Fix HF Space runtime by adding persistent FastAPI server

.gitignore

@@ -1,6 +1,8 @@
 node_modules/
 .next/
-backend/.venv/
+lifeline-ai/node_modules/
+lifeline-ai/.next/
+lifeline-ai/backend/.venv/
 venv/
 __pycache__/
 *.pyc

Dockerfile

@@ -26,6 +26,12 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir --upgrade pip \
     && pip install --no-cache-dir -r requirements.txt
 
+# If a backend requirements file exists (lifeline-ai/backend/requirements.txt), install it too
+COPY lifeline-ai/backend/requirements.txt ./lifeline-backend-requirements.txt
+RUN if [ -f ./lifeline-backend-requirements.txt ]; then \
+      pip install --no-cache-dir -r ./lifeline-backend-requirements.txt; \
+    fi
+
 # ── Copy application source safely ────────────────────────────────────────────
 # Copying the full project avoids file-not-found build breaks and is HF-Spaces-friendly.
 COPY . .
@@ -40,6 +46,10 @@ ENV OPENAI_API_KEY="EMPTY" \
     MODEL_NAME="gpt-4o-mini" \
     HF_TOKEN=""
 
-# ── Default command: run baseline inference across all tasks ──────────────────
-# LLM agent can be enabled by passing: --agent llm and setting API env vars.
-CMD ["python", "-u", "inference.py", "--difficulty", "all", "--agent", "rules"]
+# ── Expose the port expected by Hugging Face Spaces and run the backend web server
+EXPOSE 7860
+
+# Default command: start the FastAPI backend (lifeline-ai backend) on port 7860.
+# This keeps the container running as a web service compatible with Spaces (sdk: docker).
+# It will cd into the backend folder and run uvicorn. Override at runtime as needed.
+CMD ["sh", "-c", "uvicorn backend.app.main:app --host 0.0.0.0 --port 7860"]

backend/__init__.py

@@ -0,0 +1,8 @@
+"""Backend package for LifeLine AI HTTP API.
+
+This package provides a small FastAPI wrapper that exposes the existing
+benchmarking/inference logic via HTTP so the container remains running on
+Hugging Face Spaces (sdk: docker).
+"""
+
+__all__ = ["app"]

backend/app/__init__.py

@@ -0,0 +1,6 @@
+"""backend.app package
+
+Contains the FastAPI application module (main.py).
+"""
+
+__all__ = ["main"]

backend/app/main.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+import logging
+from typing import Any, Dict, List, Optional
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+# Import the existing inference runner so we can reuse run_episode
+try:
+    # inference.py lives at project root and exports run_episode
+    import inference
+except Exception:
+    inference = None
+
+app = FastAPI(title="LifeLine AI API", version="1.0.0")
+
+# Configure logging for startup visibility
+logger = logging.getLogger("lifeline.backend")
+logging.basicConfig(level=logging.INFO)
+
+
+class BenchmarkRequest(BaseModel):
+    agent: str = "rules"  # 'rules' or 'llm'
+    difficulty: str = "all"  # easy|medium|hard|all
+
+
+@app.on_event("startup")
+def startup_event() -> None:
+    logger.info("LifeLine AI API started successfully")
+
+
+@app.get("/health")
+def health() -> Dict[str, str]:
+    return {"status": "ok", "project": "LifeLine AI"}
+
+
+@app.post("/run-benchmark")
+def run_benchmark(req: BenchmarkRequest) -> Dict[str, Any]:
+    """Run the existing inference benchmark and return structured JSON results.
+
+    This re-uses the `run_episode` function from `inference.py` so the benchmark
+    logic remains in one place and is usable both as CLI and via the HTTP API.
+    """
+
+    if inference is None:
+        raise HTTPException(status_code=500, detail="inference module not available")
+
+    agent = req.agent.lower()
+    if agent not in ("rules", "llm"):
+        raise HTTPException(status_code=400, detail="agent must be 'rules' or 'llm'")
+
+    difficulty = req.difficulty.lower()
+    if difficulty not in ("easy", "medium", "hard", "all"):
+        raise HTTPException(status_code=400, detail="difficulty must be easy|medium|hard|all")
+
+    # Prepare OpenAI client when requested
+    client: Optional[Any] = None
+    if agent == "llm":
+        try:
+            from openai import OpenAI as OpenAIClient  # type: ignore
+        except Exception as exc:  # pragma: no cover - import/runtime error
+            raise HTTPException(status_code=500, detail=f"OpenAI client not available: {exc}")
+
+        api_key = os.getenv("OPENAI_API_KEY", "EMPTY")
+        hf_token = os.getenv("HF_TOKEN", "")
+        if hf_token and api_key == "EMPTY":
+            api_key = hf_token
+
+        try:
+            client = OpenAIClient(api_key=api_key, base_url=os.getenv("API_BASE_URL", "https://api.openai.com/v1"))
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=f"Failed to initialize OpenAI client: {exc}")
+
+    # Determine difficulties list
+    difficulties: List[str]
+    if difficulty == "all":
+        difficulties = inference.ALL_DIFFICULTIES
+    else:
+        difficulties = [difficulty]
+
+    results = []
+    for diff in difficulties:
+        # Each run returns structured dicts as defined by inference.run_episode
+        try:
+            res = inference.run_episode(client, diff, agent)
+        except Exception as exc:
+            # Bubble up error details while keeping API stable
+            raise HTTPException(status_code=500, detail=f"Benchmark run failed: {exc}")
+        results.append(res)
+
+    avg_score = sum(r["score"] for r in results) / len(results) if results else 0.0
+
+    return {"average_score": avg_score, "results": results}