Upload folder using huggingface_hub

inference.py

@@ -1,14 +1,17 @@
 import asyncio
+import json
 import os
 import textwrap
+import urllib.request
 from typing import List, Optional
 
-from openai import OpenAI
+try:
+    from dotenv import load_dotenv
+    load_dotenv(override=True)
+except ImportError:
+    pass
 
 from my_env_v4 import MyEnvV4Action, MyEnvV4Env
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
 
 API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
 MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4o-mini")
@@ -71,30 +74,49 @@ def build_user_prompt(step: int, last_echoed: str, last_reward: float, history:
     ).strip()
 
 
-def get_model_message(client: OpenAI, step: int, last_echoed: str, last_reward: float, history: List[str]) -> str:
+def get_model_message(api_key: str, step: int, last_echoed: str, last_reward: float, history: List[str]) -> str:
     user_prompt = build_user_prompt(step, last_echoed, last_reward, history)
+    
+    headers = {
+        "Content-Type": "application/json",
+    }
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+        
+    data = {
+        "model": MODEL_NAME,
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt},
+        ],
+        "temperature": TEMPERATURE,
+        "max_tokens": MAX_TOKENS,
+        "stream": False
+    }
+    
     try:
-        completion = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": user_prompt},
-            ],
-            temperature=TEMPERATURE,
-            max_tokens=MAX_TOKENS,
-            stream=False,
+        url = f"{API_BASE_URL.rstrip('/')}/chat/completions"
+        req = urllib.request.Request(
+            url,
+            headers=headers,
+            data=json.dumps(data).encode("utf-8"),
+            method="POST"
         )
-        text = (completion.choices[0].message.content or "").strip()
-        return text if text else "hello"
+        with urllib.request.urlopen(req, timeout=30) as response:
+            result = json.loads(response.read().decode("utf-8"))
+            text = (result.get("choices", [{}])[0].get("message", {}).get("content") or "").strip()
+            return text if text else "hello"
     except Exception as exc:
         print(f"[DEBUG] Model request failed: {exc}", flush=True)
         return "hello"
 
 
 async def main() -> None:
-    client = OpenAI(base_url=API_BASE_URL, api_key=_api_key)
-
-    env = await MyEnvV4Env.from_docker_image(LOCAL_IMAGE_NAME)
+    try:
+        env = await MyEnvV4Env.from_docker_image(LOCAL_IMAGE_NAME)
+    except Exception as e:
+        print(f"[DEBUG] env init failed: {e}", flush=True)
+        return
 
     history: List[str] = []
     rewards: List[float] = []
@@ -105,26 +127,37 @@ async def main() -> None:
     log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
 
     try:
-        result = await env.reset() # OpenENV.reset()
-        last_echoed = result.observation.echoed_message
+        try:
+            result = await env.reset() # OpenENV.reset()
+        except Exception as e:
+            print(f"[DEBUG] env.reset() failed: {e}", flush=True)
+            log_end(success=False, steps=0, rewards=[])
+            return
+
+        last_echoed = getattr(result.observation, "echoed_message", "")
         last_reward = 0.0
 
         for step in range(1, MAX_STEPS + 1):
-            if result.done:
+            if getattr(result, "done", False):
                 break
 
-            message = get_model_message(client, step, last_echoed, last_reward, history)
+            message = get_model_message(_api_key or "", step, last_echoed, last_reward, history)
 
-            result = await env.step(MyEnvV4Action(message=message))
-            obs = result.observation
+            try:
+                result = await env.step(MyEnvV4Action(message=message))
+            except Exception as e:
+                print(f"[DEBUG] env.step() failed: {e}", flush=True)
+                log_step(step=step, action=repr(message), reward=0.0, done=True, error=str(e))
+                break
 
-            reward = result.reward or 0.0
-            done = result.done
+            obs = result.observation
+            reward = getattr(result, "reward", 0.0) or 0.0
+            done = getattr(result, "done", False)
             error = getattr(result, "error", None)
 
             rewards.append(reward)
             steps_taken = step
-            last_echoed = obs.echoed_message
+            last_echoed = getattr(obs, "echoed_message", "")
             last_reward = reward
 
             # Formatting action to avoid newlines breaking stdout tracking format rules
@@ -148,4 +181,7 @@ async def main() -> None:
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"[DEBUG] main() unhandled exception {e}", flush=True)

requirements.txt

@@ -2,3 +2,5 @@ fastapi
 uvicorn
 pydantic
 duckdb
+openai
+python-dotenv