bug fixes in inference.py

.gitignore

@@ -13,4 +13,5 @@ baseline_scores.json
 .pytest_cache/
 MySolution.md
 nltk_data
-eval_results.json
+eval_results.json
+groq.py

inference.py

@@ -3,13 +3,12 @@ inference.py
 ------------
 Inference script — Smart Contract Audit RL Environment.
 
-Implements agents for all three tasks using the OpenAI-compatible client.
+Implements agents for all three tasks using the Groq client.
 Emits mandatory structured stdout in the OpenEnv format.
 
 MANDATORY ENV VARS:
-  API_BASE_URL   LLM API endpoint   (default: https://api.openai.com/v1)
-  MODEL_NAME     Model identifier   (default: gpt-4o-mini)
-  HF_TOKEN       API key / HF token
+  GROQ_API_KEY   Groq API key (required)
+  MODEL_NAME     Model identifier   (default: openai/gpt-oss-20b)
 
 MANDATORY STDOUT FORMAT (per episode):
   [START] task=<id> env=smart-contract-audit model=<model>
@@ -49,6 +48,8 @@ HF_TOKEN     = os.getenv("HF_TOKEN",     "")
 if not HF_TOKEN:
     raise RuntimeError("HF_TOKEN environment variable not set")
 
+client = OpenAI(api_key=HF_TOKEN, base_url=API_BASE_URL)
+
 # Benchmark / environment identifier (constant for this env)
 ENV_BENCHMARK = "smart-contract-audit"
 
@@ -58,13 +59,31 @@ SEED_BASE    = 42
 
 # Max steps per task
 MAX_STEPS_T1 = 15
-MAX_STEPS_T2 = 10
-MAX_STEPS_T3 = 12
+MAX_STEPS_T2 = 15
+MAX_STEPS_T3 = 15
 
 # A grader_score >= this is considered a "success" for the [END] line
 SUCCESS_SCORE_THRESHOLD = 0.5
 
-client = OpenAI(api_key=HF_TOKEN, base_url=API_BASE_URL)
+# ─────────────────────────────────────────────────────────────────────────────
+# Unified LLM call function
+# ─────────────────────────────────────────────────────────────────────────────
+
+def get_llm_response(
+    messages: List[Dict[str, str]],
+    max_tokens: int = 200,
+    temperature: float = 0.0,
+) -> str:
+    """
+    Call the Groq LLM with the given messages and parameters.
+    Returns the response content as a string.
+    Raises an exception on failure (to be caught by the caller).
+    """
+    completion = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=messages,          # type: ignore
+    )
+    return completion.choices[0].message.content.strip()  # type: ignore
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -113,9 +132,6 @@ def log_end(
 
 def _t1_user_msg(obs: Dict[str, Any]) -> str:
     return (
-        f"Contract: {obs['contract_name']}\n"
-        f"Description: {obs['contract_description']}\n"
-        f"Step: {obs['step_count']} | Reward so far: {obs['cumulative_reward']:.2f}\n\n"
         f"Last action : {obs['last_action'] or 'None'}\n"
         f"Last result : {obs['last_action_result'] or 'Episode just started.'}"
     )
@@ -126,9 +142,9 @@ def _run_t1_episode(env: Task1Environment, seed: int, ep_num: int) -> Dict[str,
     r   = env.reset(seed=seed)
     obs = r.observation.model_dump()
 
-    log_start(task="task1_vuln_detection", env=ENV_BENCHMARK, model=MODEL_NAME) # type: ignore
+    log_start(task="task1_vuln_detection", env=ENV_BENCHMARK, model=MODEL_NAME)
 
-    messages: List[ChatCompletionMessageParam] = [ # type: ignore
+    messages: List[Dict[str, str]] = [
         {"role": "system", "content": T1_SYSTEM}
     ]
     step_rewards: List[float] = []
@@ -140,11 +156,7 @@ def _run_t1_episode(env: Task1Environment, seed: int, ep_num: int) -> Dict[str,
         for step in range(1, MAX_STEPS_T1 + 1):
             messages.append({"role": "user", "content": _t1_user_msg(obs)})
             try:
-                resp = client.chat.completions.create(
-                    model=MODEL_NAME, messages=messages, # type: ignore
-                    max_tokens=200, temperature=0.0,
-                )
-                raw = resp.choices[0].message.content.strip() # type: ignore
+                raw = get_llm_response(messages, max_tokens=200, temperature=0.0)
                 error_msg = None
             except Exception as e:
                 raw = ""
@@ -169,8 +181,7 @@ def _run_t1_episode(env: Task1Environment, seed: int, ep_num: int) -> Dict[str,
             log_step(step=step, action=at.value, reward=r_val, done=done, error=error_msg)
 
             if done:
-                v = r_val
-                grader_score = 1.0 if v >= 4.9 else (0.5 if v >= 0.9 else 0.0)
+                grader_score = r_val
                 break
 
             time.sleep(0.3)
@@ -196,10 +207,8 @@ def _run_t1_episode(env: Task1Environment, seed: int, ep_num: int) -> Dict[str,
 def _t2_user_msg(obs: Dict[str, Any]) -> str:
     extra = obs.get("extra", {})
     return (
-        f"Contract : {obs['contract_name']}\n"
-        f"Function : {extra.get('target_function', '?')}  "
-        f"({extra.get('target_signature', '')})\n"
-        f"Step: {obs['step_count']} | Reward so far: {obs['cumulative_reward']:.2f}\n\n"
+        f"Target Function : {extra.get('target_function', '?')}  "
+        # f"({extra.get('target_signature', '')})\n"
         f"Last action : {obs['last_action'] or 'None'}\n"
         f"Last result :\n{obs['last_action_result'] or 'Episode just started.'}"
     )
@@ -211,9 +220,9 @@ def _run_t2_episode(env: Task2Environment, seed: int, ep_num: int) -> Dict[str,
     obs = r.observation.model_dump()
     fn  = obs["extra"].get("target_function", "?")
 
-    log_start(task="task2_property_discovery", env=ENV_BENCHMARK, model=MODEL_NAME) # type: ignore
+    log_start(task="task2_property_discovery", env=ENV_BENCHMARK, model=MODEL_NAME)
 
-    messages: List[ChatCompletionMessageParam] = [ # type: ignore
+    messages: List[Dict[str, str]] = [
         {"role": "system", "content": T2_SYSTEM}
     ]
     step_rewards: List[float] = []
@@ -225,11 +234,7 @@ def _run_t2_episode(env: Task2Environment, seed: int, ep_num: int) -> Dict[str,
         for step in range(1, MAX_STEPS_T2 + 1):
             messages.append({"role": "user", "content": _t2_user_msg(obs)})
             try:
-                resp = client.chat.completions.create(
-                    model=MODEL_NAME, messages=messages, # type: ignore
-                    max_tokens=400, temperature=0.0,
-                )
-                raw = resp.choices[0].message.content.strip() # type: ignore
+                raw = get_llm_response(messages, max_tokens=400, temperature=0.0)
                 error_msg = None
             except Exception as e:
                 raw = ""
@@ -254,7 +259,7 @@ def _run_t2_episode(env: Task2Environment, seed: int, ep_num: int) -> Dict[str,
             log_step(step=step, action=at.value, reward=r_val, done=done, error=error_msg)
 
             if done:
-                grader_score = round(r_val / 5.0, 3) if r_val > 0 else 0.0
+                grader_score = r_val
                 break
 
             time.sleep(0.3)
@@ -281,9 +286,7 @@ def _run_t2_episode(env: Task2Environment, seed: int, ep_num: int) -> Dict[str,
 def _t3_user_msg(obs: Dict[str, Any]) -> str:
     extra = obs.get("extra", {})
     return (
-        f"Contract  : {obs['contract_name']}\n"
-        f"Property  : {extra.get('property_english', '(none)')}\n"
-        f"Step: {obs['step_count']} | Reward so far: {obs['cumulative_reward']:.2f}\n\n"
+        f"Verify Property  : {extra.get('property_english', '(none)')}\n"
         f"Last action : {obs['last_action'] or 'None'}\n"
         f"Last result :\n{obs['last_action_result'] or 'Episode just started.'}"
     )
@@ -294,9 +297,9 @@ def _run_t3_episode(env: Task3Environment, seed: int, ep_num: int) -> Dict[str,
     r   = env.reset(seed=seed)
     obs = r.observation.model_dump()
 
-    log_start(task="task3_rule_checker", env=ENV_BENCHMARK, model=MODEL_NAME) # type: ignore
+    log_start(task="task3_rule_checker", env=ENV_BENCHMARK, model=MODEL_NAME)
 
-    messages: List[ChatCompletionMessageParam] = [ # type: ignore
+    messages: List[Dict[str, str]] = [
         {"role": "system", "content": T3_SYSTEM}
     ]
     step_rewards: List[float] = []
@@ -308,11 +311,7 @@ def _run_t3_episode(env: Task3Environment, seed: int, ep_num: int) -> Dict[str,
         for step in range(1, MAX_STEPS_T3 + 1):
             messages.append({"role": "user", "content": _t3_user_msg(obs)})
             try:
-                resp = client.chat.completions.create(
-                    model=MODEL_NAME, messages=messages, # type: ignore
-                    max_tokens=200, temperature=0.0,
-                )
-                raw = resp.choices[0].message.content.strip()   # type: ignore
+                raw = get_llm_response(messages, max_tokens=200, temperature=0.0)
                 error_msg = None
             except Exception as e:
                 raw = ""
@@ -337,8 +336,7 @@ def _run_t3_episode(env: Task3Environment, seed: int, ep_num: int) -> Dict[str,
             log_step(step=step, action=at.value, reward=r_val, done=done, error=error_msg)
 
             if done:
-                v = r_val
-                grader_score = 1.0 if v >= 4.9 else (0.3 if v >= 1.0 else 0.0)
+                grader_score = r_val
                 break
 
             time.sleep(0.3)
@@ -367,13 +365,11 @@ def run_task1(n: int = NUM_EPISODES) -> Dict[str, Any]:
     env      = Task1Environment()
     episodes = [_run_t1_episode(env, SEED_BASE + i, i + 1) for i in range(n)]
     avg_s    = sum(e["grader_score"] for e in episodes) / n
-    avg_r    = sum(e["cumulative_reward"] for e in episodes) / n
     print(f"\n  Avg grader score : {avg_s:.3f}", flush=True)
-    print(f"  Avg cum reward   : {avg_r:.2f}", flush=True)
     return {
         "task_id": "task1_vuln_detection", "name": "Targeted Vulnerability Detection",
         "status": "active", "num_episodes": n, "episodes": episodes,
-        "avg_grader_score": avg_s, "avg_cumulative_reward": avg_r,
+        "avg_grader_score": avg_s
     }
 
 
@@ -386,11 +382,10 @@ def run_task2(n: int = NUM_EPISODES) -> Dict[str, Any]:
     avg_s    = sum(e["grader_score"] for e in episodes) / n
     avg_r    = sum(e["cumulative_reward"] for e in episodes) / n
     print(f"\n  Avg grader score : {avg_s:.3f}", flush=True)
-    print(f"  Avg cum reward   : {avg_r:.2f}", flush=True)
     return {
         "task_id": "task2_property_discovery", "name": "Property Discovery",
         "status": "active", "num_episodes": n, "episodes": episodes,
-        "avg_grader_score": avg_s, "avg_cumulative_reward": avg_r,
+        "avg_grader_score": avg_s
     }
 
 
@@ -403,11 +398,10 @@ def run_task3(n: int = NUM_EPISODES) -> Dict[str, Any]:
     avg_s    = sum(e["grader_score"] for e in episodes) / n
     avg_r    = sum(e["cumulative_reward"] for e in episodes) / n
     print(f"\n  Avg grader score : {avg_s:.3f}", flush=True)
-    print(f"  Avg cum reward   : {avg_r:.2f}", flush=True)
     return {
         "task_id": "task3_rule_checker", "name": "Rule Checker",
         "status": "active", "num_episodes": n, "episodes": episodes,
-        "avg_grader_score": avg_s, "avg_cumulative_reward": avg_r,
+        "avg_grader_score": avg_s
     }
 
 
@@ -418,7 +412,7 @@ def run_task3(n: int = NUM_EPISODES) -> Dict[str, Any]:
 async def main() -> None:
     """Async entry point (wraps sync env calls; asyncio.run() expected by caller)."""
     print("Smart Contract Audit RL Environment — Baseline Inference", flush=True)
-    print(f"Model: {MODEL_NAME} | Base URL: {API_BASE_URL}", flush=True)
+    print(f"Model: {MODEL_NAME} | Groq API", flush=True)
 
     t1 = run_task1(NUM_EPISODES)
     t2 = run_task2(NUM_EPISODES)
@@ -426,7 +420,7 @@ async def main() -> None:
 
     results = {
         "model":    MODEL_NAME,
-        "base_url": API_BASE_URL,
+        "backend":  "groq",
         "tasks":    [t1, t2, t3],
     }
     overall = sum(t["avg_grader_score"] for t in results["tasks"]) / 3
@@ -445,4 +439,4 @@ async def main() -> None:
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

org_inference.py

@@ -1,449 +0,0 @@
-"""
-inference.py
-------------
-Inference script — Smart Contract Audit RL Environment.
-
-Implements agents for all three tasks using the OpenAI-compatible client.
-Emits mandatory structured stdout in the OpenEnv format.
-
-MANDATORY ENV VARS:
-  API_BASE_URL   LLM API endpoint   (default: https://api.openai.com/v1)
-  MODEL_NAME     Model identifier   (default: gpt-4o-mini)
-  HF_TOKEN       API key / HF token
-
-MANDATORY STDOUT FORMAT (per episode):
-  [START] task=<id> env=smart-contract-audit model=<model>
-  [STEP]  step=<n> action=<str> reward=<0.00> done=<true|false> error=<str|null>
-  [END]   success=<true|false> steps=<n> score=<0.000> rewards=<r1,r2,...>
-
-Usage:
-  python inference.py
-
-Output:
-  Structured stdout per episode, plus baseline_scores.json summary.
-"""
-
-import asyncio
-import json
-import os
-import sys
-import time
-from typing import Any, Dict, List, Optional
-
-from openai import OpenAI
-
-from server import Task1Environment, Task2Environment, Task3Environment
-from env.schemas import Action, ActionType
-from utils import T1_SYSTEM, T2_SYSTEM, T3_SYSTEM
-from dotenv import dotenv_values
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Configuration
-# ─────────────────────────────────────────────────────────────────────────────
-
-config = dotenv_values(".env")
-API_BASE_URL = config.get("API_BASE_URL", "https://api.openai.com/v1")
-MODEL_NAME   = config.get("MODEL_NAME",   "gpt-4o")
-HF_TOKEN     = config.get("HF_TOKEN",     "")
-
-if not HF_TOKEN:
-    print("[WARN] HF_TOKEN not set — API calls may fail.", file=sys.stderr)
-    exit(1)
-
-# Benchmark / environment identifier (constant for this env)
-ENV_BENCHMARK = "smart-contract-audit"
-
-# Episodes per task
-NUM_EPISODES = 3
-SEED_BASE    = 42
-
-# Max steps per task
-MAX_STEPS_T1 = 15
-MAX_STEPS_T2 = 10
-MAX_STEPS_T3 = 12
-
-# A grader_score >= this is considered a "success" for the [END] line
-SUCCESS_SCORE_THRESHOLD = 0.5
-
-client = OpenAI(api_key=HF_TOKEN, base_url=API_BASE_URL)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Mandatory stdout helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def log_start(task: str, env: str, model: str) -> None:
-    """Emit the [START] line — one per episode."""
-    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,
-) -> None:
-    """Emit a [STEP] line — one per env.step() call."""
-    error_val = error if error else "null"
-    print(
-        f"[STEP] step={step} action={action} "
-        f"reward={reward:.2f} done={str(done).lower()} error={error_val}",
-        flush=True,
-    )
-
-
-def log_end(
-    success: bool,
-    steps: int,
-    score: float,
-    rewards: List[float],
-) -> None:
-    """Emit the [END] line — one per episode, always emitted."""
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
-    print(
-        f"[END] success={str(success).lower()} steps={steps} "
-        f"score={score:.3f} rewards={rewards_str}",
-        flush=True,
-    )
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Task 1 — Targeted Vulnerability Detection
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _t1_user_msg(obs: Dict[str, Any]) -> str:
-    return (
-        f"Contract: {obs['contract_name']}\n"
-        f"Description: {obs['contract_description']}\n"
-        f"Step: {obs['step_count']} | Reward so far: {obs['cumulative_reward']:.2f}\n\n"
-        f"Last action : {obs['last_action'] or 'None'}\n"
-        f"Last result : {obs['last_action_result'] or 'Episode just started.'}"
-    )
-
-
-def _run_t1_episode(env: Task1Environment, seed: int, ep_num: int) -> Dict[str, Any]:
-    """Run one Task 1 episode; emit [START]/[STEP]/[END]."""
-    r   = env.reset(seed=seed)
-    obs = r.observation.model_dump()
-
-    log_start(task="task1_vuln_detection", env=ENV_BENCHMARK, model=MODEL_NAME) # type: ignore
-
-    messages: List[ChatCompletionMessageParam] = [ # type: ignore
-        {"role": "system", "content": T1_SYSTEM}
-    ]
-    step_rewards: List[float] = []
-    grader_score  = 0.0
-    steps_taken   = 0
-    error_msg: Optional[str] = None
-
-    try:
-        for step in range(1, MAX_STEPS_T1 + 1):
-            messages.append({"role": "user", "content": _t1_user_msg(obs)})
-            try:
-                resp = client.chat.completions.create(
-                    model=MODEL_NAME, messages=messages, # type: ignore
-                    max_tokens=200, temperature=0.0,
-                )
-                raw = resp.choices[0].message.content.strip() # type: ignore
-                error_msg = None
-            except Exception as e:
-                raw = ""
-                error_msg = str(e)[:80]
-                print(f"[DEBUG] T1 LLM error ep={ep_num} step={step}: {e}", file=sys.stderr)
-
-            try:
-                parsed = json.loads(raw)
-                at     = ActionType(parsed["action"])
-                params = parsed.get("params", {})
-            except Exception:
-                at, params = ActionType.LIST_FUNCTIONS, {}
-
-            messages.append({"role": "assistant", "content": raw})
-            result = env.step(Action(action_type=at, params=params))
-            obs    = result.observation.model_dump()
-            r_val  = result.reward.value
-            done   = result.done
-
-            step_rewards.append(r_val)
-            steps_taken = step
-            log_step(step=step, action=at.value, reward=r_val, done=done, error=error_msg)
-
-            if done:
-                v = r_val
-                grader_score = 1.0 if v >= 4.9 else (0.5 if v >= 0.9 else 0.0)
-                break
-
-            time.sleep(0.3)
-
-    finally:
-        success = grader_score >= SUCCESS_SCORE_THRESHOLD
-        log_end(success=success, steps=steps_taken, score=grader_score, rewards=step_rewards)
-
-    return {
-        "episode":          ep_num,
-        "seed":             seed,
-        "contract":         obs["contract_name"],
-        "grader_score":     grader_score,
-        "cumulative_reward": obs["cumulative_reward"],
-    }
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Task 2 — Property Discovery
-# ─────────────────────────────────────────────────────────────────────────────
-
-
-def _t2_user_msg(obs: Dict[str, Any]) -> str:
-    extra = obs.get("extra", {})
-    return (
-        f"Contract : {obs['contract_name']}\n"
-        f"Function : {extra.get('target_function', '?')}  "
-        f"({extra.get('target_signature', '')})\n"
-        f"Step: {obs['step_count']} | Reward so far: {obs['cumulative_reward']:.2f}\n\n"
-        f"Last action : {obs['last_action'] or 'None'}\n"
-        f"Last result :\n{obs['last_action_result'] or 'Episode just started.'}"
-    )
-
-
-def _run_t2_episode(env: Task2Environment, seed: int, ep_num: int) -> Dict[str, Any]:
-    """Run one Task 2 episode; emit [START]/[STEP]/[END]."""
-    r   = env.reset(seed=seed)
-    obs = r.observation.model_dump()
-    fn  = obs["extra"].get("target_function", "?")
-
-    log_start(task="task2_property_discovery", env=ENV_BENCHMARK, model=MODEL_NAME) # type: ignore
-
-    messages: List[ChatCompletionMessageParam] = [ # type: ignore
-        {"role": "system", "content": T2_SYSTEM}
-    ]
-    step_rewards: List[float] = []
-    grader_score  = 0.0
-    steps_taken   = 0
-    error_msg: Optional[str] = None
-
-    try:
-        for step in range(1, MAX_STEPS_T2 + 1):
-            messages.append({"role": "user", "content": _t2_user_msg(obs)})
-            try:
-                resp = client.chat.completions.create(
-                    model=MODEL_NAME, messages=messages, # type: ignore
-                    max_tokens=400, temperature=0.0,
-                )
-                raw = resp.choices[0].message.content.strip() # type: ignore
-                error_msg = None
-            except Exception as e:
-                raw = ""
-                error_msg = str(e)[:80]
-                print(f"[DEBUG] T2 LLM error ep={ep_num} step={step}: {e}", file=sys.stderr)
-
-            try:
-                parsed = json.loads(raw)
-                at     = ActionType(parsed["action"])
-                params = parsed.get("params", {})
-            except Exception:
-                at, params = ActionType.GET_FUNCTION_CODE, {}
-
-            messages.append({"role": "assistant", "content": raw})
-            result = env.step(Action(action_type=at, params=params))
-            obs    = result.observation.model_dump()
-            r_val  = result.reward.value
-            done   = result.done
-
-            step_rewards.append(r_val)
-            steps_taken = step
-            log_step(step=step, action=at.value, reward=r_val, done=done, error=error_msg)
-
-            if done:
-                grader_score = round(r_val / 5.0, 3) if r_val > 0 else 0.0
-                break
-
-            time.sleep(0.3)
-
-    finally:
-        success = grader_score >= SUCCESS_SCORE_THRESHOLD
-        log_end(success=success, steps=steps_taken, score=grader_score, rewards=step_rewards)
-
-    return {
-        "episode":          ep_num,
-        "seed":             seed,
-        "contract":         obs["contract_name"],
-        "function":         fn,
-        "grader_score":     grader_score,
-        "cumulative_reward": obs["cumulative_reward"],
-    }
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Task 3 — Rule Checker
-# ─────────────────────────────────────────────────────────────────────────────
-
-
-def _t3_user_msg(obs: Dict[str, Any]) -> str:
-    extra = obs.get("extra", {})
-    return (
-        f"Contract  : {obs['contract_name']}\n"
-        f"Property  : {extra.get('property_english', '(none)')}\n"
-        f"Step: {obs['step_count']} | Reward so far: {obs['cumulative_reward']:.2f}\n\n"
-        f"Last action : {obs['last_action'] or 'None'}\n"
-        f"Last result :\n{obs['last_action_result'] or 'Episode just started.'}"
-    )
-
-
-def _run_t3_episode(env: Task3Environment, seed: int, ep_num: int) -> Dict[str, Any]:
-    """Run one Task 3 episode; emit [START]/[STEP]/[END]."""
-    r   = env.reset(seed=seed)
-    obs = r.observation.model_dump()
-
-    log_start(task="task3_rule_checker", env=ENV_BENCHMARK, model=MODEL_NAME) # type: ignore
-
-    messages: List[ChatCompletionMessageParam] = [ # type: ignore
-        {"role": "system", "content": T3_SYSTEM}
-    ]
-    step_rewards: List[float] = []
-    grader_score  = 0.0
-    steps_taken   = 0
-    error_msg: Optional[str] = None
-
-    try:
-        for step in range(1, MAX_STEPS_T3 + 1):
-            messages.append({"role": "user", "content": _t3_user_msg(obs)})
-            try:
-                resp = client.chat.completions.create(
-                    model=MODEL_NAME, messages=messages, # type: ignore
-                    max_tokens=200, temperature=0.0,
-                )
-                raw = resp.choices[0].message.content.strip()   # type: ignore
-                error_msg = None
-            except Exception as e:
-                raw = ""
-                error_msg = str(e)[:80]
-                print(f"[DEBUG] T3 LLM error ep={ep_num} step={step}: {e}", file=sys.stderr)
-
-            try:
-                parsed = json.loads(raw)
-                at     = ActionType(parsed["action"])
-                params = parsed.get("params", {})
-            except Exception:
-                at, params = ActionType.LIST_FUNCTIONS, {}
-
-            messages.append({"role": "assistant", "content": raw})
-            result = env.step(Action(action_type=at, params=params))
-            obs    = result.observation.model_dump()
-            r_val  = result.reward.value
-            done   = result.done
-
-            step_rewards.append(r_val)
-            steps_taken = step
-            log_step(step=step, action=at.value, reward=r_val, done=done, error=error_msg)
-
-            if done:
-                v = r_val
-                grader_score = 1.0 if v >= 4.9 else (0.3 if v >= 1.0 else 0.0)
-                break
-
-            time.sleep(0.3)
-
-    finally:
-        success = grader_score >= SUCCESS_SCORE_THRESHOLD
-        log_end(success=success, steps=steps_taken, score=grader_score, rewards=step_rewards)
-
-    return {
-        "episode":          ep_num,
-        "seed":             seed,
-        "contract":         obs["contract_name"],
-        "grader_score":     grader_score,
-        "cumulative_reward": obs["cumulative_reward"],
-    }
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Task runners
-# ─────────────────────────────────────────────────────────────────────────────
-
-def run_task1(n: int = NUM_EPISODES) -> Dict[str, Any]:
-    print("\n" + "="*60, flush=True)
-    print("TASK 1: Targeted Vulnerability Detection", flush=True)
-    print("="*60, flush=True)
-    env      = Task1Environment()
-    episodes = [_run_t1_episode(env, SEED_BASE + i, i + 1) for i in range(n)]
-    avg_s    = sum(e["grader_score"] for e in episodes) / n
-    avg_r    = sum(e["cumulative_reward"] for e in episodes) / n
-    print(f"\n  Avg grader score : {avg_s:.3f}", flush=True)
-    print(f"  Avg cum reward   : {avg_r:.2f}", flush=True)
-    return {
-        "task_id": "task1_vuln_detection", "name": "Targeted Vulnerability Detection",
-        "status": "active", "num_episodes": n, "episodes": episodes,
-        "avg_grader_score": avg_s, "avg_cumulative_reward": avg_r,
-    }
-
-
-def run_task2(n: int = NUM_EPISODES) -> Dict[str, Any]:
-    print("\n" + "="*60, flush=True)
-    print("TASK 2: Property Discovery", flush=True)
-    print("="*60, flush=True)
-    env      = Task2Environment()
-    episodes = [_run_t2_episode(env, SEED_BASE + i, i + 1) for i in range(n)]
-    avg_s    = sum(e["grader_score"] for e in episodes) / n
-    avg_r    = sum(e["cumulative_reward"] for e in episodes) / n
-    print(f"\n  Avg grader score : {avg_s:.3f}", flush=True)
-    print(f"  Avg cum reward   : {avg_r:.2f}", flush=True)
-    return {
-        "task_id": "task2_property_discovery", "name": "Property Discovery",
-        "status": "active", "num_episodes": n, "episodes": episodes,
-        "avg_grader_score": avg_s, "avg_cumulative_reward": avg_r,
-    }
-
-
-def run_task3(n: int = NUM_EPISODES) -> Dict[str, Any]:
-    print("\n" + "="*60, flush=True)
-    print("TASK 3: Rule Checker", flush=True)
-    print("="*60, flush=True)
-    env      = Task3Environment()
-    episodes = [_run_t3_episode(env, SEED_BASE + i, i + 1) for i in range(n)]
-    avg_s    = sum(e["grader_score"] for e in episodes) / n
-    avg_r    = sum(e["cumulative_reward"] for e in episodes) / n
-    print(f"\n  Avg grader score : {avg_s:.3f}", flush=True)
-    print(f"  Avg cum reward   : {avg_r:.2f}", flush=True)
-    return {
-        "task_id": "task3_rule_checker", "name": "Rule Checker",
-        "status": "active", "num_episodes": n, "episodes": episodes,
-        "avg_grader_score": avg_s, "avg_cumulative_reward": avg_r,
-    }
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Main
-# ─────────────────────────────────────────────────────────────────────────────
-
-async def main() -> None:
-    """Async entry point (wraps sync env calls; asyncio.run() expected by caller)."""
-    print("Smart Contract Audit RL Environment — Baseline Inference", flush=True)
-    print(f"Model: {MODEL_NAME} | Base URL: {API_BASE_URL}", flush=True)
-
-    t1 = run_task1(NUM_EPISODES)
-    t2 = run_task2(NUM_EPISODES)
-    t3 = run_task3(NUM_EPISODES)
-
-    results = {
-        "model":    MODEL_NAME,
-        "base_url": API_BASE_URL,
-        "tasks":    [t1, t2, t3],
-    }
-    overall = sum(t["avg_grader_score"] for t in results["tasks"]) / 3
-    results["overall_avg_score"] = overall
-
-    print("\n" + "="*60, flush=True)
-    print("BASELINE SUMMARY", flush=True)
-    print("="*60, flush=True)
-    for t in results["tasks"]:
-        print(f"  ✅ {t['name']:40s}: {t['avg_grader_score']:.3f}", flush=True)
-    print(f"\n  Overall avg grader score: {overall:.3f}", flush=True)
-
-    with open("baseline_scores.json", "w") as f:
-        json.dump(results, f, indent=2)
-    print("\n  Scores written to baseline_scores.json", flush=True)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())