Update app/main.py

app/main.py

@@ -1,74 +1,155 @@
-import os
+import os, json, traceback
 from pathlib import Path
 from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
 from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.exception_handlers import http_exception_handler
+from starlette.exceptions import HTTPException as StarletteHTTPException
 import config as cfg
 from agent_system import orchestrator
 from sandbox import pip_install
 
-app = FastAPI(title="PraisonChat", version="4.0.0")
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+app = FastAPI(title="PraisonChat", version="5.0.0")
+app.add_middleware(CORSMiddleware, allow_origins=["*"],
+                   allow_methods=["*"], allow_headers=["*"])
 
 STATIC_DIR = Path(__file__).parent / "static"
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
 
+# ── ALWAYS return JSON errors, never HTML ─────────────────────
+@app.exception_handler(StarletteHTTPException)
+async def json_http_exception(request, exc):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"ok": False, "detail": str(exc.detail)}
+    )
+
+@app.exception_handler(Exception)
+async def json_generic_exception(request, exc):
+    tb = traceback.format_exc()
+    print(f"[SERVER] Unhandled: {exc}\n{tb}")
+    return JSONResponse(
+        status_code=500,
+        content={"ok": False, "detail": str(exc)}
+    )
+
+
+# ── Pages ──────────────────────────────────────────────────────
 @app.get("/", response_class=HTMLResponse)
 async def root():
     return HTMLResponse((STATIC_DIR / "index.html").read_text(encoding="utf-8"))
 
 
+# ── System ─────────────────────────────────────────────────────
 @app.get("/api/health")
 def health():
-    return {"status":"ok","version":"4.0.0",
-            "longcat_key_set": bool(cfg.get_longcat_key()),
-            "telegram_set":    bool(cfg.get_telegram_token())}
-
+    return {"ok": True, "version": "5.0.0",
+            "longcat_key": bool(cfg.get_longcat_key()),
+            "telegram":    bool(cfg.get_telegram_token())}
 
 @app.get("/api/models")
 def models():
-    return {"models":[
+    return {"models": [
         {"id":"LongCat-Flash-Lite",         "name":"LongCat Flash Lite",     "context":"320K","speed":"⚡ Fastest","quota":"50M/day"},
         {"id":"LongCat-Flash-Chat",          "name":"LongCat Flash Chat",     "context":"256K","speed":"🚀 Fast",   "quota":"500K/day"},
         {"id":"LongCat-Flash-Thinking-2601", "name":"LongCat Flash Thinking", "context":"256K","speed":"🧠 Deep",   "quota":"500K/day"},
     ]}
 
+@app.get("/api/builtin-tools")
+def builtin_tools():
+    return {"tools":[
+        {"name":"datetime",   "description":"Real system date & time",      "icon":"🕐"},
+        {"name":"web_search", "description":"Real DuckDuckGo search",       "icon":"🔍"},
+        {"name":"fetch_page", "description":"Real webpage content",         "icon":"🌐"},
+        {"name":"run_python", "description":"Real Python code execution",   "icon":"🐍"},
+        {"name":"voice",      "description":"Real MP3 audio via gTTS",      "icon":"🔊"},
+        {"name":"math",       "description":"Real math & calculations",     "icon":"🔢"},
+        {"name":"qr_code",    "description":"QR code generation",           "icon":"📱"},
+        {"name":"charts",     "description":"Charts & graphs via matplotlib","icon":"📊"},
+    ]}
 
+@app.get("/api/memory")
+def get_memory():
+    from memory import get_all_for_api
+    return get_all_for_api()
+
+@app.delete("/api/memory/{key}")
+def delete_memory(key: str):
+    from memory import MEM_DIR
+    safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in key)
+    path = MEM_DIR / f"{safe}.md"
+    if path.exists():
+        path.unlink()
+        return {"ok": True}
+    return {"ok": False, "detail": "Not found"}
+
+@app.get("/api/skills")
+def get_skills():
+    from memory import list_skills, load_skill
+    skills = list_skills()
+    for s in skills:
+        s["code"] = load_skill(s["name"])[:800]
+    return {"skills": skills}
+
+@app.delete("/api/skills/{name}")
+def delete_skill_route(name: str):
+    from memory import delete_skill
+    ok = delete_skill(name)
+    return {"ok": ok}
+
+
+# ── Chat ───────────────────────────────────────────────────────
 @app.post("/api/chat")
 async def chat(request: Request):
     try:
         body = await request.json()
     except Exception:
-        raise HTTPException(400, "Invalid JSON")
-    messages = body.get("messages",[])
+        return JSONResponse(status_code=400,
+                            content={"ok":False,"detail":"Invalid JSON body"})
+
+    messages = body.get("messages", [])
     api_key  = body.get("api_key","").strip() or cfg.get_longcat_key()
     model    = body.get("model","LongCat-Flash-Lite")
+
     if not api_key:
-        raise HTTPException(400,"LongCat API key required. Add it in Settings.")
+        return JSONResponse(status_code=400,
+            content={"ok":False,"detail":"LongCat API key required. Add it in Settings."})
     if not messages:
-        raise HTTPException(400,"No messages")
+        return JSONResponse(status_code=400,
+            content={"ok":False,"detail":"No messages provided"})
+
     if api_key != cfg.get_longcat_key(): cfg.set_longcat_key(api_key)
     if model   != cfg.get_model():       cfg.set_model(model)
+
     user_message = messages[-1].get("content","")
     history      = messages[:-1]
+
     async def stream():
-        async for chunk in orchestrator.stream_response(user_message, history, api_key, model):
+        async for chunk in orchestrator.stream_response(
+            user_message, history, api_key, model
+        ):
             yield f"data: {chunk}\n\n"
+
     return StreamingResponse(stream(), media_type="text/event-stream",
-                             headers={"X-Accel-Buffering":"no","Cache-Control":"no-cache"})
+        headers={"X-Accel-Buffering":"no","Cache-Control":"no-cache","Connection":"keep-alive"})
 
 
+# ── Package installer ──────────────────────────────────────────
 @app.post("/api/install-package")
 async def install_package(request: Request):
