fix: redirect root / to /ui so judges see Gradio UI not raw JSON

server/app.py

@@ -1,106 +1,88 @@
 """
-ECHO ULTIMATE — FastAPI OpenEnv-Compliant Server.
-Pure FastAPI: no openenv package dependency.
-Mounts Gradio UI at /ui.
+ECHO ULTIMATE — OpenEnv-Compliant FastAPI Server.
+
+Built with openenv.core.create_fastapi_app so the environment is exposed through
+the standard OpenEnv HTTP protocol:
+
+    POST /reset      → EchoObservation (OpenEnv standard)
+    POST /step       → EchoObservation (OpenEnv standard)
+    GET  /state      → EchoState       (OpenEnv standard)
+    GET  /health     → health status
+    GET  /schema/action      → JSON schema
+    GET  /schema/observation → JSON schema
+
+Additional ECHO-specific endpoints:
+    GET  /tasks      → task definitions
+    GET  /metrics    → CalibrationReport (ECE, Brier, MCE …)
+    GET  /metrics/{domain}
+    GET  /fingerprint
+    GET  /history
+    POST /advance_phase
+    GET  /ui         → Gradio demo (mounted)
+
 Runs on port 7860 (HuggingFace Space public port).
 """
 
 import logging
 import os
-import random
 import sys
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from contextlib import asynccontextmanager
-from typing import Any, Optional
+from typing import Optional
 
-from fastapi import FastAPI, HTTPException
+from fastapi import HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field
+from fastapi.responses import RedirectResponse
+from openenv.core import create_fastapi_app
 
 from config import cfg
 from core.tasks import TASKS
-from env.echo_env import EchoEnv
+from env.openenv_env import EchoOpenEnv
 from env.reward import RewardHistory
 from env.task_bank import TaskBank
+from models import EchoAction, EchoObservation
 
 logger = logging.getLogger(__name__)
 
-# ── App state ─────────────────────────────────────────────────────────────────
+# ── Singleton environment (stateful, shared across all HTTP requests) ─────────
 
 _task_bank: Optional[TaskBank] = None
-_env: Optional[EchoEnv] = None
 _history: Optional[RewardHistory] = None
+_env: Optional[EchoOpenEnv] = None
 
 
-def _get_env() -> EchoEnv:
+def _get_env() -> EchoOpenEnv:
     if _env is None:
-        raise HTTPException(400, "No active episode. POST /reset first.")
+        raise RuntimeError("Environment not initialised — server startup incomplete.")
     return _env
 
 
-# ── Pydantic schemas ──────────────────────────────────────────────────────────
-
-class ResetRequest(BaseModel):
-    task_id: Optional[str] = Field(None, description="Specific task ID to load")
-    adversarial: Optional[bool] = Field(False, description="Use adversarial questions")
-
-
-class StepRequest(BaseModel):
-    action: Optional[str] = Field(None, description="Legacy: action string")
-    response: Optional[str] = Field(None, description="Agent response with confidence and answer tags")
-
-    def get_response(self) -> str:
-        """Accept either 'response' or 'action' field."""
-        return self.response or self.action or ""
+def _env_factory() -> EchoOpenEnv:
+    """
+    Singleton factory required by create_fastapi_app.
+    Returns the shared instance so state persists across reset/step calls.
+    gym.Env.close() is a no-op, so the OpenEnv server's cleanup call is harmless.
+    """
+    return _get_env()
 
 
-class TaskInfo(BaseModel):
-    id: str
-    name: str
-    description: str
-    pass_threshold: float
-    n_episodes: int
+# ── Create OpenEnv-compliant FastAPI app ──────────────────────────────────────
 
+app = create_fastapi_app(
+    env=_env_factory,
+    action_cls=EchoAction,
+    observation_cls=EchoObservation,
+)
 
