Switch to FastAPI Docker Space — no Gradio/pydub Python 3.13 issue

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN pip install --no-cache-dir fastapi uvicorn huggingface_hub
+
+COPY app.py .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -3,21 +3,19 @@ title: Beryl Chat API
 emoji: 🤖
 colorFrom: yellow
 colorTo: gray
-sdk: gradio
-sdk_version: 5.0.0
-app_file: app.py
+sdk: docker
 pinned: true
 license: mit
 ---
 
 # Beryl Chat API
 
-Raw-mode Gradio inference proxy for Beryl Desktop.
+Raw FastAPI inference proxy for Beryl Desktop.
 
 ## API Usage
 
 ```
-POST /api/predict
+POST /predict
 Content-Type: application/json
 
 {

app.py

@@ -1,10 +1,12 @@
 """
-Beryl Chat API — Gradio raw-mode proxy Space
-Hosted at: AIBRUH/beryl-chat-api
-Routes: POST /api/predict  →  { data: [messages_json, model_key] }
-Returns: { data: [response_text] }
+Beryl Chat API — FastAPI raw inference proxy
+Hosted at: AIBRUH/beryl-chat-api (Docker Space)
+POST /predict  →  { data: [messages_json, model_key] }
+POST /run/predict  →  same (Gradio-compat alias)
 """
-import os, json, gradio as gr
+import os, json
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 from huggingface_hub import InferenceClient
 
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
@@ -17,69 +19,48 @@ MODELS = {
     "auto":   "Qwen/Qwen2.5-7B-Instruct",
 }
 
-EMOTION_KW = ["feel","lonely","sad","love","companion","miss","emotional","relationship"]
+EMOTION_KW = ["feel","lonely","sad","love","companion","miss",
+              "emotional","relationship","heart","care","hurt"]
 
-def route_model(messages_list, model_key):
-    if model_key and model_key != "auto":
-        return MODELS.get(model_key, MODELS["auto"])
-    last = (messages_list[-1].get("content","") if messages_list else "").lower()
-    if any(k in last for k in EMOTION_KW):
-        return MODELS["glm"]
-    return MODELS["qwen"]
+app = FastAPI(title="Beryl Chat API")
 
-def chat(messages_json: str, model_key: str = "auto") -> str:
-    """Raw inference endpoint. Called via Gradio HTTP API."""
-    try:
-        messages = json.loads(messages_json)
-        if not isinstance(messages, list):
-            return json.dumps({"error": "messages must be a JSON array"})
 
-        model = route_model(messages, model_key.strip() if model_key else "auto")
+def route_model(messages: list, model_key: str) -> str:
+    if model_key and model_key not in ("auto", ""):
+        return MODELS.get(model_key, MODELS["auto"])
+    last = (messages[-1].get("content","") if messages else "").lower()
+    return MODELS["glm"] if any(k in last for k in EMOTION_KW) else MODELS["qwen"]
 
-        client = InferenceClient(
-            provider="hf-inference",
-            api_key=HF_TOKEN,
-        )
 
-        result = client.chat_completion(
-            model=model,
-            messages=messages,
-            max_tokens=600,
-            temperature=0.78,
-        )
-        response = result.choices[0].message.content
-        return json.dumps({
-            "response": response,
-            "model":    model.split("/")[-1],
-            "ok":       True,
-        })
+def do_chat(messages: list, model_key: str) -> dict:
+    model = route_model(messages, model_key)
+    client = InferenceClient(provider="hf-inference", api_key=HF_TOKEN)
+    result = client.chat_completion(
+        model=model, messages=messages,
+        max_tokens=600, temperature=0.78,
+    )
+    return {"response": result.choices[0].message.content,
+            "model": model.split("/")[-1], "ok": True}
 
-    except Exception as e:
-        # Return error as JSON so caller can handle gracefully
-        return json.dumps({"ok": False, "error": str(e), "response": ""})
 
+@app.get("/health")
+def health():
+    return {"ok": True, "version": "1.0.0", "service": "beryl-chat-api"}
 
-def health() -> str:
-    return json.dumps({"ok": True, "version": "1.0.0", "service": "beryl-chat-api"})
 
+@app.post("/predict")
+@app.post("/run/predict")      # Gradio-compat alias
+async def predict(request: Request):
+    try:
+        body = await request.json()
+        data = body.get("data", [])
+        messages_json = data[0] if len(data) > 0 else "[]"
+        model_key     = data[1] if len(data) > 1 else "auto"
 
-# ── Raw Gradio interface — NO visual components used ──────────────────────────
-# gr.Interface exposes /api/predict automatically
-with gr.Blocks(title="Beryl Chat API") as demo:
-    # Minimal UI just to satisfy HF Space requirements
-    gr.Markdown("## Beryl Chat API\nRaw inference proxy. Call `/api/predict` directly.")
-    with gr.Row(visible=False):
-        msg_in    = gr.Textbox(label="messages_json")
-        model_in  = gr.Textbox(label="model_key", value="auto")
-        out       = gr.Textbox(label="response_json")
-        btn       = gr.Button("Run")
-        btn.click(fn=chat, inputs=[msg_in, model_in], outputs=out)
-
-    # Also expose health
-    with gr.Row(visible=False):
-        health_out = gr.Textbox(label="health")
-        health_btn = gr.Button("health")
-        health_btn.click(fn=health, inputs=[], outputs=health_out)
+        messages = json.loads(messages_json)
+        result   = do_chat(messages, model_key)
+        return JSONResponse({"data": [json.dumps(result)]})
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_api=True)
+    except Exception as e:
+        err = json.dumps({"ok": False, "error": str(e), "response": ""})
+        return JSONResponse({"data": [err]}, status_code=200)