Update app/main.py

app/main.py

@@ -4,13 +4,12 @@ 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
+import config as cfg
 from agent_system import orchestrator
-from tool_executor import BUILTIN_TOOL_IMPLEMENTATIONS, pip_install
+from sandbox import pip_install
 
-app = FastAPI(title="PraisonChat", version="3.0.0")
-
-app.add_middleware(CORSMiddleware, allow_origins=["*"],
-                   allow_methods=["*"], allow_headers=["*"])
+app = FastAPI(title="PraisonChat", version="4.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")
@@ -18,144 +17,119 @@ app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
-    return HTMLResponse(content=(STATIC_DIR / "index.html").read_text(encoding="utf-8"))
+    return HTMLResponse((STATIC_DIR / "index.html").read_text(encoding="utf-8"))
 
 
 @app.get("/api/health")
 def health():
-    return {"status": "ok", "version": "3.0.0"}
+    return {"status":"ok","version":"4.0.0",
+            "longcat_key_set": bool(cfg.get_longcat_key()),
+            "telegram_set":    bool(cfg.get_telegram_token())}
 
 
 @app.get("/api/models")
 def 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"},
+    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():
-    items = [
-        {"name":"get_current_datetime","description":"Real system date & time","icon":"🕐"},
-        {"name":"search_web",          "description":"Real DuckDuckGo search",   "icon":"🔍"},
-        {"name":"fetch_webpage",       "description":"Real webpage content fetch","icon":"🌐"},
-        {"name":"run_python_code",     "description":"Real Python execution",     "icon":"🐍"},
-        {"name":"create_voice",        "description":"Real MP3 audio via gTTS",   "icon":"🔊"},
-        {"name":"calculate",           "description":"Real math evaluation",       "icon":"🔢"},
-    ]
-    return {"tools": items}
-
-
 @app.post("/api/chat")
 async def chat(request: Request):
     try:
         body = await request.json()
     except Exception:
-        raise HTTPException(400, "Invalid JSON body")
-
-    messages = body.get("messages", [])
-    api_key  = body.get("api_key") or os.getenv("LONGCAT_API_KEY","")
+        raise HTTPException(400, "Invalid JSON")
+    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")
+        raise HTTPException(400,"LongCat API key required. Add it in Settings.")
     if not messages:
-        raise HTTPException(400, "No messages")
-
+        raise HTTPException(400,"No messages")
+    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):
             yield f"data: {chunk}\n\n"
-
     return StreamingResponse(stream(), media_type="text/event-stream",
                              headers={"X-Accel-Buffering":"no","Cache-Control":"no-cache"})
 
 
-# ══════════════════════════════════════════════════════════════
-#  TELEGRAM INTEGRATION
-# ══════════════════════════════════════════════════════════════
+@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")
+    import asyncio
+    loop = asyncio.get_event_loop()
+    ok, msg = await loop.run_in_executor(None, pip_install, packages)
+    return {"ok":ok,"message":msg}
 
+
+# ── Telegram ───────────────────────────────────────────────────
 @app.post("/telegram/webhook")
 async def telegram_webhook(request: Request, background_tasks: BackgroundTasks):
-    """Receive updates from Telegram."""
-    from telegram_bot import handle_telegram_update
+    from telegram_bot import handle_update
     try:
         update = await request.json()
     except Exception:
-        return JSONResponse({"ok": True})
-
-    api_key = os.environ.get("LONGCAT_API_KEY","")
-    model   = os.environ.get("LONGCAT_MODEL","LongCat-Flash-Lite")
-
-    if api_key:
-        background_tasks.add_task(handle_telegram_update, update, api_key, model)
-
-    return JSONResponse({"ok": True})
+        return JSONResponse({"ok":True})
+    print(f"[WEBHOOK] {str(update)[:200]}")
+    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")
+        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})
+    background_tasks.add_task(handle_update, update, api_key, model)
+    return JSONResponse({"ok":True})
 
 
 @app.post("/api/telegram/setup")
 async def telegram_setup(request: Request):
-    """Set up the Telegram webhook."""
     from telegram_bot import set_webhook, get_bot_info
-    try:
-        body = await request.json()
-    except Exception:
-        raise HTTPException(400, "Invalid JSON")
-
-    token    = body.get("token","")
-    base_url = body.get("base_url","")  # e.g. https://your-space.hf.space
-
-    if token:
-        os.environ["TELEGRAM_BOT_TOKEN"] = token
-
-    if not os.environ.get("TELEGRAM_BOT_TOKEN"):
-        raise HTTPException(400, "TELEGRAM_BOT_TOKEN not set")
-
-    bot_info = await get_bot_info()
-    if not bot_info.get("ok"):
-        raise HTTPException(400, f"Invalid bot token: {bot_info}")
-
+    body     = await request.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:
-        result = await set_webhook(base_url)
-        return {"ok":True,"bot":bot_info.get("result",{}),"webhook":result}
-
-    return {"ok":True,"bot":bot_info.get("result",{})}
+        webhook_result = await set_webhook(base_url)
+    return {"ok":True,"bot":bot.get("result",{}),"webhook":webhook_result}
 
 
 @app.get("/api/telegram/status")
 async def telegram_status():
-    """Get Telegram bot status."""
     from telegram_bot import get_webhook_info, get_bot_info
-    token = os.environ.get("TELEGRAM_BOT_TOKEN","")
+    token = cfg.get_telegram_token()
     if not token:
-        return {"connected": False, "message": "No bot token configured"}
+        return {"connected":False,"message":"No bot token"}
     bot  = await get_bot_info()
     hook = await get_webhook_info()
-    return {
-        "connected": bool(token),
-        "bot": bot.get("result",{}),
-        "webhook": hook.get("result",{}),
-    }
+    return {"connected":bot.get("ok",False),"bot":bot.get("result",{}),
+            "webhook":hook.get("result",{}),"longcat_key_set":bool(cfg.get_longcat_key())}
 
 
 @app.delete("/api/telegram/disconnect")
 async def telegram_disconnect():
     from telegram_bot import delete_webhook
     result = await delete_webhook()
-    os.environ.pop("TELEGRAM_BOT_TOKEN","")
-    return {"ok":True,"result":result}
-
-
-@app.post("/api/install-package")
-async def install_package(request: Request):
-    """Manually install a Python package into the agent environment."""
-    body = await request.json()
-    packages = body.get("packages",[])
-    if not packages:
-        raise HTTPException(400,"No packages specified")
-    ok, msg = pip_install(packages)
-    return {"ok":ok,"message":msg}
+    cfg.set("telegram_token","")
+    return {"ok":True,"result":result}