Update app.py

app.py

@@ -4,6 +4,7 @@ from pathlib import Path
 import gradio as gr
 import spaces
 import httpx
+import edge_tts
 from huggingface_hub import hf_hub_download
 
 # ===== 0. CONFIG (override in Space Settings → Variables and secrets) =====
@@ -49,7 +50,7 @@ def memory_limit_gb():
 CORES = effective_cpus()
 print(f"[resources] effective cores: {CORES} | RAM limit: {memory_limit_gb() or '?'} GB")
 
-# ===== 3. FETCH PREBUILT llama.cpp (seconds, zero compilation) =====
+# ===== 3. FETCH PREBUILT llama.cpp =====
 FALLBACK_TAG = "b8407"
 
 def resolve_tag() -> str:
@@ -70,7 +71,6 @@ def ensure_llama_server() -> Path:
     root = Path.home() / ".cache" / "llamacpp" / tag
     server = root / "build" / "bin" / "llama-server"
     if not server.exists():
-        # llama.cpp Linux binaries are now distributed as .tar.gz (not .zip)
         url = (f"https://github.com/ggml-org/llama.cpp/releases/download/"
                f"{tag}/llama-{tag}-bin-ubuntu-x64.tar.gz")
         print(f"[llama.cpp] downloading {url}")
@@ -78,7 +78,6 @@ def ensure_llama_server() -> Path:
         with urllib.request.urlopen(req, timeout=180) as r:
             blob = r.read()
         root.mkdir(parents=True, exist_ok=True)
-        # Extract tar.gz archive
         with tarfile.open(fileobj=io.BytesIO(blob), mode="r:gz") as t:
             t.extractall(root)
         for f in (root / "build" / "bin").iterdir():
@@ -89,7 +88,7 @@ def ensure_llama_server() -> Path:
 print(f"[model] downloading {MODEL_REPO}/{MODEL_FILE}")
 model_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE)
 
-# ===== 5. LAUNCH llama-server, SIZED TO THE DETECTED HARDWARE =====
+# ===== 5. LAUNCH llama-server =====
 server_bin = ensure_llama_server()
 UPSTREAM = f"http://127.0.0.1:{LLAMA_PORT}"
 
@@ -100,11 +99,11 @@ env.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
 cmd = [
     str(server_bin), "-m", model_path,
     "--host", "127.0.0.1", "--port", str(LLAMA_PORT),
-    "-t", str(CORES), "-tb", str(CORES),   # every core the cgroup gives us
+    "-t", str(CORES), "-tb", str(CORES),
     "-c", str(CTX_SIZE),
-    "-np", str(PARALLEL),                  # real concurrent slots, no global lock
-    "-fa",                                 # flash attention → much smaller KV cache
-    "--cache-reuse", "256",                # KV reuse across chat turns
+    "-np", str(PARALLEL),
+    "-fa",
+    "--cache-reuse", "256",
 ]
 if API_KEY:
     cmd += ["--api-key", API_KEY]
@@ -127,7 +126,7 @@ def wait_ready(timeout=600):
 
 wait_ready()
 
-# ===== 6. GRADIO UI (same backend as the API) =====
+# ===== 6. GRADIO UI =====
 from openai import OpenAI
 oai = OpenAI(base_url=f"{UPSTREAM}/v1", api_key=API_KEY or "not-needed")
 
@@ -158,25 +157,129 @@ def chat(message, history):
 
 with gr.Blocks() as demo:
     gr.Markdown(
-        f"# ⚡ llama.cpp on ZeroGPU's free CPU\n"
-        f"`{MODEL_REPO}` · {CORES} threads · ctx {CTX_SIZE} · {PARALLEL} parallel slots\n\n"
-        f"**External API:** `POST /v1/chat/completions` on this Space's `*.hf.space` URL."
+        f"# ⚡ llama.cpp + Edge-TTS API on ZeroGPU's CPU\n"
+        f"`{MODEL_REPO}` · {CORES} threads · ctx {CTX_SIZE}\n\n"
+        f"**Endpoints Available:**\n"
+        f"- `POST /v1/chat/completions` (LLM Chat)\n"
+        f"- `GET/POST /tts` (Microsoft Edge Text-to-Speech Stream)\n"
+        f"- `GET /tts/voices` (List Edge TTS Voices)"
     )
-    gr.ChatInterface(fn=chat, examples=["Who are you?",
-        "Write a python script to reverse a string.", "Explain quantum computing."])
+    gr.ChatInterface(fn=chat, examples=["Who are you?", "Tell me a fast joke."])
 
 demo = demo.queue()
 
