Please God, Help Me Pass !!!

inference.py

@@ -4,172 +4,134 @@ import urllib.request
 import urllib.error
 from typing import List, Optional
 
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except ImportError:
-    pass
-
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "openai",
-# ]
-# ///
-
 from openai import OpenAI
 
-def post_json(url: str, payload: dict) -> dict:
-    data = json.dumps(payload).encode("utf-8")
-    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
-    try:
-        with urllib.request.urlopen(req) as res:
-            return json.loads(res.read().decode("utf-8"))
-    except urllib.error.HTTPError as e:
-        raise Exception(f"HTTP Error {e.code}: {e.read().decode('utf-8')}")
+# ── CRITICAL: Use ONLY validator-injected credentials. No fallbacks. ──────────
+API_BASE_URL = os.environ["API_BASE_URL"]   # raises KeyError if not injected — intentional
+API_KEY      = os.environ["API_KEY"]        # raises KeyError if not injected — intentional
+MODEL_NAME   = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://localhost:7860")
 
-API_BASE_URL = os.getenv("API_BASE_URL")  # No default - must be injected
-API_KEY = os.getenv("API_KEY")            # No default - must be injected
+TASK_NAME  = "schedule-optimization"
+BENCHMARK  = "cognitive-load-manager"
+MAX_STEPS  = 50
+SUCCESS_SCORE_THRESHOLD = 0.5
 
-if not API_BASE_URL or not API_KEY:
-    raise RuntimeError("[FATAL] API_BASE_URL and API_KEY must be injected by the validator.")
-ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://localhost:7860")
-MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
-HF_TOKEN = os.getenv("HF_TOKEN")  # kept for local dev / backward compat
 
-TASK_NAME = "schedule-optimization"
-BENCHMARK = "cognitive-load-manager"
-SUCCESS_SCORE_THRESHOLD = 0.5  # Need 50% score basically
-MAX_STEPS = 50
+def post_json(url: str, payload: dict) -> dict:
+    data = json.dumps(payload).encode("utf-8")
+    req  = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req) as res:
+        return json.loads(res.read().decode("utf-8"))
+
 
 def log_start(task: str, env: str, model: str) -> None:
     print(f"[START] task={task} env={env} model={model}", flush=True)
 
 def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
-    error_val = error if error else "null"
-    done_val = str(done).lower()
-    print(
-        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
-        flush=True,
-    )
+    print(f"[STEP] step={step} action={action} reward={reward:.2f} done={str(done).lower()} error={error or 'null'}", flush=True)
 
 def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
     rewards_str = ",".join(f"{r:.2f}" for r in rewards)
     print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
 
+
 def main():
-    # Initialize OpenAI client with the hackathon proxy.
-    # API_BASE_URL and API_KEY are injected by the validator — never bypass them.
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    # Initialize client using ONLY the validator-provided proxy credentials
+    client = OpenAI(
+        base_url=API_BASE_URL,
+        api_key=API_KEY,
+    )
 
-    # Initialize Environment
     task_id = os.getenv("CLM_LEVEL", "hard")
-    
     log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
-    
-    # 1. Reset Environment
+
     try:
         data = post_json(f"{ENV_BASE_URL}/reset", {"task_id": task_id})
     except Exception as e:
-        log_step(step=0, action="reset", reward=0.0, done=True, error=str(e)[:50])
+        log_step(step=0, action="reset", reward=0.0, done=True, error=str(e)[:80])
         log_end(success=False, steps=0, score=0.0, rewards=[])
         return
-        
-    session_id = data["session_id"]
+
+    session_id  = data["session_id"]
     observation = data["observation"]
-    
-    done = False
-    step = 0
-    rewards = []
-    history = []
-    info = {}
-    
+    done        = False
+    step        = 0
+    rewards     = []
+    history     = []
+    info        = {}
+
     while not done and step < MAX_STEPS:
         step += 1
