Create app.py

app.py

@@ -0,0 +1,98 @@
+import os, json, httpx
+from typing import Dict, Any
+from fastapi import FastAPI, Body, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, PlainTextResponse
+
+# ========= Config (set via Secrets) =========
+TTS_BASE = os.getenv("TTS_BASE", "https://Percy3822-ActualTTS.hf.space")
+PY_AI_URL = os.getenv("PY_AI_URL", "https://Percy3822-Python_ai.hf.space")      # optional/future
+GODOT_AI_URL = os.getenv("GODOT_AI_URL", "https://Percy3822-Godot_ai.hf.space") # optional/future
+SECRET = os.getenv("BRAIN_SHARED_SECRET")  # same header "x-auth" for internal calls
+
+ROUTES = {
+    "python": PY_AI_URL,
+    "godot": GODOT_AI_URL,
+    "chat":  None,  # handled client-side (or future Chat module)
+}
+
+app = FastAPI(title="Brain_v2 (Router-Only)", version="2.0.0")
+
+# CORS for your local app; restrict later if desired
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+_client = httpx.AsyncClient(timeout=httpx.Timeout(connect=15, read=None, write=15))
+
+def _authorized(req: Request) -> bool:
+    return not SECRET or req.headers.get("x-auth") == SECRET
+
+@app.get("/")
+def root():
+    return PlainTextResponse("Brain_v2 router — POST /process to get stream URLs")
+
+@app.get("/health")
+async def health():
+    return {
+        "ok": True,
+        "routes": {k: (v or "client") for k, v in ROUTES.items()},
+        "tts_ws": f"{TTS_BASE}/ws/tts",
+        "version": "2.0.0"
+    }
+
+@app.post("/process")
+async def process(payload: Dict[str, Any] = Body(...), request: Request = None):
+    """
+    Input: { "text": "...", "module":"auto|python|godot|chat" }
+    Output: { ok, route, stream_url, tts_url }
+    - Client connects directly to stream_url for live TEXT tokens
+    - Client connects directly to tts_url for AUDIO (WS) when needed
+    """
+    if request and not _authorized(request):
+        return JSONResponse({"error": "unauthorized"}, status_code=401)
+
+    text = (payload.get("text") or "").strip()
+    module = (payload.get("module") or "auto").lower()
+    if not text:
+        return JSONResponse({"error": "empty text"}, status_code=400)
+
+    # Lightweight routing
+    low = text.lower()
+    route = "chat"
+    if module in ("python", "godot", "chat"):
+        route = module
+    elif low.startswith(("python:", "py:")):
+        route = "python"
+    elif low.startswith(("godot:", "gd:")):
+        route = "godot"
+
+    target = ROUTES.get(route)
+    stream_url = f"{target}/ws/stream" if target else None
+
+    return {
+        "ok": True,
+        "route": route,
+        "stream_url": stream_url,         # direct model → client (text)
+        "tts_url": f"{TTS_BASE}/ws/tts",  # direct TTS → client (audio)
+        "note": "Connect directly to these URLs for streaming. Brain does not proxy."
+    }
+
+# Optional debug: say text via TTS to test wiring (non-streaming HTTP)
+@app.post("/say")
+async def say(payload: Dict[str, Any] = Body(...), request: Request = None):
+    if request and not _authorized(request):
+        return JSONResponse({"error": "unauthorized"}, status_code=401)
+    txt = (payload.get("text") or "").strip()
+    if not txt:
+        return JSONResponse({"error": "empty text"}, status_code=400)
+    try:
+        async with _client.stream("POST", f"{TTS_BASE}/speak.wav", json={"text": txt}) as r:
+            r.raise_for_status()
+            # we don’t proxy bytes here; caller just checks 200 OK for warmup
+            return {"ok": True}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=502)