-class StepResponse(BaseModel):
-    state: dict
-    reward: float
-    terminated: bool
-    truncated: bool
-    info: dict
-
-
-# ── Lifespan ──────────────────────────────────────────────────────────────────
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    global _task_bank, _env, _history
-    logger.info("ECHO ULTIMATE server starting…")
-    _task_bank = TaskBank()
-    _task_bank.ensure_loaded()
-    _history = RewardHistory()
-    _env = EchoEnv(task_bank=_task_bank, reward_history=_history, phase=3)
-    _env.reset()
-    logger.info("ECHO ULTIMATE ready ✅  (7 domains, 3 tasks)")
-    print("✅  ECHO ULTIMATE server ready — http://0.0.0.0:7860/docs")
-    yield
-    logger.info("ECHO ULTIMATE server shutting down.")
-
-
-# ── App ───────────────────────────────────────────────��───────────────────────
-
-app = FastAPI(
-    title="ECHO ULTIMATE — Epistemic Calibration RL Environment",
-    description=(
-        "OpenEnv-compliant training environment for LLM metacognitive calibration. "
-        "7 domains · 3 curriculum phases · 5 calibration metrics · Epistemic fingerprint."
-    ),
-    version="2.0.0",
-    lifespan=lifespan,
+app.title = "ECHO ULTIMATE — Epistemic Calibration RL Environment"
+app.description = (
+    "OpenEnv-compliant training environment for LLM metacognitive calibration. "
+    "7 domains · 3 curriculum phases · 5 calibration metrics · Epistemic fingerprint. "
+    "Trains models to know what they don't know via GRPO + Brier-score rewards."
 )
+app.version = "2.0.0"
 
 app.add_middleware(
     CORSMiddleware,
@@ -111,100 +93,59 @@ app.add_middleware(
 )
 
 
-# ── Endpoints ─────────────────────────────────────────────────────────────────
+# ── Startup: initialise singleton env ─────────────────────────────────────────
 
-@app.get("/health", tags=["Health"])
-async def health():
-    return {"status": "ok", "environment": "ECHO-ULTIMATE", "version": "2.0.0",
-            "domains": 7, "tasks": 3}
+@app.on_event("startup")
+async def _startup():
+    global _task_bank, _history, _env
+    logger.info("ECHO ULTIMATE server starting…")
+    _task_bank = TaskBank()
+    _task_bank.ensure_loaded()
+    _history = RewardHistory()
+    _env = EchoOpenEnv(task_bank=_task_bank, reward_history=_history, phase=3)
+    _env._gym_reset()
+    logger.info("ECHO ULTIMATE ready ✅  (7 domains, 3 tasks)")
+    print("✅  ECHO ULTIMATE server ready — http://0.0.0.0:7860/docs")
 
 
+# ── ECHO-specific extra endpoints ─────────────────────────────────────────────
+
 @app.get("/", tags=["Health"])
 async def root():
-    return {"message": "ECHO ULTIMATE RL Environment",
-            "docs": "/docs", "health": "/health",
-            "tasks": "/tasks", "metrics": "/metrics", "ui": "/ui"}
+    return RedirectResponse(url="/ui")
 
 
-@app.get("/tasks", response_model=list[TaskInfo], tags=["Tasks"])
+@app.get("/tasks", tags=["Tasks"])
 async def list_tasks():
-    return [TaskInfo(id=t.id, name=t.name, description=t.description,
-                     pass_threshold=t.pass_threshold, n_episodes=t.n_episodes)
-            for t in TASKS]
-
-
-@app.post("/reset", tags=["Environment"])
-async def reset(req: ResetRequest = ResetRequest()) -> dict:
-    env = _get_env()
-    opts = {}
-    if req.task_id:
-        opts["task_id"] = req.task_id
-    if req.adversarial:
-        opts["adversarial"] = True
-    state, info = env.reset(options=opts if opts else None)
-    return state
-
-
-@app.post("/reset/{task_id}", tags=["Environment"])
-async def reset_task(task_id: str) -> dict:
-    env = _get_env()
-    state, _ = env.reset(options={"task_id": task_id})
-    return state
-
-
-@app.post("/step", response_model=StepResponse, tags=["Environment"])
-async def step(req: StepRequest) -> StepResponse:
-    env = _get_env()
-    response_text = req.get_response()
-    if not response_text:
-        raise HTTPException(422, "Provide either 'response' or 'action' field.")
-    try:
-        state, reward, terminated, truncated, info = env.step(response_text)
-    except Exception as exc:
-        logger.error("step error: %s", exc)
-        raise HTTPException(500, f"Step failed: {exc}")
-    return StepResponse(
-        state=state,
-        reward=round(float(reward), 4),
-        terminated=terminated,
-        truncated=truncated,
-        info=info,
-    )
-
-
-@app.get("/state", tags=["Environment"])
-async def get_state() -> dict:
-    return _get_env()._build_obs()
+    return _get_env().list_tasks()
 
 
 @app.get("/metrics", tags=["Metrics"])
 async def get_metrics():
-    rep = _get_env().get_metrics()
-    return rep.to_dict()
+    return _get_env().get_metrics().to_dict()
 
 
 @app.get("/metrics/{domain}", tags=["Metrics"])
 async def get_domain_metrics(domain: str):
     if domain not in cfg.DOMAINS:
         raise HTTPException(404, f"Unknown domain '{domain}'. Valid: {cfg.DOMAINS}")
-    rep = _get_env().get_metrics(domain=domain)
-    return rep.to_dict()
+    return _get_env().get_metrics(domain=domain).to_dict()
 
 
 @app.get("/fingerprint", tags=["Metrics"])
-async def get_fingerprint() -> dict:
+async def get_fingerprint():
     env = _get_env()
     profiles = env.reward_history.get_domain_profiles()
     return {
-        "domain_scores": {d: round(1.0 - r.ece, 3) for d, r in profiles.items()},
-        "domain_ece": {d: round(r.ece, 3) for d, r in profiles.items()},
+        "domain_scores":   {d: round(1.0 - r.ece, 3) for d, r in profiles.items()},
+        "domain_ece":      {d: round(r.ece, 3) for d, r in profiles.items()},
         "domain_accuracy": {d: round(r.accuracy, 3) for d, r in profiles.items()},
-        "overall_ece": round(env.get_metrics().ece, 3),
+        "overall_ece":     round(env.get_metrics().ece, 3),
     }
 
 
 @app.get("/history", tags=["Metrics"])
-async def get_history() -> dict:
+async def get_history():
     env = _get_env()
     df = env.reward_history.to_dataframe()
     records = df.tail(100).to_dict(orient="records") if len(df) > 0 else []
@@ -245,7 +186,7 @@ except Exception as _e:
     print(f"⚠️  Gradio UI not mounted: {_e}")
 
 
-# ── Direct runner ──────────────────────────────────────────────────────────────
+# ── Direct runner ─────────────────────────────────────────────────────────────
 
 if __name__ == "__main__":
     import uvicorn