Delete app.py

app.py

@@ -1,128 +0,0 @@
-    )
-    answer = result["choices"][0]["message"].get("content") or ""
-    return {
-        "answer": answer.strip(),
-        "task": p.task,
-        "usage": result.get("usage", {}),
-    }
-
-async def inference_worker(app: FastAPI) -> None:
-    while True:
-        job: WorkItem = await app.state.queue.get()
-        try:
-            if job.future.cancelled():
-                continue
-            app.state.active_model = job.model
-            start = time.perf_counter()
-            queue_ms = round((start - job.created) * 1000)
-            engine = app.state.engines[job.model]
-            generated = await asyncio.to_thread(run_inference, engine, job)
-            inference_ms = round((time.perf_counter() - start) * 1000)
-            app.state.completed += 1
-            if not job.future.done():
-                job.future.set_result({
-                    "request_id": job.id,
-                    "model": job.model,
-                    "task": generated["task"],
-                    "answer": generated["answer"],
-                    "usage": generated["usage"],
-                    "queue_ms": queue_ms,
-                    "inference_ms": inference_ms,
-                    "total_ms": round((time.perf_counter() - job.created) * 1000),
-                })
-        except Exception:
-            # Never print prompts, context, or full exceptions in production logs.
-            log.exception("Inference failed for request %s", job.id)
-            if not job.future.done():
-                job.future.set_exception(RuntimeError("Inference failed"))
-        finally:
-            app.state.active_model = None
-            app.state.queue.task_done()
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    app.state.engines = {}
-    app.state.errors = {}
-    app.state.queue = asyncio.Queue(maxsize=MAX_QUEUE_SIZE)
-    app.state.active_model = None
-    app.state.completed = 0
-    app.state.default_model = DEFAULT_MODEL
-    for name in LOAD_MODELS:
-        try:
-            app.state.engines[name] = await asyncio.to_thread(load_one, name)
-            log.info("Model ready: %s", name)
-        except Exception as exc:
-            log.exception("Model failed to load: %s", name)
-            app.state.errors[name] = type(exc).__name__
-    app.state.worker = asyncio.create_task(inference_worker(app))
-    try:
-        yield
-    finally:
-        app.state.worker.cancel()
-        try:
-            await app.state.worker
-        except asyncio.CancelledError:
-            pass
-
-app = FastAPI(title="MEPLIFEOS / FUGTH AI Gateway", version="1.2.0", lifespan=lifespan)
-
-def check_secret(provided: str | None, variable: str) -> None:
-    expected = os.getenv(variable, "")
-    if not expected:
-        raise HTTPException(status_code=503, detail=f"Server secret {variable} is not configured")
-    if not provided or not secrets.compare_digest(provided, expected):
-        raise HTTPException(status_code=401, detail="Invalid API key")
-
-def require_client_key(x_api_key: str | None = Header(default=None, alias="X-API-Key")):
-    check_secret(x_api_key, "FUGTH_API_KEY")
-
-def require_admin_key(x_admin_key: str | None = Header(default=None, alias="X-Admin-Key")):
-    check_secret(x_admin_key, "FUGTH_ADMIN_KEY")
-
-@app.get("/", include_in_schema=False)
-def homepage():
-    return FileResponse("/app/index.html")
-
-@app.get("/health")
-def health():
-    available = list(app.state.engines)
-    return {
-        "ready": bool(available),
-        "loaded_models": available,
-        "load_errors": app.state.errors,
-        "default_model": app.state.default_model,
-        "queued": app.state.queue.qsize(),
-        "max_queue_size": MAX_QUEUE_SIZE,
-        "active_model": app.state.active_model,
-        "completed_requests": app.state.completed,
-        "api_key_configured": bool(os.getenv("FUGTH_API_KEY")),
-    }
-
-@app.post("/v1/chat", dependencies=[Depends(require_client_key)])
-async def chat(payload: ChatRequest):
-    selected = payload.model or app.state.default_model
-    if selected not in app.state.engines:
-        raise HTTPException(503, detail=f"Model {selected} is not loaded")
-    if app.state.queue.full():
-        raise HTTPException(429, detail="Inference queue full; retry later", headers={"Retry-After": "15"})
-    job = WorkItem(payload, selected)
-    try:
-        app.state.queue.put_nowait(job)
-    except asyncio.QueueFull:
-        raise HTTPException(429, detail="Inference queue full; retry later", headers={"Retry-After": "15"})
-    try:
-        return await asyncio.wait_for(job.future, timeout=REQUEST_TIMEOUT)
-    except asyncio.TimeoutError:
-        job.future.cancel()  # Workers skip queued requests whose clients timed out.
-        raise HTTPException(504, detail="Generation timed out; try a shorter request")
-    except RuntimeError:
-        raise HTTPException(500, detail="Inference failed; check Space logs")
-    except asyncio.CancelledError:
-        job.future.cancel()
-        raise
-
-@app.post("/admin/default-model", dependencies=[Depends(require_admin_key)])
-def change_default(body: DefaultModelRequest):
-    if body.model not in app.state.engines:
-        raise HTTPException(503, detail="Requested model is not loaded")
-    app.state.default_model = body.model