Update app.py

app.py

@@ -3,7 +3,7 @@ import asyncio
 from typing import List, Dict, Any, Optional, Literal
 
 import httpx
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, UploadFile, File
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field, ValidationError
@@ -28,8 +28,8 @@ CONNECT_TIMEOUT_S   = float(os.getenv("CONNECT_TIMEOUT_S", "10"))
 # Schemas
 # =========================
 class Cursor(BaseModel):
-    l: int = Field(..., description="line")
-    c: int = Field(..., description="col")
+    l: int
+    c: int
 
 class Viewport(BaseModel):
     start: int
@@ -81,11 +81,9 @@ class CodeHelpOut(BaseModel):
     notes: Dict[str, Any] = {}
 
 # =========================
-# App + Static UI
+# App + UI
 # =========================
-app = FastAPI(title="Brain (Router)", version="1.0")
-
-# Serve the static UI
+app = FastAPI(title="Brain (Router)", version="1.2")
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 @app.get("/")
@@ -93,7 +91,7 @@ async def root_ui():
     return FileResponse("static/ui.html")
 
 # =========================
-# HTTP client (async)
+# HTTP client
 # =========================
 client: Optional[httpx.AsyncClient] = None
 
@@ -102,64 +100,21 @@ async def _startup():
     global client
     client = httpx.AsyncClient(
         timeout=httpx.Timeout(REQUEST_TIMEOUT_S, connect=CONNECT_TIMEOUT_S),
-        headers={"User-Agent": "BrainRouter/1.0"}
+        headers={"User-Agent": "BrainRouter/1.2"}
     )
-    asyncio.create_task(worker_loop())
-    asyncio.create_task(worker_loop())
 
 @app.on_event("shutdown")
 async def _shutdown():
     global client
-    try:
-        if client is not None:
-            await client.aclose()
-    except Exception:
-        pass
-
-# =========================
-# Small Utilities
-# =========================
-def _truncate_bytes(s: str, budget: int) -> str:
-    b = s.encode("utf-8")
-    if len(b) <= budget:
-        return s
-    return b[:budget].decode("utf-8", errors="ignore")
-
-def _shrink_lines_to_max(window: Viewport, max_lines: int) -> Viewport:
-    lines = window.text.splitlines()
-    if len(lines) <= max_lines:
-        return window
-    keep = max_lines
-    slice_start = max(0, len(lines) - keep)
-    new_text = "\n".join(lines[slice_start:])
-    return Viewport(start=window.end - keep + 1, end=window.end, text=new_text)
+    if client:
+        await client.aclose()
 
 async def _safe_post_json(url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
     if client is None:
-        raise HTTPException(status_code=500, detail="HTTP client not initialized")
-    try:
-        r = await client.post(url, json=payload)
-        r.raise_for_status()
-        return r.json()
-    except Exception as e:
-        raise HTTPException(status_code=502, detail=f"POST {url} failed: {e}")
-
-# =========================
-# Priority Queue (reserved)
-# =========================
-TASK_Q: "asyncio.PriorityQueue[tuple[int,float,dict]]" = asyncio.PriorityQueue()
-
-async def worker_loop():
-    while True:
-        priority, ts, task = await TASK_Q.get()
-        try:
-            handler = task.get("handler")
-            if handler:
-                await handler(**task.get("args", {}))
-        except Exception:
-            pass
-        finally:
-            TASK_Q.task_done()
+        raise HTTPException(status_code=500, detail="HTTP client not ready")
+    r = await client.post(url, json=payload)
+    r.raise_for_status()
+    return r.json()
 
 # =========================
 # Health & Warmup
@@ -173,7 +128,7 @@ async def health():
         "vision": bool(VISION_URL),
         "memory": bool(MEMORY_URL),
     }
-    return {"ok": True, "deps": deps, "version": "1.0"}
+    return {"ok": True, "deps": deps, "version": "1.2"}
 
 @app.post("/warmup")
 async def warmup():
@@ -183,83 +138,84 @@ async def warmup():
             res = await _safe_post_json(f"{PYTHON_AI_URL}/code_help", {
                 "intent":"ping","file":"_warmup_.py","lang":"python",
                 "cursor":{"l":1,"c":1},
-                "viewport":{"start":1,"end":1,"text":"print('warmup')\n"},
+                "viewport":{"start":1,"end":1,"text":"print('warmup')"},
                 "diag": [], "term":"", "mem":{"short":[],"sess":[],"proj":[]}
             })
-            notes["python_ai"] = "ok" if res else "no-response"
-        except HTTPException as e:
-            notes["python_ai"] = f"err: {e.detail}"
+            notes["python_ai"] = "ok" if res else "fail"
+        except Exception as e:
+            notes["python_ai"] = f"err: {e}"
     if TTS_URL:
         try:
-            res = await _safe_post_json(f"{TTS_URL}/speak", {"text":"warming up"})
-            notes["tts"] = "ok" if "audio_path" in res else "no-audio"
-        except HTTPException as e:
-            notes["tts"] = f"err: {e.detail}"
+            res = await _safe_post_json(f"{TTS_URL}/speak", {"text":"warmup"})
+            notes["tts"] = "ok" if "audio_path" in res else "fail"
+        except Exception as e:
+            notes["tts"] = f"err: {e}"
+    if STT_URL:
+        notes["stt"] = "configured"
     return {"ok": True, "notes": notes}
 
 # =========================
-# Core: Code Help endpoint
+# Code Help
 # =========================
