Add OpenEnv HTTP API and submission inference script

Dockerfile

@@ -11,7 +11,7 @@ ENV HOME=/home/user \
 
 WORKDIR $HOME/app
 
-COPY --chown=user pyproject.toml README.md $HOME/app/
+COPY --chown=user pyproject.toml README.md openenv.yaml inference.py $HOME/app/
 COPY --chown=user src $HOME/app/src
 COPY --chown=user config $HOME/app/config
 COPY --chown=user datasets $HOME/app/datasets
@@ -25,4 +25,3 @@ RUN pip install --no-cache-dir --upgrade pip && \
 EXPOSE 7860
 
 CMD ["sh", "-c", "uvicorn server:app --host 0.0.0.0 --port ${PORT:-7860}"]
-

README.md

@@ -156,6 +156,34 @@ python scripts/run_openai_baseline.py --model gpt-5-nano
 
 The script is designed to stay bounded enough for a normal benchmark pass to finish comfortably under 20 minutes on a lightweight chat model, while still using the full fixed task set. For repeatability it fixes the benchmark graph/tasks and uses deterministic decoding settings. Because remote model backends can still change over time, the output artifact also records model metadata and system fingerprints when available.
 
+## Inference Script
+
+The submission-ready inference entrypoint is the root `inference.py` file. It talks to the deployed Hugging Face Space over HTTP, uses the OpenAI client for all model calls, and emits structured stdout logs in the `[START]`, `[STEP]`, and `[END]` format.
+
+Required environment variables:
+
+- `API_BASE_URL`
+- `MODEL_NAME`
+- `HF_TOKEN`
+
+Optional environment variables:
+
+- `SPACE_URL` default: `https://siddeshwar1625-osint.hf.space`
+- `TASK_INDICES` default: `0,10,20`
+- `MAX_STEPS` default: `8`
+
+Example local test command against a running local server:
+
+```bash
+API_BASE_URL=https://api.openai.com/v1 MODEL_NAME=gpt-5.4-mini HF_TOKEN=your_key SPACE_URL=http://127.0.0.1:7860 python inference.py
+```
+
+Example test command against the deployed Space:
+
+```bash
+API_BASE_URL=https://api.openai.com/v1 MODEL_NAME=gpt-5.4-mini HF_TOKEN=your_key SPACE_URL=https://siddeshwar1625-osint.hf.space python inference.py
+```
+
 ## Docker And Hugging Face Space
 
 The repository is ready for a Docker-based Hugging Face Space:
@@ -179,6 +207,11 @@ The FastAPI app serves:
 - `/dashboard`: generated benchmark dashboard
 - `/api/environment`: environment metadata
 - `/healthz`: health check
+- `/openenv.yaml`: OpenEnv HTTP spec stub
+- `/openenv/tasks`: task enumeration
+- `/openenv/reset`: episode reset endpoint
+- `/openenv/step`: episode step endpoint
+- `/openenv/state/{session_id}`: current session state endpoint
 
 ## Automated Validation
 

