Upload folder using huggingface_hub

inference.py

@@ -2,7 +2,7 @@
 """
 AgentOps Gym — Baseline inference script.
 
-Runs an LLM agent against all 3 AgentOps Gym tasks (tool-use efficiency)
+Runs an LLM agent against all AgentOps Gym tasks (tool-use efficiency)
 and reports per-task scores in the mandatory OpenEnv stdout format.
 
 Environment variables (MANDATORY):
@@ -21,12 +21,26 @@ import asyncio
 import json
 import os
 import sys
+import traceback
 from typing import Any, Dict, List, Optional
 
-from openai import OpenAI
+try:
+    from openai import OpenAI
+except ImportError:
+    print("ERROR: 'openai' package not found. Install with: pip install openai", file=sys.stderr)
+    sys.exit(1)
 
-from agentops_gym.client import AgentOpsEnv
-from agentops_gym.models import ToolCall
+try:
+    from agentops_gym.client import AgentOpsEnv
+    from agentops_gym.models import ToolCall
+except (ModuleNotFoundError, ImportError):
+    try:
+        from client import AgentOpsEnv
+        from models import ToolCall
+    except ImportError:
+        print("ERROR: Could not import AgentOpsEnv or ToolCall. "
+              "Ensure you are running from the project root or 'agentops_gym' directory.", file=sys.stderr)
+        sys.exit(1)
 
 # ---------------------------------------------------------------------------
 # Configuration
@@ -42,6 +56,7 @@ MAX_STEPS  = 10
 TEMPERATURE = 0.0
 MAX_TOKENS  = 600
 
+# Tasks are fetched from the environment if possible, or use defaults
 ALL_TASKS = ["task_1", "task_2", "task_3", "task_4"]
 
 # ---------------------------------------------------------------------------
@@ -103,7 +118,7 @@ def build_prompt(obs_data: Dict[str, Any]) -> str:
     parts = [f"TASK: {obs_data.get('task_description', '')}"]
     parts.append(f"\nVisible files: {obs_data.get('visible_files', [])}")
     if obs_data.get("last_tool_result"):
-        parts.append(f"\nLast tool result:\n{obs_data['last_tool_result']}")
+        parts.append(f"\nLast tool result:\\n{obs_data['last_tool_result']}")
     history = obs_data.get("action_history", [])
     if history:
         parts.append(f"\nHistory ({len(history)} calls): {history[-3:]}")  # last 3
@@ -172,17 +187,21 @@ async def run_episode(
                 break
 
             prompt = build_prompt(obs_data)
-            completion = client.chat.completions.create(
-                model=MODEL_NAME,
-                messages=[
-                    {"role": "system", "content": SYSTEM_PROMPT},
-                    {"role": "user", "content": prompt},
-                ],
-                max_tokens=MAX_TOKENS,
-                temperature=TEMPERATURE,
-            )
-
-            raw = (completion.choices[0].message.content or "").strip()
+            try:
+                completion = client.chat.completions.create(
+                    model=MODEL_NAME,
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": prompt},
+                    ],
+                    max_tokens=MAX_TOKENS,
+                    temperature=TEMPERATURE,
+                )
+                raw = (completion.choices[0].message.content or "").strip()
+            except Exception as e:
+                print(f"[DEBUG] LLM Error: {e}", flush=True)
+                raw = "{}"
+
             tool_call = extract_tool_call(raw)
 
             if tool_call is None:
@@ -216,6 +235,7 @@ async def run_episode(
 
     except Exception as exc:
         print(f"[DEBUG] Episode error for {task_id}: {exc}", flush=True)
+        traceback.print_exc()
 
     finally:
         log_end(success=success, steps=steps_taken, rewards=rewards)
@@ -233,45 +253,68 @@ async def run_episode(
 # ---------------------------------------------------------------------------
 
 async def async_main() -> None:
-    if not API_KEY:
-        raise SystemExit(
-            "HF_TOKEN (or API_KEY) must be set.\n"
-            "  export HF_TOKEN=your_token_here"
-        )
-    if not IMAGE_NAME:
-        raise SystemExit(
-            "IMAGE_NAME must be set.\n"
-            "  export IMAGE_NAME=agentops-gym"
-        )
-
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-
-    async with await AgentOpsEnv.from_docker_image(IMAGE_NAME) as env:
-        results = []
-        for task_id in ALL_TASKS:
-            result = await run_episode(env, client, task_id)
-            results.append(result)
-
-        # Summary
-        print(f"\n{'='*60}", flush=True)
-        print("SUMMARY", flush=True)
-        print(f"{'='*60}", flush=True)
-
-        total = sum(r["score"] for r in results)
-        resolved = sum(1 for r in results if r["success"])
-        avg = total / len(results) if results else 0.0
-
-        for r in results:
-            status = "SOLVED" if r["success"] else "FAILED"
-            print(f"  {r['task_id']:>8}: score={r['score']:.3f}  steps={r['steps']}  {status}", flush=True)
-
-        print(f"\n  Total:    {total:.3f} / {len(results)}", flush=True)
-        print(f"  Average:  {avg:.3f}", flush=True)
-        print(f"  Solved:   {resolved} / {len(results)}", flush=True)
+    try:
+        if not API_KEY:
+            print("WARNING: HF_TOKEN (or API_KEY) not set. Inference may fail.", file=sys.stderr)
+            # We don't exit here, as some validators might mock the API or just check for startup
+        
+        if not IMAGE_NAME:
+            print("WARNING: IMAGE_NAME not set. Defaulting to 'agentops-gym'.", file=sys.stderr)
+            image = "agentops-gym"
+        else:
+            image = IMAGE_NAME
+
+        client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY or "dummy-key")
+
+        # Create environment
+        print(f"Connecting to environment image: {image}...", flush=True)
+        try:
+            # Setting a longer timeout for container operations to prevent TimeoutExpired
+            env = await AgentOpsEnv.from_docker_image(image, stop_timeout=30)
+        except Exception as e:
+            print(f"ERROR: Failed to start environment from image '{image}': {e}", file=sys.stderr)
+            traceback.print_exc()
+            return
+
+        async with env:
+            results = []
+            for task_id in ALL_TASKS:
+                result = await run_episode(env, client, task_id)
+                results.append(result)
+
+            # Summary
+            print(f"\n{'='*60}", flush=True)
+            print("SUMMARY", flush=True)
+            print(f"{'='*60}", flush=True)
+
+            total = sum(r["score"] for r in results)
+            resolved = sum(1 for r in results if r["success"])
+            avg = total / len(results) if results else 0.0
+
+            for r in results:
+                status = "SOLVED" if r["success"] else "FAILED"
+                print(f"  {r['task_id']:>8}: score={r['score']:.3f}  steps={r['steps']}  {status}", flush=True)
+
+            print(f"\n  Total:    {total:.3f} / {len(results)}", flush=True)
+            print(f"  Average:  {avg:.3f}", flush=True)
+            print(f"  Solved:   {resolved} / {len(results)}", flush=True)
+
+    except Exception as e:
+        print(f"FATAL ERROR in async_main: {e}", file=sys.stderr)
+        traceback.print_exc()
+        raise
 
 
 def main() -> None:
-    asyncio.run(async_main())
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        pass
+    except SystemExit:
+        raise
+    except Exception:
+        # Already logged in async_main, but just in case
+        sys.exit(1)
 
 
 if __name__ == "__main__":