-def _enforce_budgets(t: Telemetry, m: Memory) -> tuple[Telemetry, Memory, int, int]:
-    t2 = Telemetry(
-        file=t.file, lang=t.lang, cursor=t.cursor,
-        viewport=_shrink_lines_to_max(t.viewport, VIEWPORT_MAX_LINES),
-        diag=t.diag[:5],
-        term=t.term
-    )
-    mem_text = " | ".join(m.short + m.sess + m.proj)
-    mem_text = _truncate_bytes(mem_text, MEMORY_BUDGET_BYTES)
-    m2 = Memory(short=[], sess=[mem_text] if mem_text else [], proj=[])
-    used_mem = len(mem_text.encode("utf-8"))
-    prompt_bytes = (
-        len(t2.file) + len(t2.lang) +
-        len(t2.viewport.text) + sum(len(d.msg) for d in t2.diag) +
-        len(t2.term) + used_mem
-    )
-    return t2, m2, used_mem, prompt_bytes
-
-async def _route_python_ai(payload: Dict[str, Any]) -> PythonAIOutput:
-    if not PYTHON_AI_URL:
-        raise HTTPException(status_code=500, detail="PYTHON_AI_URL not configured")
-    res = await _safe_post_json(f"{PYTHON_AI_URL}/code_help", payload)
-    try:
-        return PythonAIOutput(**res)
-    except ValidationError as ve:
-        raise HTTPException(status_code=502, detail=f"Bad AI JSON schema: {ve}")
-
-async def _send_tts(text: str) -> Optional[str]:
-    if not TTS_URL or not text:
-        return None
-    try:
-        res = await _safe_post_json(f"{TTS_URL}/speak", {"text": text})
-        audio_path = res.get("audio_path")
-        if not audio_path:
-            return None
-        base = TTS_URL.rstrip("/")
-        name = audio_path.split("/")[-1]
-        return f"{base}/file/{name}"
-    except HTTPException:
-        return None
-
 @app.post("/code_help", response_model=CodeHelpOut)
 async def code_help(x: CodeHelpIn):
-    t2, m2, used_mem, used_prompt = _enforce_budgets(x.telemetry, x.memory)
     py_in = {
         "intent": x.utterance,
-        "file": t2.file,
-        "lang": t2.lang,
-        "cursor": {"l": t2.cursor.l, "c": t2.cursor.c},
-        "viewport": {"start": t2.viewport.start, "end": t2.viewport.end, "text": t2.viewport.text},
-        "diag": [{"l": d.l, "sev": d.sev, "msg": d.msg} for d in t2.diag],
-        "term": t2.term,
-        "mem": {"short": m2.short, "sess": m2.sess, "proj": m2.proj}
+        "file": x.telemetry.file,
+        "lang": x.telemetry.lang,
+        "cursor": {"l": x.telemetry.cursor.l, "c": x.telemetry.cursor.c},
+        "viewport": {"start": x.telemetry.viewport.start, "end": x.telemetry.viewport.end, "text": x.telemetry.viewport.text},
+        "diag": [{"l": d.l, "sev": d.sev, "msg": d.msg} for d in x.telemetry.diag],
+        "term": x.telemetry.term,
+        "mem": {"short": x.memory.short, "sess": x.memory.sess, "proj": x.memory.proj}
     }
-    ai_out = await _route_python_ai(py_in)
-    tts_url = await _send_tts(ai_out.explanation)
-    return CodeHelpOut(
-        ai=ai_out,
-        tts_audio_url=tts_url,
-        used_memory_bytes=used_mem,
-        used_prompt_bytes=used_prompt,
-        notes={"response_mode": x.response_mode}
-    )
+    res = await _safe_post_json(f"{PYTHON_AI_URL}/code_help", py_in)
+    ai_out = PythonAIOutput(**res)
+    tts_url = None
+    if TTS_URL:
+        try:
+            r = await _safe_post_json(f"{TTS_URL}/speak", {"text": ai_out.explanation})
+            if "audio_path" in r:
+                base = TTS_URL.rstrip("/")
+                name = r["audio_path"].split("/")[-1]
+                tts_url = f"{base}/file/{name}"
+        except:
+            pass
+    return CodeHelpOut(ai=ai_out, tts_audio_url=tts_url, used_memory_bytes=0, used_prompt_bytes=0, notes={})
+
+# =========================
+# TTS Proxy
+# =========================
+class SpeakIn(BaseModel):
+    text: str
+    sample_rate: Optional[int] = None
+    length_scale: Optional[float] = None
+    noise_scale: Optional[float] = None
+    noise_w: Optional[float] = None
+
+@app.post("/tts_speak")
+async def tts_speak(x: SpeakIn):
+    if not TTS_URL:
+        raise HTTPException(status_code=500, detail="TTS_URL not configured")
+    payload = {k:v for k,v in x.model_dump().items() if v is not None}
+    r = await _safe_post_json(f"{TTS_URL}/speak", payload)
+    if "audio_path" not in r:
+        raise HTTPException(status_code=502, detail="TTS failed")
+    base = TTS_URL.rstrip("/")
+    name = r["audio_path"].split("/")[-1]
+    return {"tts_audio_url": f"{base}/file/{name}"}
+
+# =========================
+# STT Proxy
+# =========================
+@app.post("/stt_transcribe")
+async def stt_transcribe(file: UploadFile = File(...)):
+    if not STT_URL:
+        raise HTTPException(status_code=500, detail="STT_URL not configured")
+    if client is None:
+        raise HTTPException(status_code=500, detail="Client not ready")
+    data = await file.read()
+    files = {"file": (file.filename or "audio.wav", data, file.content_type or "audio/wav")}
+    r = await client.post(f"{STT_URL}/transcribe", files=files)
+    r.raise_for_status()
+    return r.json()