-# ===== 7. PUBLIC /v1 PROXY — the supported way, no monkey-patch =====
+# ===== 7. FASTAPI PROXY & EDGE-TTS ENDPOINTS =====
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import Response, StreamingResponse
+from fastapi.responses import Response, StreamingResponse, JSONResponse
 
-app = FastAPI(title="llama-cpp-proxy")
-app.add_middleware(CORSMiddleware, allow_origins=["*"],
-                   allow_methods=["*"], allow_headers=["*"])
+app = FastAPI(title="llama-cpp-edgetts-proxy")
+app.add_middleware(
+    CORSMiddleware, 
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"], 
+    allow_headers=["*"]
+)
 _http = httpx.AsyncClient(timeout=httpx.Timeout(None))
 
+# Helper functions to normalize speed and pitch for EdgeTTS
+def format_rate(rate_input):
+    if rate_input is None:
+        return "+0%"
+    val = str(rate_input).strip()
+    if val.endswith("%"):
+        return val if val.startswith(("+", "-")) else f"+{val}"
+    try:
+        f = float(val)
+        pct = int(round((f - 1.0) * 100))
+        return f"+{pct}%" if pct >= 0 else f"{pct}%"
+    except ValueError:
+        return "+0%"
+
+def format_pitch(pitch_input):
+    if pitch_input is None:
+        return "+0Hz"
+    val = str(pitch_input).strip()
+    if val.endswith("Hz") or val.endswith("%"):
+        return val if val.startswith(("+", "-")) else f"+{val}"
+    try:
+        val_int = int(val)
+        return f"+{val_int}Hz" if val_int >= 0 else f"{val_int}Hz"
+    except ValueError:
+        return "+0Hz"
+
+# --- Edge-TTS Stream Endpoint ---
+@app.api_route("/tts", methods=["GET", "POST"])
+async def tts_stream(request: Request):
+    """
+    Query or JSON Parameters:
+    - text: text to read
+    - voice: e.g., 'en-US-AriaNeural' or 'en-US-ChristopherNeural'
+    - speed / rate: e.g. 1.2 or '+20%'
+    - pitch: e.g. '+0Hz' or '+5%'
+    """
+    if request.method == "POST":
+        try:
+            data = await request.json()
+        except Exception:
+            data = {}
+    else:
+        data = dict(request.query_params)
+
+    text = data.get("text", "")
+    if not text:
+        return JSONResponse({"error": "Missing 'text' parameter"}, status_code=400)
+
+    voice = data.get("voice", "en-US-AriaNeural")
+    raw_rate = data.get("rate") or data.get("speed")
+    rate = format_rate(raw_rate)
+    pitch = format_pitch(data.get("pitch"))
+
+    async def generate_audio():
+        communicate = edge_tts.Communicate(text=text, voice=voice, rate=rate, pitch=pitch)
+        async for chunk in communicate.stream():
+            if chunk["type"] == "audio":
+                yield chunk["data"]
+
+    return StreamingResponse(
+        generate_audio(),
+        media_type="audio/mpeg",
+        headers={
+            "Cache-Control": "no-cache",
+            "Content-Disposition": "inline; filename=tts.mp3"
+        }
+    )
+
+# --- OpenAI Audio Speech Compatible Endpoint ---
+@app.api_route("/v1/audio/speech", methods=["POST"])
+async def openai_speech(request: Request):
+    try:
+        data = await request.json()
+    except Exception:
+        data = {}
+
+    text = data.get("input", "")
+    voice = data.get("voice", "en-US-AriaNeural")
+    speed = data.get("speed", 1.0)
+    
+    rate = format_rate(speed)
+
+    async def generate_audio():
+        communicate = edge_tts.Communicate(text=text, voice=voice, rate=rate)
+        async for chunk in communicate.stream():
+            if chunk["type"] == "audio":
+                yield chunk["data"]
+
+    return StreamingResponse(generate_audio(), media_type="audio/mpeg")
+
+# --- Get All Available Voices ---
+@app.get("/tts/voices")
+async def list_voices():
+    voices = await edge_tts.list_voices()
+    return JSONResponse(voices)
+
+# --- Proxy LLM Chat Completions ---
 @app.api_route("/v1/{path:path}", methods=["GET", "POST"])
 async def v1_proxy(path: str, request: Request):
     body = await request.body()
@@ -206,7 +309,8 @@ async def v1_proxy(path: str, request: Request):
     return Response(content=resp.content, status_code=resp.status_code,
                     media_type=resp.headers.get("content-type", "application/json"))
 
-app = gr.mount_gradio_app(app, demo, path="/")   # mounted LAST so /v1/* wins
+# Mount Gradio UI
+app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
     import uvicorn