Create api.py

api.py

@@ -0,0 +1,119 @@
+# api.py
+from typing import Dict, Optional
+import os
+import asyncio
+import json
+from fastapi import FastAPI, APIRouter
+from pydantic import BaseModel
+
+# --------------------------
+# Config
+# --------------------------
+AGENT_NAMES = {
+    1: "Agent 1 (GLM 4.5)",
+    2: "Agent 2 (GLM 4.5)",
+    3: "Agent 3 (GLM 4.5)",
+    4: "Agent 4 (GLM 4.5)",
+}
+
+ZHIPUAI_API_KEY = os.getenv("ZHIPUAI_API_KEY")  # Optional; if missing, we fallback to echo mode.
+GLM_MODEL = os.getenv("GLM_MODEL", "glm-4-5")   # Placeholder name; adjust if needed.
+
+# --------------------------
+# Schemas
+# --------------------------
+class MessageRequest(BaseModel):
+    message: str
+
+class AgentResponse(BaseModel):
+    agent: str
+    response: str
+
+# --------------------------
+# Core agent call
+# --------------------------
+async def call_glm_45(agent_label: str, message: str) -> str:
+    """
+    Calls GLM 4.5 (or returns a graceful echo if API key isn't set).
+    This function is isolated so both FastAPI and Gradio can reuse it.
+    """
+    if not ZHIPUAI_API_KEY:
+        # Safe fallback when no API key is present.
+        await asyncio.sleep(0)  # yield control
+        return f"[{agent_label}] Echo: {message}"
+
+    # If you have ZHIPUAI_API_KEY set, implement the real API call here.
+    # This is a stub to avoid runtime errors if the SDK/endpoint changes.
+    # Replace this section with the ZhipuAI client code you use in production.
+    try:
+        import httpx
+        # Example placeholder POST; adjust to the actual ZhipuAI API.
+        # If you know the official SDK, swap this for that instead.
+        url = "https://open.bigmodel.cn/api/paas/v4/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {ZHIPUAI_API_KEY}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": GLM_MODEL,
+            "messages": [
+                {"role": "system", "content": f"You are {agent_label}."},
+                {"role": "user", "content": message},
+            ],
+            "temperature": 0.7,
+        }
+        async with httpx.AsyncClient(timeout=60) as client:
+            r = await client.post(url, headers=headers, data=json.dumps(payload))
+            r.raise_for_status()
+            data = r.json()
+            # Adapt this extraction to the API's actual response schema:
+            content = (
+                data.get("choices", [{}])[0]
+                .get("message", {})
+                .get("content", "")
+            ) or json.dumps(data)  # fallback to raw
+            return content.strip()
+    except Exception as e:
+        # Never crash the app — degrade gracefully.
+        return f"[{agent_label}] GLM call failed ({type(e).__name__}): {e}. Fallback: {message}"
+
+async def run_agent(agent_id: int, message: str) -> str:
+    agent_label = AGENT_NAMES.get(agent_id, f"Agent {agent_id} (GLM 4.5)")
+    return await call_glm_45(agent_label, message)
+
+async def run_all_agents(message: str) -> Dict[str, str]:
+    tasks = [run_agent(i, message) for i in sorted(AGENT_NAMES.keys())]
+    results = await asyncio.gather(*tasks)
+    return {f"agent{i}": resp for i, resp in zip(sorted(AGENT_NAMES.keys()), results)}
+
+# --------------------------
+# FastAPI App + Routes
+# --------------------------
+api = FastAPI(title="Multi-Agent Control Panel API", version="1.0.0")
+router = APIRouter(prefix="/api")
+
+@router.post("/agent1", response_model=AgentResponse)
+async def agent1(req: MessageRequest):
+    resp = await run_agent(1, req.message)
+    return AgentResponse(agent=AGENT_NAMES[1], response=resp)
+
+@router.post("/agent2", response_model=AgentResponse)
+async def agent2(req: MessageRequest):
+    resp = await run_agent(2, req.message)
+    return AgentResponse(agent=AGENT_NAMES[2], response=resp)
+
+@router.post("/agent3", response_model=AgentResponse)
+async def agent3(req: MessageRequest):
+    resp = await run_agent(3, req.message)
+    return AgentResponse(agent=AGENT_NAMES[3], response=resp)
+
+@router.post("/agent4", response_model=AgentResponse)
+async def agent4(req: MessageRequest):
+    resp = await run_agent(4, req.message)
+    return AgentResponse(agent=AGENT_NAMES[4], response=resp)
+
+@router.post("/run_all")
+async def run_all(req: MessageRequest):
+    return await run_all_agents(req.message)
+
+api.include_router(router)