fix: add OpenEnv root reset and step aliases

Expose OpenEnv-compatible root endpoints (/reset, /step, /state/{episode_id}) and API aliases (/api/reset, /api/step, /api/state/{episode_id}) to prevent 405 on evaluator probes.

Add endpoint coercion for relaxed action payloads and tests for alias behavior.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

backend/app/api/routes/__init__.py

@@ -1,5 +1,5 @@
 """API routes package."""
 
-from app.api.routes import agents, episode, health, memory, sites, tasks, tools
+from app.api.routes import agents, episode, health, memory, openenv, sites, tasks, tools
 
-__all__ = ["agents", "episode", "health", "memory", "sites", "tasks", "tools"]
+__all__ = ["agents", "episode", "health", "memory", "openenv", "sites", "tasks", "tools"]

backend/app/api/routes/openenv.py

@@ -0,0 +1,168 @@
+"""OpenEnv compatibility endpoints exposed at root-level paths."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Body, HTTPException, status
+from pydantic import BaseModel, Field
+
+from app.api.deps import SettingsDep
+from app.api.routes.episode import (
+    EpisodeState,
+    ResetRequest,
+    ResetResponse,
+    StepRequest,
+    get_episode_state,
+    reset_episode,
+    step_episode,
+)
+from app.core.action import Action, ActionType
+
+router = APIRouter(tags=["OpenEnv"])
+
+
+class OpenEnvResetRequest(BaseModel):
+    """Lenient reset request supporting common OpenEnv field aliases."""
+
+    task_id: str | None = Field(default=None)
+    task: str | None = Field(default=None)
+    task_name: str | None = Field(default=None)
+    seed: int | None = Field(default=None)
+    config: dict[str, Any] | None = Field(default=None)
+
+
+class OpenEnvStepRequest(BaseModel):
+    """Lenient step request supporting common OpenEnv field aliases."""
+
+    episode_id: str | None = Field(default=None)
+    episode: str | None = Field(default=None)
+    session_id: str | None = Field(default=None)
+    action: Any = Field(default_factory=dict)
+
+
+def _coerce_action(action_payload: Any) -> Action:
+    """Coerce OpenEnv-style actions into internal Action model."""
+    if isinstance(action_payload, Action):
+        return action_payload
+
+    if isinstance(action_payload, str):
+        action_type = action_payload.strip().lower()
+        try:
+            return Action(action_type=ActionType(action_type), parameters={})
+        except ValueError:
+            return Action.wait()
+
+    if isinstance(action_payload, dict):
+        payload = dict(action_payload)
+
+        if "action_type" not in payload:
+            for alias in ("action", "type", "name"):
+                alias_value = payload.get(alias)
+                if isinstance(alias_value, str) and alias_value.strip():
+                    payload["action_type"] = alias_value.strip().lower()
+                    break
+
+        if "parameters" not in payload:
+            params = payload.get("params")
+            payload["parameters"] = params if isinstance(params, dict) else {}
+
+        if "reasoning" not in payload and isinstance(payload.get("thought"), str):
+            payload["reasoning"] = payload["thought"]
+
+        action_type = payload.get("action_type")
+        if not isinstance(action_type, str):
+            payload["action_type"] = ActionType.WAIT.value
+            payload["parameters"] = {}
+        else:
+            normalized = action_type.strip().lower()
+            try:
+                ActionType(normalized)
+                payload["action_type"] = normalized
+            except ValueError:
+                payload["action_type"] = ActionType.WAIT.value
+                payload["parameters"] = {}
+
+        try:
+            return Action.model_validate(payload)
+        except Exception:
+            return Action.wait()
+
+    return Action.wait()
+
+
+@router.post(
+    "/reset",
+    response_model=ResetResponse,
+    status_code=status.HTTP_200_OK,
+    summary="OpenEnv-compatible reset endpoint",
+)
+@router.post(
+    "/api/reset",
+    response_model=ResetResponse,
+    status_code=status.HTTP_200_OK,
+    include_in_schema=False,
+)
+async def openenv_reset(
+    settings: SettingsDep,
+    request: OpenEnvResetRequest | None = Body(default=None),
+) -> ResetResponse:
+    """
+    Root-level reset alias used by OpenEnv evaluators.
+
+    Defaults to `task_001` when no explicit task identifier is provided.
+    """
+    payload = request or OpenEnvResetRequest()
+    task_id = payload.task_id or payload.task or payload.task_name or "task_001"
+    normalized_request = ResetRequest(task_id=task_id, seed=payload.seed, config=payload.config)
+    return await reset_episode(normalized_request, settings)
+
+
+@router.post(
+    "/step",
+    status_code=status.HTTP_200_OK,
+    summary="OpenEnv-compatible step endpoint",
+)
+@router.post(
+    "/api/step",
+    status_code=status.HTTP_200_OK,
+    include_in_schema=False,
+)
+async def openenv_step(
+    request: OpenEnvStepRequest = Body(default_factory=OpenEnvStepRequest),
+) -> dict[str, Any]:
+    """Root-level step alias used by OpenEnv evaluators."""
+    episode_id = request.episode_id or request.episode or request.session_id
+    if not episode_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing episode_id",
+        )
+
+    result = await step_episode(
+        StepRequest(
+            episode_id=episode_id,
+            action=_coerce_action(request.action),
+        )
+    )
+    payload = result.model_dump()
+    payload["done"] = bool(result.terminated or result.truncated)
+    return payload
+
+
+@router.get(
+    "/state/{episode_id}",
+    response_model=EpisodeState,
+    status_code=status.HTTP_200_OK,
+    summary="OpenEnv-compatible state endpoint",
+)
+@router.get(
+    "/api/state/{episode_id}",
+    response_model=EpisodeState,
+    status_code=status.HTTP_200_OK,
+    include_in_schema=False,
+)
+async def openenv_state(episode_id: str) -> EpisodeState:
+    """Root-level state alias used by OpenEnv evaluators."""
+    return await get_episode_state(episode_id)
+

backend/app/main.py

@@ -11,7 +11,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
 
-from app.api.routes import agents, episode, health, memory, plugins, scrape, sites, tasks, tools
+from app.api.routes import agents, episode, health, memory, openenv, plugins, scrape, sites, tasks, tools
 from app.api.routes import settings as settings_routes
 from app.config import get_settings
 from app.memory.manager import MemoryManager
@@ -135,6 +135,7 @@ def create_app() -> FastAPI:
     app.include_router(plugins.router, prefix=api_prefix, tags=["Plugins"])
     app.include_router(sites.router, prefix=api_prefix, tags=["Sites"])
     app.include_router(scrape.router, prefix=api_prefix, tags=["Scraping"])
+    app.include_router(openenv.router, tags=["OpenEnv"])
     
     # Import and include providers router
     from app.api.routes import providers

backend/tests/test_api/test_episode.py

@@ -46,3 +46,30 @@ def test_get_state(client: TestClient, sample_task: dict) -> None:
     assert response.status_code == 200
     data = response.json()
     assert data["episode_id"] == episode_id
+
+
+def test_openenv_reset_alias(client: TestClient, sample_task: dict) -> None:
+    """Test OpenEnv-compatible reset alias at root path."""
+    response = client.post("/reset", json={"task": sample_task["task_id"]})
+    assert response.status_code == 200
+    data = response.json()
+    assert "episode_id" in data
+    assert data["task_id"] == sample_task["task_id"]
+
+
+def test_openenv_step_alias_with_string_action(client: TestClient, sample_task: dict) -> None:
+    """Test OpenEnv-compatible step alias accepts string action payloads."""
+    reset_response = client.post("/reset", json={"task_id": sample_task["task_id"]})
+    assert reset_response.status_code == 200
+    episode_id = reset_response.json()["episode_id"]
+
+    step_response = client.post(
+        "/step",
+        json={
+            "episode_id": episode_id,
+            "action": "done",
+        },
+    )
+    assert step_response.status_code == 200
+    data = step_response.json()
+    assert "done" in data