inference.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import requests
+from openai import OpenAI
+from requests import RequestException
+
+from osint_env.baselines.openai_runner import SYSTEM_PROMPT, build_action_tools
+
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-5.4-mini")
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+SPACE_URL = os.getenv("SPACE_URL", "https://siddeshwar1625-osint.hf.space").rstrip("/")
+
+MAX_STEPS = int(os.getenv("MAX_STEPS", "8"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0.0"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "256"))
+REQUEST_TIMEOUT = int(os.getenv("REQUEST_TIMEOUT", "90"))
+TASK_INDICES = [int(part.strip()) for part in os.getenv("TASK_INDICES", "0,10,20").split(",") if part.strip()]
+SUCCESS_SCORE_THRESHOLD = float(os.getenv("SUCCESS_SCORE_THRESHOLD", "0.67"))
+
+BENCHMARK = "osint-openenv"
+TASK_NAME = "fixed_levels_easy_mid_hard"
+
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: dict[str, Any], reward: float, done: bool, error: str | None) -> None:
+    action_text = json.dumps(action, sort_keys=True, separators=(",", ":"))
+    error_text = "null" if error is None else json.dumps(error)
+    print(
+        f"[STEP] step={step} action={action_text} reward={reward:.4f} done={str(bool(done)).lower()} error={error_text}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
+    rewards_text = json.dumps([round(value, 4) for value in rewards], separators=(",", ":"))
+    print(
+        f"[END] success={str(bool(success)).lower()} steps={steps} score={score:.4f} rewards={rewards_text}",
+        flush=True,
+    )
+
+
+def _supports_reasoning_effort_in_chat_completions(model: str) -> bool:
+    model_name = str(model).strip().lower()
+    if model_name.startswith("gpt-5.4-mini"):
+        return False
+    return model_name.startswith("gpt-5")
+
+
+def _request_kwargs(messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> dict[str, Any]:
+    kwargs: dict[str, Any] = {
+        "model": MODEL_NAME,
+        "messages": messages,
+        "tools": tools,
+        "tool_choice": "required",
+        "parallel_tool_calls": False,
+    }
+    if MODEL_NAME.strip().lower().startswith("gpt-5"):
+        kwargs["max_completion_tokens"] = MAX_TOKENS
+        if _supports_reasoning_effort_in_chat_completions(MODEL_NAME):
+            kwargs["reasoning_effort"] = "none"
+    else:
+        kwargs["temperature"] = TEMPERATURE
+        kwargs["max_tokens"] = MAX_TOKENS
+    return kwargs
+
+
+def _message_text(message: Any) -> str:
+    content = getattr(message, "content", "")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "text":
+                parts.append(str(item.get("text", "")))
+        return "\n".join(part for part in parts if part)
+    return str(content or "")
+
+
+def _space_get(path: str) -> dict[str, Any]:
+    response = requests.get(f"{SPACE_URL}{path}", timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+    return response.json()
+
+
+def _space_post(path: str, payload: dict[str, Any]) -> dict[str, Any]:
+    response = requests.post(f"{SPACE_URL}{path}", json=payload, timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+    return response.json()
+
+
+def _decode_action(tool_name: str, args: dict[str, Any]) -> dict[str, Any]:
+    if tool_name == "submit_answer":
+        return {"action_type": "ANSWER", "payload": {"answer": str(args.get("answer", "")).strip()}}
+    if tool_name == "add_edge":
+        return {
+            "action_type": "ADD_EDGE",
+            "payload": {
+                "src": str(args.get("src", "")).strip(),
+                "rel": str(args.get("rel", "")).strip(),
+                "dst": str(args.get("dst", "")).strip(),
+                "confidence": float(args.get("confidence", 1.0)),
+            },
+        }
+    return {"action_type": "CALL_TOOL", "payload": {"tool_name": tool_name, "args": dict(args)}}
+
+
+def get_model_action(client: OpenAI, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> tuple[dict[str, Any], dict[str, Any]]:
+    try:
+        completion = client.chat.completions.create(**_request_kwargs(messages, tools))
+        message = completion.choices[0].message
+        tool_calls = list(message.tool_calls or [])
+        if not tool_calls:
+            fallback_answer = _message_text(message).strip() or "unknown"
+            return {"action_type": "ANSWER", "payload": {"answer": fallback_answer}}, {
+                "role": "assistant",
+                "content": _message_text(message),
+            }
+        tool_call = tool_calls[0]
+        try:
+            args = json.loads(tool_call.function.arguments or "{}")
+        except json.JSONDecodeError:
+            args = {}
+        if not isinstance(args, dict):
+            args = {}
+        assistant_message = {
+            "role": "assistant",
+            "content": _message_text(message),
+            "tool_calls": [
+                {
+                    "id": tool_call.id,
+                    "type": "function",
+                    "function": {
+                        "name": str(tool_call.function.name),
+                        "arguments": json.dumps(args, sort_keys=True),
+                    },
+                }
+            ],
+        }
+        return _decode_action(str(tool_call.function.name), args), assistant_message
+    except Exception as exc:
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        return {"action_type": "ANSWER", "payload": {"answer": "unknown"}}, {"role": "assistant", "content": ""}
+
+
+def main() -> None:
+    if not HF_TOKEN:
+        raise SystemExit("HF_TOKEN is required.")
+
+    try:
+        ping = _space_get("/healthz")
+        if ping.get("status") != "ok":
+            raise SystemExit(f"Unexpected healthz payload: {ping}")
+    except RequestException as exc:
+        raise SystemExit(f"Space ping failed: {exc}") from exc
+
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN, timeout=REQUEST_TIMEOUT)
+    tools = build_action_tools()
+
+    history: list[str] = []
+    rewards: list[float] = []
+    task_scores: list[float] = []
+    steps_taken = 0
+
+    log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
+
+    for task_index in TASK_INDICES:
+        result = _space_post("/openenv/reset", {"task_index": task_index})
+        session_id = str(result["session_id"])
+        done = bool(result.get("done", False))
+        messages: list[dict[str, Any]] = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": json.dumps(result["observation"], indent=2, sort_keys=True),
+            },
+        ]
+
+        for local_step in range(1, MAX_STEPS + 1):
+            if done:
+                break
+            action, assistant_message = get_model_action(client, messages, tools)
+            error = None
+            try:
+                result = _space_post(
+                    "/openenv/step",
+                    {
+                        "session_id": session_id,
+                        "action_type": action["action_type"],
+                        "payload": action["payload"],
+                    },
+                )
+            except RequestException as exc:
+                error = str(exc)
+                result = _space_get(f"/openenv/state/{session_id}")
+            reward = float(result.get("reward", 0.0) or 0.0)
+            done = bool(result.get("done", False))
+            rewards.append(reward)
+            steps_taken += 1
+            log_step(step=steps_taken, action=action, reward=reward, done=done, error=error)
+            history.append(f"step={steps_taken} task_index={task_index} reward={reward:+.4f}")
+            messages.append(assistant_message)
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": "remote_step",
+                    "content": json.dumps(result, sort_keys=True),
+                }
+            )
+            if done:
+                break
+
+        info = dict(result.get("info", {}))
+        task_answer = str(info.get("task_answer", ""))
+        agent_answer = str(info.get("agent_answer", ""))
+        task_scores.append(1.0 if agent_answer and agent_answer == task_answer else 0.0)
+
+    score = sum(task_scores) / max(1, len(task_scores))
+    success = score >= SUCCESS_SCORE_THRESHOLD
+    log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+if __name__ == "__main__":
+    main()

openenv.yaml

@@ -0,0 +1,35 @@
+name: osint-openenv
+version: 0.1.0
+description: Synthetic OSINT benchmark environment exposed over HTTP.
+transport:
+  type: http
+  base_path: /
+endpoints:
+  health:
+    method: GET
+    path: /healthz
+  metadata:
+    method: GET
+    path: /api/environment
+  tasks:
+    method: GET
+    path: /openenv/tasks
+  reset:
+    method: POST
+    path: /openenv/reset
+  step:
+    method: POST
+    path: /openenv/step
+  state:
+    method: GET
+    path: /openenv/state/{session_id}
+models:
+  action_space:
+    - CALL_TOOL
+    - ADD_EDGE
+    - ANSWER
+  observation_fields:
+    - tool_outputs
+    - graph_snapshot
+    - action_history
+    - task

server.py

@@ -5,12 +5,22 @@ import os
 from collections import Counter
 from functools import lru_cache
 from pathlib import Path
+from threading import Lock
 from typing import Any
+from uuid import uuid4
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 
+from osint_env.api import (
+    OpenEnvActionRequest,
+    OpenEnvObservationModel,
+    OpenEnvResetRequest,
+    OpenEnvResponseEnvelope,
+    OpenEnvTaskSummary,
+)
 from osint_env.config import clone_environment_config, load_seeding_config, load_shared_config
+from osint_env.domain.models import Action, ActionType
 from osint_env.env.environment import OSINTEnvironment
 from osint_env.eval.runner import run_evaluation
 from osint_env.llm import build_llm_client
@@ -25,6 +35,10 @@ SPACE_PORT = int(os.getenv("PORT", "7860"))
 SPACE_DASHBOARD = Path("artifacts/space_dashboard.html")
 LATEST_BASELINE_OUTPUT = Path("artifacts/baselines/openai_fixed_levels_latest.json")
 LATEST_EVALUATION_OUTPUT = Path("artifacts/latest_evaluation.json")
+OPENENV_SPEC_PATH = Path("openenv.yaml")
+
+_SESSION_LOCK = Lock()
+_SESSIONS: dict[str, OSINTEnvironment] = {}
 
 
 def _load_json(path: Path) -> dict[str, Any] | None:
@@ -59,6 +73,67 @@ def _build_environment() -> OSINTEnvironment:
     return OSINTEnvironment(env_cfg, llm=llm)
 
 
+def _serialize_observation(observation: Any) -> OpenEnvObservationModel:
+    return OpenEnvObservationModel(
+        tool_outputs=list(observation.tool_outputs),
+        graph_snapshot=dict(observation.graph_snapshot),
+        action_history=list(observation.action_history),
+        task=dict(observation.task),
+    )
+
+
+def _safe_session_info(info: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "step_count": int(info.get("step_count", 0)),
+        "total_reward": float(info.get("total_reward", 0.0)),
+        "tool_calls": int(info.get("tool_calls", 0)),
+        "redundant_tool_calls": int(info.get("redundant_tool_calls", 0)),
+        "task_answer": str(info.get("task_answer", "")),
+        "agent_answer": "" if info.get("agent_answer") is None else str(info.get("agent_answer", "")),
+        "graph_f1": float(info.get("graph_f1", 0.0)),
+        "reward_components": dict(info.get("reward_components", {})),
+    }
+
+
+def _task_summaries(env: OSINTEnvironment) -> list[OpenEnvTaskSummary]:
+    return [
+        OpenEnvTaskSummary(
+            task_id=task.task_id,
+            task_type=task.task_type,
+            question=task.question,
+            difficulty=str(task.metadata.get("difficulty", "unknown")),
+        )
+        for task in env.tasks
+    ]
+
+
+def _resolve_task_index(env: OSINTEnvironment, request: OpenEnvResetRequest) -> int:
+    if request.task_index is not None:
+        task_index = int(request.task_index)
+        if task_index < 0 or task_index >= len(env.tasks):
+            raise HTTPException(status_code=400, detail=f"Invalid task_index {task_index}")
+        return task_index
+    if request.task_id:
+        for idx, task in enumerate(env.tasks):
+            if task.task_id == request.task_id:
+                return idx
+        raise HTTPException(status_code=400, detail=f"Unknown task_id {request.task_id}")
+    return 0
+
+
+def _get_session_env(session_id: str) -> OSINTEnvironment:
+    with _SESSION_LOCK:
+        env = _SESSIONS.get(session_id)
+    if env is None:
+        raise HTTPException(status_code=404, detail=f"Unknown session_id {session_id}")
+    return env
+
+
+def _store_session(session_id: str, env: OSINTEnvironment) -> None:
+    with _SESSION_LOCK:
+        _SESSIONS[session_id] = env
+
+
 @lru_cache(maxsize=1)
 def _base_environment_snapshot() -> dict[str, Any]:
     env = _build_environment()
@@ -271,11 +346,69 @@ def healthz() -> JSONResponse:
     return JSONResponse({"status": "ok"})
 
 
+@app.get("/openenv.yaml")
+def openenv_spec() -> FileResponse:
+    return FileResponse(OPENENV_SPEC_PATH, media_type="text/yaml")
+
+
 @app.get("/api/environment")
 def environment_metadata() -> JSONResponse:
     return JSONResponse(_space_snapshot())
 
 
+@app.get("/openenv/tasks", response_model=list[OpenEnvTaskSummary])
+def openenv_tasks() -> list[OpenEnvTaskSummary]:
+    env = _build_environment()
+    return _task_summaries(env)
+
+
+@app.post("/openenv/reset", response_model=OpenEnvResponseEnvelope)
+def openenv_reset(request: OpenEnvResetRequest) -> OpenEnvResponseEnvelope:
+    env = _build_environment()
+    env._task_idx = _resolve_task_index(env, request)
+    observation = env.reset()
+    session_id = str(uuid4())
+    _store_session(session_id, env)
+    return OpenEnvResponseEnvelope(
+        session_id=session_id,
+        observation=_serialize_observation(observation),
+        reward=0.0,
+        done=False,
+        info=_safe_session_info(env._info()),
+    )
+
+
+@app.post("/openenv/step", response_model=OpenEnvResponseEnvelope)
+def openenv_step(request: OpenEnvActionRequest) -> OpenEnvResponseEnvelope:
+    env = _get_session_env(request.session_id)
+    try:
+        action_type = ActionType(str(request.action_type))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=f"Unsupported action_type {request.action_type}") from exc
+    observation, reward, done, info = env.step(Action(action_type, dict(request.payload)))
+    return OpenEnvResponseEnvelope(
+        session_id=request.session_id,
+        observation=_serialize_observation(observation),
+        reward=float(reward),
+        done=bool(done),
+        info=_safe_session_info(info),
+    )
+
+
+@app.get("/openenv/state/{session_id}", response_model=OpenEnvResponseEnvelope)
+def openenv_state(session_id: str) -> OpenEnvResponseEnvelope:
+    env = _get_session_env(session_id)
+    if env.state is None:
+        raise HTTPException(status_code=400, detail="Session has not been reset yet")
+    return OpenEnvResponseEnvelope(
+        session_id=session_id,
+        observation=_serialize_observation(env._observation()),
+        reward=0.0,
+        done=bool(env.state.done),
+        info=_safe_session_info(env._info()),
+    )
+
+
 @app.get("/dashboard")
 def dashboard() -> FileResponse:
     snapshot = _space_snapshot()

