Upload folder using huggingface_hub

env/environment.py

@@ -263,3 +263,7 @@ class ProductivityEnvironment:
     def _maybe_finish(self) -> None:
         if self._step_count >= self.max_steps:
             self._done = True
+
+    def close(self) -> None:
+        """No-op close method for API parity with async/containerized envs."""
+        return None

inference.py

@@ -12,6 +12,10 @@ from env.environment import ProductivityEnvironment
 
 
 MAX_STEPS = 5
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "zai-org/GLM-5.1")
+HF_TOKEN = os.getenv("HF_TOKEN")
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME", "openenv-productivity")
 
 
 def _compact(text: Optional[str]) -> str:
@@ -29,34 +33,27 @@ def _print_start(task_name: str, env_name: str, model_name: str) -> None:
 
 
 def _print_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_value = error if error else "null"
     print(
         f"[STEP] step={step} action={_compact(action)} reward={reward:.2f} "
-        f"done={_bool_text(done)} error={_compact(error)}"
+        f"done={_bool_text(done)} error={error_value}"
     )
 
 
-def _print_end(success: bool, steps: int, rewards: list[float]) -> None:
+def _print_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
     reward_text = ",".join(f"{value:.2f}" for value in rewards)
-    print(f"[END] success={_bool_text(success)} steps={steps} rewards={reward_text}")
+    print(f"[END] success={_bool_text(success)} steps={steps} score={score:.3f} rewards={reward_text}")
 
 
 def _build_client() -> Tuple[Optional[OpenAI], Optional[str], Optional[str]]:
-    api_base_url = os.getenv("API_BASE_URL")
-    model_name = os.getenv("MODEL_NAME")
-    token = os.getenv("HF_TOKEN")
-
-    if not api_base_url:
-        return None, model_name, "missing API_BASE_URL"
-    if not model_name:
-        return None, None, "missing MODEL_NAME"
-    if not token:
-        return None, model_name, "missing HF_TOKEN"
+    if not HF_TOKEN:
+        return None, MODEL_NAME, "missing HF_TOKEN"
 
     try:
-        client = OpenAI(base_url=api_base_url, api_key=token)
+        client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
     except Exception as exc:
-        return None, model_name, f"client_initialization_failed:{_compact(exc)}"
-    return client, model_name, None
+        return None, MODEL_NAME, f"client_initialization_failed:{_compact(exc)}"
+    return client, MODEL_NAME, None
 
 
 def _extract_action(content: str) -> str:
@@ -109,64 +106,75 @@ def main() -> None:
 
     env = ProductivityEnvironment(max_steps=MAX_STEPS)
     task_name = args.task
-    model_name_for_log = os.getenv("MODEL_NAME") or "unknown"
+    model_name_for_log = MODEL_NAME
     rewards: list[float] = []
     success = False
     steps_taken = 0
+    score = 0.0
+    last_error: Optional[str] = None
 
     _print_start(task_name, env.benchmark_name, model_name_for_log)
 
-    try:
-        observation = env.reset(task_name=task_name)
-    except Exception as exc:
-        _print_step(1, "inspect", 0.00, True, f"reset_failed:{_compact(exc)}")
-        _print_end(False, 1, [0.00])
-        return
-
-    client, model_name, init_error = _build_client()
-    if init_error is not None or client is None or model_name is None:
-        rewards.append(0.00)
-        _print_step(1, "inspect", 0.00, True, init_error)
-        _print_end(False, 1, rewards)
-        return
-
     done = False
-    last_error: Optional[str] = None
-
-    for step_number in range(1, MAX_STEPS + 1):
-        steps_taken = step_number
-        action, model_error = _query_model(
-            client,
-            model_name,
-            json.dumps(observation.model_dump(), separators=(",", ":"), sort_keys=True),
-        )
-
-        if model_error is not None or action is None:
-            rewards.append(0.00)
-            _print_step(step_number, "inspect", 0.00, True, model_error)
-            done = True
-            last_error = model_error
-            break
-
+    try:
         try:
-            observation, reward, done, info = env.step(action)
-            error = info.get("error")
-            rewards.append(reward.value)
-            _print_step(step_number, action, reward.value, done, error)
-            last_error = error
+            observation = env.reset(task_name=task_name)
         except Exception as exc:
-            rewards.append(0.00)
-            _print_step(step_number, action, 0.00, True, f"step_failed:{_compact(exc)}")
+            steps_taken = 1
+            rewards = [0.00]
+            last_error = f"reset_failed:{_compact(exc)}"
+            _print_step(1, "inspect", 0.00, True, last_error)
             done = True
-            last_error = str(exc)
-            break
-
-        if done:
-            break
-
-    if rewards:
-        success = done and env.state().best_score >= 1.0 and last_error in (None, "")
-    _print_end(success, max(steps_taken, 1), rewards if rewards else [0.00])
+            return
+
+        client, model_name, init_error = _build_client()
+        if init_error is not None or client is None or model_name is None:
+            steps_taken = 1
+            rewards = [0.00]
+            last_error = init_error
+            _print_step(1, "inspect", 0.00, True, last_error)
+            done = True
+            return
+
+        for step_number in range(1, MAX_STEPS + 1):
+            steps_taken = step_number
+            action, model_error = _query_model(
+                client,
+                model_name,
+                json.dumps(observation.model_dump(), separators=(",", ":"), sort_keys=True),
+            )
+
+            if model_error is not None or action is None:
+                rewards.append(0.00)
+                _print_step(step_number, "inspect", 0.00, True, model_error)
+                done = True
+                last_error = model_error
+                break
+
+            try:
+                observation, reward, done, info = env.step(action)
+                error = info.get("error")
+                rewards.append(reward.value)
+                _print_step(step_number, action, reward.value, done, error)
+                last_error = error
+            except Exception as exc:
+                rewards.append(0.00)
+                _print_step(step_number, action, 0.00, True, f"step_failed:{_compact(exc)}")
+                done = True
+                last_error = str(exc)
+                break
+
+            if done:
+                break
+
+        score = max(0.0, min(1.0, float(env.state().best_score)))
+        success = bool(done and score >= 1.0 and (last_error is None or last_error == ""))
+    finally:
+        try:
+            env.close()
+        except Exception:
+            pass
+        _print_end(success, max(steps_taken, 1), score, rewards if rewards else [0.00])
 
 
 if __name__ == "__main__":

server/app.py

@@ -3,10 +3,17 @@ from __future__ import annotations
 import os
 
 from fastapi import FastAPI
+from pydantic import BaseModel
 import uvicorn
 
+from env.environment import ProductivityEnvironment
 
 app = FastAPI(title="openenv-productivity", version="1.0.0")
+_ENV = ProductivityEnvironment(max_steps=5)
+
+
+class StepRequest(BaseModel):
+    action: str
 
 
 @app.get("/")
@@ -23,6 +30,27 @@ def health() -> dict[str, str]:
     return {"status": "ok"}
 
 
+@app.post("/reset")
+def reset(task: str = "easy") -> dict:
+    return _ENV.reset(task_name=task).model_dump()
+
+
+@app.get("/state")
+def state() -> dict:
+    return _ENV.state().model_dump()
+
+
+@app.post("/step")
+def step(payload: StepRequest) -> dict:
+    obs, reward, done, info = _ENV.step(payload.action)
+    return {
+        "observation": obs.model_dump(),
+        "reward": reward.model_dump(),
+        "done": done,
+        "info": info,
+    }
+
+
 @app.get("/{path:path}")
 def fallback(path: str) -> dict[str, str]:
     return {