-        
-        # 2. Extract action via OpenAI interface (pointing to HF)
-        history_str = "\n".join(history[-5:]) if history else "No previous actions."
-        system_prompt = """
-You are an AI task scheduler managing cognitive load.
-CRITICAL RULES:
-1. If "fatigue_level" is "high" or "medium", output {"type": "break"}. Do NOT work until fatigue is "low".
-2. If "stress_warning" is true, {"type": "break"} reduces stress safely.
-3. Find tasks where "progress" < 1.0. Output {"type": "work", "task_id": "<id>"}. Do NOT work on 1.0 tasks.
-4. Respond ONLY with raw JSON format. No markdown blocks.
-Valid actions: {"type": "work", "task_id": "id"}, {"type": "break"}, {"type": "delay"}, {"type": "switch", "task_id": "id"}
-"""
-        user_prompt = f"""
-Previous 5 Steps History:
-{history_str}
-
-Current Observation:
-{json.dumps(observation, indent=2)}
-
-What is your next action JSON?
-"""
-        action = None
+        history_str  = "\n".join(history[-5:]) if history else "No previous actions."
+        system_prompt = (
+            "You are an AI task scheduler managing cognitive load.\n"
+            "RULES:\n"
+            "1. If fatigue_level is 'high' or 'medium', output {\"type\": \"break\"}.\n"
+            "2. If stress_warning is true, output {\"type\": \"break\"}.\n"
+            "3. Find tasks where progress < 1.0 and output {\"type\": \"work\", \"task_id\": \"<id>\"}.\n"
+            "4. Respond ONLY with raw JSON. No markdown."
+        )
+        user_prompt = (
+            f"Previous 5 steps:\n{history_str}\n\n"
+            f"Observation:\n{json.dumps(observation, indent=2)}\n\n"
+            "Next action JSON?"
+        )
+
+        action    = None
         error_msg = None
-        
+
         try:
-            completion = client.chat.completions.create(
+            completion  = client.chat.completions.create(
                 model=MODEL_NAME,
                 messages=[
-                    {"role": "system", "content": system_prompt.strip()},
-                    {"role": "user", "content": user_prompt.strip()}
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user",   "content": user_prompt},
                 ],
                 temperature=0.1,
-                max_tokens=150
+                max_tokens=150,
             )
-            action_text = (completion.choices[0].message.content or "").strip()
-            # strip potential code blocks if model hallucinates them
-            if action_text.startswith("```json"): action_text = action_text[7:]
-            if action_text.endswith("```"): action_text = action_text[:-3]
-            
-            start_idx = action_text.find("{")
-            end_idx = action_text.rfind("}")
-            if start_idx != -1 and end_idx != -1:
-                json_str = action_text[start_idx:end_idx+1]
-                action = json.loads(json_str)
-        except Exception as e:
-            error_msg = str(e)[:50]
-        
-        # Fallback heuristic logic if action could not be parsed
+            text = (completion.choices[0].message.content or "").strip()
+            text = text.removeprefix("```json").removesuffix("```").strip()
+            s, e = text.find("{"), text.rfind("}")
+            if s != -1 and e != -1:
+                action = json.loads(text[s:e+1])
+        except Exception as ex:
+            error_msg = str(ex)[:80]
+
+        # Fallback if LLM call failed or returned unparseable output
         if not action:
-            tasks = observation.get("tasks", [])
-            incomp = [t for t in tasks if t.get("progress", 0.0) < 1.0]
-            if observation.get("visible_state", {}).get("fatigue_level") == "high":
+            tasks   = observation.get("tasks", [])
+            incomp  = [t for t in tasks if t.get("progress", 0.0) < 1.0]
+            fatigue = observation.get("visible_state", {}).get("fatigue_level", "low")
+            if fatigue in ("high", "medium"):
                 action = {"type": "break"}
             elif incomp:
                 action = {"type": "work", "task_id": incomp[0]["id"]}
             else:
                 action = {"type": "delay"}
 
-        # Stringify action densely for stdout formatting
-        action_str = json.dumps(action).replace(" ", "")
-        
-        # 3. Process action in Env
+        action_str = json.dumps(action, separators=(",", ":"))
+
         try:
-            step_data = post_json(f"{ENV_BASE_URL}/step", {
-                "session_id": session_id,
-                "action": action
-            })
-            
+            step_data   = post_json(f"{ENV_BASE_URL}/step", {"session_id": session_id, "action": action})
             observation = step_data["observation"]
-            reward = step_data.get("reward", 0.0)
-            done = step_data.get("done", False)
-            info = step_data.get("info", {})
-        except Exception as e:
-            reward = 0.0
-            done = True
-            error_msg = error_msg or str(e)[:50]
-            
+            reward      = step_data.get("reward", 0.0)
+            done        = step_data.get("done", False)
+            info        = step_data.get("info", {})
+        except Exception as ex:
+            reward    = 0.0
+            done      = True
+            error_msg = error_msg or str(ex)[:80]
+
         rewards.append(reward)
-        history.append(f"Step {step} Action: {action_str} -> Reward: {reward}")
+        history.append(f"Step {step}: {action_str} -> reward={reward:.2f}")
         log_step(step=step, action=action_str, reward=reward, done=done, error=error_msg)
 
-    score = info.get("final_score", 0.0)
+    score   = info.get("final_score", 0.0)
     success = score >= SUCCESS_SCORE_THRESHOLD
     log_end(success=success, steps=step, score=score, rewards=rewards)
 
+
 if __name__ == "__main__":
     main()