src/osint_env/api/__init__.py

@@ -0,0 +1,15 @@
+from osint_env.api.models import (
+    OpenEnvActionRequest,
+    OpenEnvObservationModel,
+    OpenEnvResetRequest,
+    OpenEnvResponseEnvelope,
+    OpenEnvTaskSummary,
+)
+
+__all__ = [
+    "OpenEnvActionRequest",
+    "OpenEnvObservationModel",
+    "OpenEnvResetRequest",
+    "OpenEnvResponseEnvelope",
+    "OpenEnvTaskSummary",
+]

src/osint_env/api/models.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class OpenEnvTaskSummary(BaseModel):
+    task_id: str
+    task_type: str
+    question: str
+    difficulty: str = "unknown"
+
+
+class OpenEnvObservationModel(BaseModel):
+    tool_outputs: list[dict[str, Any]]
+    graph_snapshot: dict[str, Any]
+    action_history: list[dict[str, Any]]
+    task: dict[str, Any]
+
+
+class OpenEnvResetRequest(BaseModel):
+    task_id: str | None = None
+    task_index: int | None = None
+
+
+class OpenEnvActionRequest(BaseModel):
+    session_id: str
+    action_type: str = Field(description="One of CALL_TOOL, ADD_EDGE, ANSWER.")
+    payload: dict[str, Any] = Field(default_factory=dict)
+
+
+class OpenEnvResponseEnvelope(BaseModel):
+    session_id: str
+    observation: OpenEnvObservationModel
+    reward: float
+    done: bool
+    info: dict[str, Any]

