revert: restore server/app.py to last working state

server/app.py

@@ -1,82 +1,105 @@
 """
-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)
-
+ECHO ULTIMATE — FastAPI OpenEnv-Compliant Server.
+Pure FastAPI: no openenv package dependency.
+Mounts Gradio UI at /ui.
 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 Optional
+from typing import Any, Optional
 
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import RedirectResponse
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
 
 from config import cfg
 from core.tasks import TASKS
-from env.openenv_env import EchoOpenEnv
+from env.echo_env import EchoEnv
 from env.reward import RewardHistory
 from env.task_bank import TaskBank
-from models import EchoAction, EchoObservation
 
 logger = logging.getLogger(__name__)
 
-# ── Singleton environment (stateful, shared across all HTTP requests) ─────────
+# ── App state ─────────────────────────────────────────────────────────────────
 
 _task_bank: Optional[TaskBank] = None
+_env: Optional[EchoEnv] = None
 _history: Optional[RewardHistory] = None
-_env: Optional[EchoOpenEnv] = None
 
 
-def _get_env() -> EchoOpenEnv:
+def _get_env() -> EchoEnv:
     if _env is None:
-        raise RuntimeError("Environment not initialised — server startup incomplete.")
+        raise HTTPException(400, "No active episode. POST /reset first.")
     return _env
 
 
-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()
+# ── 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 ""
+
+
+class TaskInfo(BaseModel):
+    id: str
+    name: str
+    description: str
+    pass_threshold: float
+    n_episodes: int
+
+
+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.")
 
-# ── Create FastAPI app ────────────────────────────────────────────────────────
+
+# ── 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. "
-        "Trains models to know what they don't know via GRPO + Brier-score rewards."
+        "7 domains · 3 curriculum phases · 5 calibration metrics · Epistemic fingerprint."
     ),
     version="2.0.0",
+    lifespan=lifespan,
 )
 
 app.add_middleware(
@@ -88,95 +111,100 @@ app.add_middleware(
 )
 
 
-# ── Startup: initialise singleton env ─────────────────────────────────────────
+# ── Endpoints ─────────────────────────────────────────────────────────────────
 
-@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")
+@app.get("/health", tags=["Health"])
+async def health():
+    return {"status": "ok", "environment": "ECHO-ULTIMATE", "version": "2.0.0",
+            "domains": 7, "tasks": 3}
 
 
-# ── OpenEnv standard endpoints ────────────────────────────────────────────────
+@app.get("/", tags=["Health"])
+async def root():
+    return {"message": "ECHO ULTIMATE RL Environment",
+            "docs": "/docs", "health": "/health",
+            "tasks": "/tasks", "metrics": "/metrics", "ui": "/ui"}
 
-@app.get("/health", tags=["Health"])
-async def health():
-    return {"status": "ok", "environment": "ECHO-ULTIMATE", "version": "2.0.0", "domains": 7, "tasks": 3}
+
+@app.get("/tasks", response_model=list[TaskInfo], 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(body: dict = {}):
+async def reset(req: ResetRequest = ResetRequest()) -> dict:
     env = _get_env()
-    task_id = body.get("task_id") if body else None
-    obs_dict, info = env._gym_reset(options={"task_id": task_id} if task_id else None)
-    task = env._current_task or {}
-    return {**obs_dict, "question": task.get("question", obs_dict.get("question", "")), "info": info}
+    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("/step", tags=["Environment"])
-async def step(body: dict):
+@app.post("/reset/{task_id}", tags=["Environment"])
+async def reset_task(task_id: str) -> dict:
     env = _get_env()
-    action = body.get("action") or body.get("response", "")
-    obs_dict, reward, terminated, truncated, info = env._gym_step(action)
-    return {"reward": round(reward, 4), "terminated": terminated or truncated, "info": info, **obs_dict}
+    state, _ = env.reset(options={"task_id": task_id})
+    return state
 
 
-@app.get("/state", tags=["Environment"])
-async def get_state():
+@app.post("/step", response_model=StepResponse, tags=["Environment"])
+async def step(req: StepRequest) -> StepResponse:
     env = _get_env()
-    task = env._current_task or {}
-    return {
-        "current_question": task.get("question", ""),
-        "domain": task.get("domain", ""),
-        "difficulty": task.get("difficulty", ""),
-        "phase": env.phase,
-    }
-
-
-# ── ECHO-specific extra endpoints ─────────────────────────────────────────────
-
-@app.get("/", tags=["Health"])
-async def root():
-    return RedirectResponse(url="/ui")
+    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("/tasks", tags=["Tasks"])
-async def list_tasks():
-    return _get_env().list_tasks()
+@app.get("/state", tags=["Environment"])
+async def get_state() -> dict:
+    return _get_env()._build_obs()
 
 
 @app.get("/metrics", tags=["Metrics"])
 async def get_metrics():
-    return _get_env().get_metrics().to_dict()
+    rep = _get_env().get_metrics()
+    return rep.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}")
-    return _get_env().get_metrics(domain=domain).to_dict()
+    rep = _get_env().get_metrics(domain=domain)
+    return rep.to_dict()
 
 
 @app.get("/fingerprint", tags=["Metrics"])
-async def get_fingerprint():
+async def get_fingerprint() -> dict:
     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():
+async def get_history() -> dict:
     env = _get_env()
     df = env.reward_history.to_dataframe()
     records = df.tail(100).to_dict(orient="records") if len(df) > 0 else []
@@ -217,7 +245,7 @@ except Exception as _e:
     print(f"⚠️  Gradio UI not mounted: {_e}")
 
 
-# ── Direct runner ─────────────────────────────────────────────────────────────
+# ── Direct runner ──────────────────────────────────────────────────────────────
 
 if __name__ == "__main__":
     import uvicorn