revert to server directory

server/__init__.py

@@ -0,0 +1,5 @@
+"""TraceFix-RL server components."""
+
+from .tracefix_rl_environment import TraceFixRLEnvironment
+
+__all__ = ["TraceFixRLEnvironment"]

server/app.py

@@ -0,0 +1,57 @@
+"""FastAPI entry point for TraceFix-RL."""
+
+import gradio as gr
+from vision_ui import demo
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+try:
+    from core.models import CodeAction, CodeObservation
+    from server.tracefix_rl_environment import TraceFixRLEnvironment
+except ImportError:
+    import sys
+    from pathlib import Path
+
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+    from core.models import CodeAction, CodeObservation
+    from server.tracefix_rl_environment import TraceFixRLEnvironment
+
+
+app = create_app(
+    TraceFixRLEnvironment,
+    CodeAction,
+    CodeObservation,
+    env_name="tracefix_rl",
+    max_concurrent_envs=1,
+)
+
+from fastapi.responses import RedirectResponse
+
+@app.get("/", include_in_schema=False)
+async def root_redirect():
+    return RedirectResponse(url="/web/")
+
+@app.get("/web", include_in_schema=False)
+async def web_no_slash_redirect():
+    return RedirectResponse(url="/web/")
+
+app = gr.mount_gradio_app(app, demo, path="/web")
+
+
+def main() -> None:
+    """Entry point for local and container execution."""
+    import os
+    import uvicorn
+
+    host = os.environ.get("HOST", "0.0.0.0")
+    port = int(os.environ.get("PORT", "7860"))
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/tracefix_rl_environment.py

@@ -0,0 +1,67 @@
+"""OpenEnv adapter around the TraceFix-RL core environment."""
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from core.environment import TraceFixRLGym
+    from core.models import CodeAction, CodeObservation
+except ImportError:
+    from core.environment import TraceFixRLGym
+    from core.models import CodeAction, CodeObservation
+
+
+class TraceFixRLEnvironment(Environment):
+    """Environment implementation compatible with OpenEnv's server interface."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        self._gym = TraceFixRLGym()
+        self._state = State(episode_id="", step_count=0)
+
+    def reset(self, difficulty: str | None = None, task_name: str | None = None) -> CodeObservation:
+        if difficulty == "easy":
+            self._gym.training_step = 1
+        elif difficulty == "medium":
+            self._gym.training_step = 2000
+        elif difficulty == "hard":
+            self._gym.training_step = 6000
+
+        task_dict = None
+        if task_name and task_name != "tracefix_rl":
+            try:
+                from tasks.tasks import ALL_TASKS
+                for t in ALL_TASKS:
+                    if t.get("name") == task_name:
+                        task_dict = t
+                        break
+            except ImportError:
+                pass
+
+        obs, system_prompt = self._gym.reset(task_index=task_dict)
+        self._state = State(
+            episode_id=obs.info.get("episode_id", ""),
+            step_count=obs.step_count,
+        )
+        metadata = dict(obs.metadata or {})
+        metadata["system_prompt"] = system_prompt
+        obs.metadata = metadata
+        return obs
+
+    def step(self, action: CodeAction) -> CodeObservation:  # type: ignore[override]
+        obs, reward, done, info = self._gym.step(action)
+        obs.reward = reward
+        obs.done = done
+        metadata = dict(obs.metadata or {})
+        metadata.update(info)
+        obs.metadata = metadata
+        self._state = State(
+            episode_id=obs.info.get("episode_id", ""),
+            step_count=obs.step_count,
+        )
+        return obs
+
+    @property
+    def state(self) -> State:
+        return self._state