src/osint_env/validation.py

@@ -19,6 +19,7 @@ from osint_env.env.reward import compute_answer_reward
 
 README_PATH = Path("README.md")
 DOCKERFILE_PATH = Path("Dockerfile")
+OPENENV_SPEC_PATH = Path("openenv.yaml")
 SHARED_CONFIG_PATH = "datasets/fixed_levels/shared_config_fixed_levels.json"
 SEED_FILE_PATH = "datasets/fixed_levels/seed_fixed_levels.json"
 
@@ -46,15 +47,18 @@ def check_hf_space_readiness() -> ValidationResult:
     client = TestClient(app)
     health = client.get("/healthz")
     dashboard = client.get("/api/environment")
+    spec = client.get("/openenv.yaml")
     passed = all(
         [
             README_PATH.exists(),
             DOCKERFILE_PATH.exists(),
+            OPENENV_SPEC_PATH.exists(),
             has_sdk,
             has_port,
             has_openenv_tag,
             health.status_code == 200,
             dashboard.status_code == 200,
+            spec.status_code == 200,
         ]
     )
     return ValidationResult(
@@ -63,11 +67,13 @@ def check_hf_space_readiness() -> ValidationResult:
         details={
             "readme_exists": README_PATH.exists(),
             "dockerfile_exists": DOCKERFILE_PATH.exists(),
+            "openenv_spec_exists": OPENENV_SPEC_PATH.exists(),
             "has_sdk_docker": has_sdk,
             "has_app_port": has_port,
             "has_openenv_tag": has_openenv_tag,
             "healthz_status": health.status_code,
             "environment_status": dashboard.status_code,
+            "openenv_spec_status": spec.status_code,
         },
     )
 