-    body = await request.json()
-    packages = body.get("packages",[])
-    if not packages: raise HTTPException(400,"No packages")
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse(status_code=400, content={"ok":False,"detail":"Invalid JSON"})
+    packages = body.get("packages", [])
+    if not packages:
+        return JSONResponse(status_code=400, content={"ok":False,"detail":"No packages"})
     import asyncio
     loop = asyncio.get_event_loop()
     ok, msg = await loop.run_in_executor(None, pip_install, packages)
-    return {"ok":ok,"message":msg}
+    return {"ok": ok, "message": msg}
 
 
 # ── Telegram ───────────────────────────────────────────────────
@@ -78,58 +159,88 @@ async def telegram_webhook(request: Request, background_tasks: BackgroundTasks):
     try:
         update = await request.json()
     except Exception:
-        return JSONResponse({"ok":True})
-    print(f"[WEBHOOK] {str(update)[:200]}")
+        return JSONResponse({"ok": True})
+
+    print(f"[WEBHOOK] {str(update)[:150]}")
     api_key = cfg.get_longcat_key()
     model   = cfg.get_model()
+
     if not api_key:
-        msg = update.get("message",{})
-        chat_id = msg.get("chat",{}).get("id")
+        msg     = update.get("message", {})
+        chat_id = msg.get("chat", {}).get("id")
         if chat_id:
             from telegram_bot import send_message
-            await send_message(chat_id,"⚠️ No LongCat API key. Open the web UI, go to Settings, and save your key.")
-        return JSONResponse({"ok":True})
+            await send_message(chat_id,
+                "⚠️ No API key saved. Open the web UI → Settings → save your LongCat key, "
+                "then re-connect Telegram.")
+        return JSONResponse({"ok": True})
+
     background_tasks.add_task(handle_update, update, api_key, model)
-    return JSONResponse({"ok":True})
+    return JSONResponse({"ok": True})
 
 
 @app.post("/api/telegram/setup")
 async def telegram_setup(request: Request):
-    from telegram_bot import set_webhook, get_bot_info
-    body     = await request.json()
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse(status_code=400, content={"ok":False,"detail":"Invalid JSON"})
+
     token    = body.get("token","").strip()
     base_url = body.get("base_url","").strip()
     api_key  = body.get("api_key","").strip()
     model    = body.get("model","").strip()
+
     if token:   cfg.set_telegram_token(token)
     if api_key: cfg.set_longcat_key(api_key)
     if model:   cfg.set_model(model)
+
     if not cfg.get_telegram_token():
-        raise HTTPException(400,"No Telegram bot token")
-    bot = await get_bot_info()
-    if not bot.get("ok"):
-        raise HTTPException(400,f"Invalid token: {bot}")
-    webhook_result = {}
-    if base_url:
-        webhook_result = await set_webhook(base_url)
-    return {"ok":True,"bot":bot.get("result",{}),"webhook":webhook_result}
+        return JSONResponse(status_code=400,
+            content={"ok":False,"detail":"No Telegram bot token provided"})
+
+    try:
+        from telegram_bot import get_bot_info, set_webhook
+        bot = await get_bot_info()
+        if not bot.get("ok"):
+            return JSONResponse(status_code=400,
+                content={"ok":False,"detail":f"Invalid bot token: {bot.get('description','')}"})
+
+        webhook_result = {}
+        if base_url:
+            webhook_result = await set_webhook(base_url)
+
+        return JSONResponse({"ok":True,
+                             "bot":bot.get("result",{}),
+                             "webhook":webhook_result})
+    except Exception as e:
+        return JSONResponse(status_code=500,
+            content={"ok":False,"detail":str(e)})
 
 
 @app.get("/api/telegram/status")
 async def telegram_status():
-    from telegram_bot import get_webhook_info, get_bot_info
-    token = cfg.get_telegram_token()
-    if not token:
-        return {"connected":False,"message":"No bot token"}
-    bot  = await get_bot_info()
-    hook = await get_webhook_info()
-    return {"connected":bot.get("ok",False),"bot":bot.get("result",{}),
-            "webhook":hook.get("result",{}),"longcat_key_set":bool(cfg.get_longcat_key())}
+    try:
+        token = cfg.get_telegram_token()
+        if not token:
+            return {"connected":False,"message":"No bot token set"}
+        from telegram_bot import get_bot_info, get_webhook_info
+        bot  = await get_bot_info()
+        hook = await get_webhook_info()
+        return {"connected":bot.get("ok",False),
+                "bot":bot.get("result",{}),
+                "webhook":hook.get("result",{}),
+                "longcat_key_set":bool(cfg.get_longcat_key())}
+    except Exception as e:
+        return {"connected":False,"message":str(e)}
 
 
 @app.delete("/api/telegram/disconnect")
 async def telegram_disconnect():
-    from telegram_bot import delete_webhook
-    result = await delete_webhook()
-    cfg.set("telegram_token","")
-    return {"ok":True,"result":result}
+    try:
+        from telegram_bot import delete_webhook
+        result = await delete_webhook()
+        cfg.set("telegram_token","")
+        return {"ok":True,"result":result}
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"ok":False,"detail":str(e)})