@@ -75,6 +81,17 @@ def check_hf_space_readiness() -> ValidationResult:
 def check_openenv_spec_compliance() -> ValidationResult:
     env = _build_environment()
     obs = env.reset()
+    client = TestClient(app)
+    reset = client.post("/openenv/reset", json={"task_index": 0})
+    step = client.post(
+        "/openenv/step",
+        json={
+            "session_id": reset.json()["session_id"] if reset.status_code == 200 else "",
+            "action_type": "ANSWER",
+            "payload": {"answer": "unknown"},
+        },
+    )
+    state = client.get(f"/openenv/state/{reset.json()['session_id']}") if reset.status_code == 200 else None
     passed = all(
         [
             isinstance(env, Env),
@@ -86,6 +103,9 @@ def check_openenv_spec_compliance() -> ValidationResult:
             env.episode_max_length == env.config.max_steps,
             isinstance(obs.task, dict),
             "question" in obs.task,
+            reset.status_code == 200,
+            step.status_code == 200,
+            state is not None and state.status_code == 200,
         ]
     )
     return ValidationResult(
@@ -97,6 +117,9 @@ def check_openenv_spec_compliance() -> ValidationResult:
             "action_space": list(env.action_space),
             "episode_max_length": env.episode_max_length,
             "task_keys": sorted(obs.task.keys()),
+            "reset_status": reset.status_code,
+            "step_status": step.status_code,
+            "state_status": 0 if state is None else state.status_code,
         },
     )
 

tests/test_server.py

@@ -24,6 +24,45 @@ def test_server_environment_metadata():
     assert "summary" in body
 
 
+def test_openenv_spec_and_tasks_endpoints():
+    spec = client.get("/openenv.yaml")
+    assert spec.status_code == 200
+    assert "reset" in spec.text
+
+    tasks = client.get("/openenv/tasks")
+    assert tasks.status_code == 200
+    body = tasks.json()
+    assert len(body) >= 3
+    assert {"task_id", "task_type", "question", "difficulty"} <= set(body[0].keys())
+
+
+def test_openenv_reset_step_and_state_cycle():
+    reset = client.post("/openenv/reset", json={"task_index": 0})
+    assert reset.status_code == 200
+    body = reset.json()
+    session_id = body["session_id"]
+    assert body["done"] is False
+    assert "question" in body["observation"]["task"]
+
+    state = client.get(f"/openenv/state/{session_id}")
+    assert state.status_code == 200
+    assert state.json()["session_id"] == session_id
+
+    step = client.post(
+        "/openenv/step",
+        json={
+            "session_id": session_id,
+            "action_type": "ANSWER",
+            "payload": {"answer": "unknown"},
+        },
+    )
+    assert step.status_code == 200
+    step_body = step.json()
+    assert step_body["session_id"] == session_id
+    assert step_body["done"] is True
+    assert "task_answer" in step_body["info"]
+
+
 def test_space_snapshot_prefers_newer_evaluation_payload(tmp_path, monkeypatch):
     baseline_path = tmp_path / "baseline.json"
     evaluation_path = tmp_path / "evaluation.json"