feat: God Agent OS V7 - Gemini+SambaNova+GitHub multi-LLM router, 24 API keys

Dockerfile.hf

@@ -3,7 +3,7 @@ FROM python:3.12-slim
 WORKDIR /app
 
 RUN apt-get update && apt-get install -y \
-    git curl build-essential nodejs npm \
+    git curl build-essential \
     && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt .
@@ -16,7 +16,6 @@ RUN mkdir -p /tmp/god_workspace /tmp/workspace
 ENV PYTHONUNBUFFERED=1
 ENV DB_PATH=/tmp/devin_agent.db
 ENV WORKSPACE_DIR=/tmp/god_workspace
-ENV PYTHONDONTWRITEBYTECODE=1
 
 EXPOSE 7860
 

ai_router/router.py

@@ -1,92 +1,98 @@
 """
-Multi-Model AI Router — Phase 9
-Supports: OpenAI, Groq, Cerebras, OpenRouter, HuggingFace
-Automatic failover chain: OpenAI → Groq → Cerebras → OpenRouter → HF
+God Agent OS V7 — Multi-LLM Router
+Gemini (6 keys) + SambaNova (9 keys) + GitHub Models (9 keys)
+Smart pool rotation, failover, task-based routing
 """
 
 import asyncio
 import json
 import os
 import time
-from typing import Any, Dict, List, Optional
+import random
+from typing import Any, Dict, List, Optional, Tuple
 
 import httpx
 import structlog
 
 log = structlog.get_logger()
 
-# ─── Provider Config ──────────────────────────────────────────────────────────
-PROVIDERS = [
-    {
-        "name": "custom",
-        "key_env": "OPENAI_API_KEY",
-        "base_url": os.environ.get("CUSTOM_GATEWAY_URL", "https://gateway.pyaesone-gtckglay.workers.dev/v1"),
-        "default_model": os.environ.get("DEFAULT_MODEL", "gpt-4o"),
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "openai",
-        "key_env": "OPENAI_API_KEY",
-        "base_url": os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
-        "default_model": os.environ.get("DEFAULT_MODEL", "gpt-4o"),
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "groq",
-        "key_env": "GROQ_API_KEY",
-        "base_url": "https://api.groq.com/openai/v1",
-        "default_model": "llama-3.3-70b-versatile",
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "cerebras",
-        "key_env": "CEREBRAS_API_KEY",
-        "base_url": "https://api.cerebras.ai/v1",
-        "default_model": "llama3.1-70b",
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "openrouter",
-        "key_env": "OPENROUTER_API_KEY",
-        "base_url": "https://openrouter.ai/api/v1",
-        "default_model": "meta-llama/llama-3.3-70b-instruct:free",
-        "headers_fn": lambda k: {
-            "Authorization": f"Bearer {k}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://god-agent.ai",
-            "X-Title": "God Agent Platform",
-        },
-    },
-    {
-        "name": "anthropic",
-        "key_env": "ANTHROPIC_API_KEY",
-        "base_url": "https://api.anthropic.com/v1",
-        "default_model": "claude-3-5-sonnet-20241022",
-        "headers_fn": lambda k: {
-            "x-api-key": k,
-            "anthropic-version": "2023-06-01",
-            "Content-Type": "application/json",
-        },
-    },
-]
+# ─── Provider Definitions ─────────────────────────────────────────────────────
+
+GEMINI_KEYS = [k.strip() for k in os.environ.get("GEMINI_KEYS", "").split(",") if k.strip()]
+SAMBANOVA_KEYS = [k.strip() for k in os.environ.get("SAMBANOVA_KEYS", "").split(",") if k.strip()]
+GITHUB_KEYS = [k.strip() for k in os.environ.get("GITHUB_KEYS", "").split(",") if k.strip()]
+OPENAI_KEY = os.environ.get("OPENAI_API_KEY", "")
+GROQ_KEY = os.environ.get("GROQ_API_KEY", "")
+ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
+
+
+class KeyPool:
+    """Rotating key pool with cooldown on failure."""
+
+    def __init__(self, keys: List[str]):
+        self.keys = [{"key": k, "fail": 0, "cooldown": 0} for k in keys]
+        self._idx = 0
+
+    def pick(self) -> Optional[Dict]:
+        now = time.time()
+        usable = [k for k in self.keys if k["cooldown"] < now]
+        if not usable:
+            return None
+        usable.sort(key=lambda x: x["fail"])
+        return usable[0]
+
+    def mark_fail(self, key_obj: Dict):
+        key_obj["fail"] += 1
+        if key_obj["fail"] >= 2:
+            key_obj["cooldown"] = time.time() + 300  # 5 min cooldown
+
+    def mark_ok(self, key_obj: Dict):
+        key_obj["fail"] = 0
+        key_obj["cooldown"] = 0
+
+    def available(self) -> bool:
+        return any(k["cooldown"] < time.time() for k in self.keys)
 
 
 class AIRouter:
     """
-    God Mode AI Router — automatically routes and fails over across providers.
-    Supports streaming token output via WebSocket.
+    God Agent OS V7 Multi-LLM Router
+    Priority: Gemini → SambaNova → GitHub Models → OpenAI → Groq → Anthropic
     """
 
     def __init__(self, ws_manager=None):
         self.ws = ws_manager
-        self._stats: Dict[str, Dict] = {p["name"]: {"calls": 0, "errors": 0, "latency": []} for p in PROVIDERS}
+        self._gemini_pool = KeyPool(GEMINI_KEYS)
+        self._sambanova_pool = KeyPool(SAMBANOVA_KEYS)
+        self._github_pool = KeyPool(GITHUB_KEYS)
+        self._stats: Dict[str, Dict] = {}
 
-    def _get_provider(self, name: str) -> Optional[Dict]:
-        return next((p for p in PROVIDERS if p["name"] == name), None)
+    # ─── Task Classifier ─────────────────────────────────────────────────────
 
-    def _available_providers(self) -> List[Dict]:
-        """Return providers with valid API keys, in priority order."""
-        return [p for p in PROVIDERS if os.environ.get(p["key_env"], "")]
+    def _classify_task(self, messages: List[Dict]) -> str:
+        content = " ".join(m.get("content", "") for m in messages if m.get("role") == "user").lower()
+        if any(w in content for w in ["code", "build", "api", "python", "javascript", "typescript", "function", "class", "debug", "error", "fix"]):
+            return "coding"
+        if any(w in content for w in ["plan", "workflow", "step", "task", "automate", "json"]):
+            return "planning"
+        if any(w in content for w in ["why", "explain", "analyze", "reason", "logic"]):
+            return "reasoning"
+        if any(w in content for w in ["ဘာ", "ဘယ်", "ဘယ်လို", "ကျေးဇူး", "မြန်မာ"]):
+            return "burmese"
+        return "general"
+
+    def _get_provider_order(self, task_type: str) -> List[str]:
+        """Route by task type — best model for the job."""
+        if task_type == "coding":
+            return ["sambanova", "github", "gemini", "openai", "groq"]
+        elif task_type == "planning":
+            return ["gemini", "github", "sambanova", "openai", "groq"]
+        elif task_type == "reasoning":
+            return ["gemini", "sambanova", "openai", "github", "groq"]
+        elif task_type == "burmese":
+            return ["gemini", "openai", "sambanova", "github", "groq"]
+        else:
+            return ["gemini", "sambanova", "github", "openai", "groq", "anthropic"]
 
     # ─── Main Entry Point ─────────────────────────────────────────────────────
 
@@ -100,46 +106,195 @@ class AIRouter:
         preferred_model: str = "",
         stream: bool = True,
     ) -> str:
-        """Route completion through available providers with failover."""
-        providers = self._available_providers()
-
-        if not providers:
-            return await self._demo_stream(messages, task_id, session_id)
+        task_type = self._classify_task(messages)
+        provider_order = self._get_provider_order(task_type)
+        log.info("AI Router routing", task_type=task_type, providers=provider_order[:3])
 
         last_error = None
-        for provider in providers:
+        for provider_name in provider_order:
             try:
-                start = time.time()
-                if provider["name"] == "anthropic":
-                    result = await self._anthropic_stream(
-                        provider, messages, task_id, session_id, temperature, max_tokens
-                    )
-                else:
-                    result = await self._openai_compat_stream(
-                        provider, messages, task_id, session_id, temperature, max_tokens, preferred_model
-                    )
-                elapsed = time.time() - start
-                self._stats[provider["name"]]["calls"] += 1
-                self._stats[provider["name"]]["latency"].append(elapsed)
-                log.info("AI Router success", provider=provider["name"], ms=round(elapsed * 1000))
-                return result
+                result = await self._call_provider(
+                    provider_name, messages, task_id, session_id, temperature, max_tokens
+                )
+                if result:
+                    log.info("AI Router success", provider=provider_name, chars=len(result))
+                    return result
             except Exception as e:
                 last_error = e
-                self._stats[provider["name"]]["errors"] += 1
-                log.warning("AI Router failover", provider=provider["name"], error=str(e))
+                log.warning("AI Router failover", provider=provider_name, error=str(e)[:100])
                 continue
 
-        log.error("All AI providers failed", last_error=str(last_error))
+        # Last resort: demo stream
+        log.error("All providers failed", error=str(last_error))
         return await self._demo_stream(messages, task_id, session_id)
 
-    # ─── OpenAI-compatible Stream (OpenAI, Groq, Cerebras, OpenRouter) ────────
+    # ─── Provider Dispatchers ─────────────────────────────────────────────────
+
+    async def _call_provider(
+        self, name: str, messages: List[Dict],
+        task_id: str, session_id: str,
+        temperature: float, max_tokens: int
+    ) -> Optional[str]:
+        if name == "gemini":
+            return await self._call_gemini(messages, task_id, session_id, temperature, max_tokens)
+        elif name == "sambanova":
+            return await self._call_sambanova(messages, task_id, session_id, temperature, max_tokens)
+        elif name == "github":
+            return await self._call_github_models(messages, task_id, session_id, temperature, max_tokens)
+        elif name == "openai" and OPENAI_KEY:
+            return await self._call_openai_compat(
+                "openai", OPENAI_KEY, "https://api.openai.com/v1",
+                os.environ.get("DEFAULT_MODEL", "gpt-4o"),
+                messages, task_id, session_id, temperature, max_tokens
+            )
+        elif name == "groq" and GROQ_KEY:
+            return await self._call_openai_compat(
+                "groq", GROQ_KEY, "https://api.groq.com/openai/v1",
+                "llama-3.3-70b-versatile",
+                messages, task_id, session_id, temperature, max_tokens
+            )
+        elif name == "anthropic" and ANTHROPIC_KEY:
+            return await self._call_anthropic(messages, task_id, session_id, temperature, max_tokens)
+        return None
+
+    # ─── Gemini Provider ──────────────────────────────────────────────────────
+
+    async def _call_gemini(
+        self, messages: List[Dict],
+        task_id: str, session_id: str,
+        temperature: float, max_tokens: int
+    ) -> Optional[str]:
+        if not self._gemini_pool.available():
+            return None
+        key_obj = self._gemini_pool.pick()
+        if not key_obj:
+            return None
+
+        # Convert messages to Gemini format
+        system_parts = []
+        user_parts = []
+        contents = []
+
+        for m in messages:
+            role = m.get("role", "user")
+            content = m.get("content", "")
+            if role == "system":
+                system_parts.append(content)
+            elif role == "user":
+                if contents and contents[-1]["role"] == "user":
+                    contents[-1]["parts"].append({"text": content})
+                else:
+                    contents.append({"role": "user", "parts": [{"text": content}]})
+            elif role == "assistant":
+                contents.append({"role": "model", "parts": [{"text": content}]})
+
+        # Prepend system to first user message
+        if system_parts and contents:
+            sys_text = "\n".join(system_parts) + "\n\n"
+            contents[0]["parts"].insert(0, {"text": sys_text})
+        elif system_parts and not contents:
+            contents = [{"role": "user", "parts": [{"text": "\n".join(system_parts)}]}]
 
-    async def _openai_compat_stream(
-        self, provider, messages, task_id, session_id, temperature, max_tokens, preferred_model
-    ) -> str:
-        key = os.environ.get(provider["key_env"], "")
-        model = preferred_model or provider["default_model"]
-        headers = provider["headers_fn"](key)
+        payload = {
+            "contents": contents,
+            "generationConfig": {
+                "temperature": temperature,
+                "maxOutputTokens": max_tokens,
+                "topP": 0.95,
+            },
+        }
+
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key={key_obj['key']}"
+
+        full_text = ""
+        try:
+            async with httpx.AsyncClient(timeout=120) as client:
+                async with client.stream("POST", url, json=payload) as resp:
+                    if resp.status_code != 200:
+                        self._gemini_pool.mark_fail(key_obj)
+                        raise Exception(f"Gemini HTTP {resp.status_code}")
+                    async for line in resp.aiter_lines():
+                        if not line.startswith("data:"):
+                            continue
+                        chunk_str = line[5:].strip()
+                        if not chunk_str or chunk_str == "[DONE]":
+                            continue
+                        try:
+                            data = json.loads(chunk_str)
+                            text = data.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+                            if text:
+                                full_text += text
+                                await self._emit_chunk(text, task_id, session_id)
+                        except Exception:
+                            pass
+            self._gemini_pool.mark_ok(key_obj)
+            return full_text if full_text else None
+        except Exception as e:
+            self._gemini_pool.mark_fail(key_obj)
+            raise e
+
+    # ─── SambaNova Provider ───────────────────────────────────────────────────
+
+    async def _call_sambanova(
+        self, messages: List[Dict],
+        task_id: str, session_id: str,
+        temperature: float, max_tokens: int
+    ) -> Optional[str]:
+        if not self._sambanova_pool.available():
+            return None
+        key_obj = self._sambanova_pool.pick()
+        if not key_obj:
+            return None
+
+        return await self._call_openai_compat(
+            "sambanova", key_obj["key"],
+            "https://api.sambanova.ai/v1",
+            "Meta-Llama-3.3-70B-Instruct",
+            messages, task_id, session_id, temperature, max_tokens,
+            key_pool=self._sambanova_pool, key_obj=key_obj
+        )
+
+    # ─── GitHub Models Provider ───────────────────────────────────────────────
+
+    async def _call_github_models(
+        self, messages: List[Dict],
+        task_id: str, session_id: str,
+        temperature: float, max_tokens: int
+    ) -> Optional[str]:
+        if not self._github_pool.available():
+            return None
+        key_obj = self._github_pool.pick()
+        if not key_obj:
+            return None
+
+        return await self._call_openai_compat(
+            "github", key_obj["key"],
+            "https://models.inference.ai.azure.com",
+            "gpt-4o",
+            messages, task_id, session_id, temperature, max_tokens,
+            key_pool=self._github_pool, key_obj=key_obj
+        )
+
+    # ─── OpenAI-Compatible Stream ─────────────────────────────────────────────
+
+    async def _call_openai_compat(
+        self,
+        provider_name: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        messages: List[Dict],
+        task_id: str,
+        session_id: str,
+        temperature: float,
+        max_tokens: int,
+        key_pool: Optional[KeyPool] = None,
+        key_obj: Optional[Dict] = None,
+    ) -> Optional[str]:
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
         payload = {
             "model": model,
             "messages": messages,
@@ -147,36 +302,47 @@ class AIRouter:
             "temperature": temperature,
             "max_tokens": max_tokens,
         }
+
         full_text = ""
-        async with httpx.AsyncClient(timeout=120) as client:
-            async with client.stream(
-                "POST", f"{provider['base_url']}/chat/completions",
-                headers=headers, json=payload
-            ) as resp:
-                resp.raise_for_status()
-                async for line in resp.aiter_lines():
-                    if not line.startswith("data:"):
-                        continue
-                    chunk = line[6:].strip()
-                    if chunk == "[DONE]":
-                        break
-                    try:
-                        data = json.loads(chunk)
-                        delta = data["choices"][0]["delta"].get("content", "")
-                        if delta:
-                            full_text += delta
-                            await self._emit_chunk(delta, task_id, session_id)
-                    except Exception:
-                        pass
-        return full_text
+        try:
+            async with httpx.AsyncClient(timeout=120) as client:
+                async with client.stream(
+                    "POST", f"{base_url}/chat/completions",
+                    headers=headers, json=payload
+                ) as resp:
+                    if resp.status_code not in (200, 206):
+                        if key_pool and key_obj:
+                            key_pool.mark_fail(key_obj)
+                        raise Exception(f"{provider_name} HTTP {resp.status_code}")
+                    async for line in resp.aiter_lines():
+                        if not line.startswith("data:"):
+                            continue
+                        chunk_str = line[6:].strip()
+                        if chunk_str == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(chunk_str)
+                            delta = data["choices"][0]["delta"].get("content", "")
+                            if delta:
+                                full_text += delta
+                                await self._emit_chunk(delta, task_id, session_id)
+                        except Exception:
+                            pass
+            if key_pool and key_obj:
+                key_pool.mark_ok(key_obj)
+            return full_text if full_text else None
+        except Exception as e:
+            if key_pool and key_obj:
+                key_pool.mark_fail(key_obj)
+            raise e
 
-    # ─── Anthropic Stream ─────────────────────────────────────────────────────
+    # ─── Anthropic ────────────────────────────────────────────────────────────
 
-    async def _anthropic_stream(
-        self, provider, messages, task_id, session_id, temperature, max_tokens
-    ) -> str:
-        key = os.environ.get(provider["key_env"], "")
-        headers = provider["headers_fn"](key)
+    async def _call_anthropic(
+        self, messages: List[Dict],
+        task_id: str, session_id: str,
+        temperature: float, max_tokens: int
+    ) -> Optional[str]:
         system = ""
         filtered = []
         for m in messages:
@@ -184,19 +350,26 @@ class AIRouter:
                 system = m["content"]
             else:
                 filtered.append(m)
+
         payload = {
-            "model": provider["default_model"],
+            "model": "claude-3-5-sonnet-20241022",
             "max_tokens": max_tokens,
             "messages": filtered,
             "stream": True,
         }
         if system:
             payload["system"] = system
+
         full_text = ""
         async with httpx.AsyncClient(timeout=120) as client:
             async with client.stream(
-                "POST", f"{provider['base_url']}/messages",
-                headers=headers, json=payload
+                "POST", "https://api.anthropic.com/v1/messages",
+                headers={
+                    "x-api-key": ANTHROPIC_KEY,
+                    "anthropic-version": "2023-06-01",
+                    "Content-Type": "application/json",
+                },
+                json=payload
             ) as resp:
                 resp.raise_for_status()
                 async for line in resp.aiter_lines():
@@ -211,37 +384,44 @@ class AIRouter:
                                 await self._emit_chunk(delta, task_id, session_id)
                     except Exception:
                         pass
-        return full_text
+        return full_text if full_text else None
 
     # ─── Demo Stream ──────────────────────────────────────────────────────────
 
-    async def _demo_stream(self, messages, task_id, session_id) -> str:
+    async def _demo_stream(self, messages: List[Dict], task_id: str, session_id: str) -> str:
         last_user = next(
-            (m["content"] for m in reversed(messages) if m["role"] == "user"), "Hello"
+            (m["content"] for m in reversed(messages) if m.get("role") == "user"), "Hello"
         )
-        response = (
-            f"🤖 **God Agent** (Demo Mode)\n\n"
-            f"Received: *{last_user[:100]}*\n\n"
-            f"To enable real AI, set one of these env vars:\n"
-            f"- `OPENAI_API_KEY` (GPT-4o)\n"
-            f"- `GROQ_API_KEY` (Llama 3.3 70B — Free)\n"
-            f"- `OPENROUTER_API_KEY` (Multi-model)\n"
-            f"- `ANTHROPIC_API_KEY` (Claude 3.5)\n\n"
-            f"**God Mode+ Capabilities Active:**\n"
-            f"- ⚡ Multi-agent orchestration\n"
-            f"- 🔧 Autonomous coding & debugging\n"
-            f"- 🧠 Persistent memory system\n"
-            f"- 🔌 Connector ecosystem\n"
-            f"- 📡 Real-time streaming\n"
-            f"- 🌐 Multi-model failover\n"
-        )
-        full_text = ""
+        burmese = any("ဘာ" in m.get("content", "") or "မြန်မာ" in m.get("content", "") for m in messages)
+
+        if burmese:
+            response = (
+                f"🤖 **God Agent OS V7** (ပြင်ပ AI Key မသတ်မှတ်ရသေးပါ)\n\n"
+                f"သင်၏ message: *{last_user[:100]}*\n\n"
+                f"**ရရှိနိုင်သော LLM Providers:**\n"
+                f"- Gemini 2.0 Flash ({len(GEMINI_KEYS)} keys)\n"
+                f"- SambaNova Llama 3.3 70B ({len(SAMBANOVA_KEYS)} keys)\n"
+                f"- GitHub Models GPT-4o ({len(GITHUB_KEYS)} keys)\n\n"
+                f"**HF Space secrets set လုပ်ပေးပါ** — GEMINI_KEYS, SAMBANOVA_KEYS, GITHUB_KEYS"
+            )
+        else:
+            response = (
+                f"🤖 **God Agent OS V7** — AI Operating System\n\n"
+                f"Your message: *{last_user[:100]}*\n\n"
+                f"**LLM Providers configured:**\n"
+                f"- 🌟 Gemini 2.0 Flash ({len(GEMINI_KEYS)} keys loaded)\n"
+                f"- ⚡ SambaNova Llama 3.3 70B ({len(SAMBANOVA_KEYS)} keys loaded)\n"
+                f"- 🔮 GitHub Models GPT-4o ({len(GITHUB_KEYS)} keys loaded)\n\n"
+                f"Set HF Space secrets to activate real AI responses."
+            )
+
+        full = ""
         for word in response.split():
             chunk = word + " "
-            full_text += chunk
+            full += chunk
             await asyncio.sleep(0.02)
             await self._emit_chunk(chunk, task_id, session_id, demo=True)
-        return full_text
+        return full
 
     # ─── Emit Helper ──────────────────────────────────────────────────────────
 
@@ -257,15 +437,38 @@ class AIRouter:
     # ─── Stats ────────────────────────────────────────────────────────────────
 
     def get_stats(self) -> Dict:
-        stats = {}
-        for name, s in self._stats.items():
-            avg_lat = round(sum(s["latency"][-20:]) / max(len(s["latency"][-20:]), 1) * 1000, 1)
-            stats[name] = {
-                "calls": s["calls"],
-                "errors": s["errors"],
-                "avg_latency_ms": avg_lat,
-                "available": bool(os.environ.get(
-                    next((p["key_env"] for p in PROVIDERS if p["name"] == name), ""), ""
-                )),
-            }
-        return stats
+        return {
+            "gemini": {
+                "calls": 0,
+                "errors": 0,
+                "avg_latency_ms": 0,
+                "available": self._gemini_pool.available(),
+                "keys": len(GEMINI_KEYS),
+            },
+            "sambanova": {
+                "calls": 0,
+                "errors": 0,
+                "avg_latency_ms": 0,
+                "available": self._sambanova_pool.available(),
+                "keys": len(SAMBANOVA_KEYS),
+            },
+            "github_models": {
+                "calls": 0,
+                "errors": 0,
+                "avg_latency_ms": 0,
+                "available": self._github_pool.available(),
+                "keys": len(GITHUB_KEYS),
+            },
+            "openai": {
+                "available": bool(OPENAI_KEY),
+                "keys": 1 if OPENAI_KEY else 0,
+            },
+            "groq": {
+                "available": bool(GROQ_KEY),
+                "keys": 1 if GROQ_KEY else 0,
+            },
+            "anthropic": {
+                "available": bool(ANTHROPIC_KEY),
+                "keys": 1 if ANTHROPIC_KEY else 0,
+            },
+        }

api/routes/health.py

@@ -1,6 +1,7 @@
 """
-Health + Status Routes — GOD MODE+ V5
+Health + Status Routes — God Agent OS V7
 """
+
 import time
 import os
 import psutil
@@ -8,6 +9,10 @@ from fastapi import APIRouter, Request
 
 router = APIRouter()
 
+GEMINI_KEYS = [k.strip() for k in os.environ.get("GEMINI_KEYS", "").split(",") if k.strip()]
+SAMBANOVA_KEYS = [k.strip() for k in os.environ.get("SAMBANOVA_KEYS", "").split(",") if k.strip()]
+GITHUB_KEYS = [k.strip() for k in os.environ.get("GITHUB_KEYS", "").split(",") if k.strip()]
+
 
 @router.get("/health", summary="Health check")
 async def health(request: Request):
@@ -19,28 +24,39 @@ async def health(request: Request):
 
     stats = ws.get_stats()
     cs = connector_manager.get_summary() if connector_manager else {}
-    provider_details = ai_router.get_provider_status() if ai_router else {}
-    active_providers = [p for p, s in provider_details.items() if s.get("available")]
+    ai_stats = ai_router.get_stats() if ai_router else {}
+
+    # Check if any LLM is available
+    ai_ready = (
+        bool(GEMINI_KEYS) or
+        bool(SAMBANOVA_KEYS) or
+        bool(GITHUB_KEYS) or
+        bool(os.environ.get("OPENAI_API_KEY")) or
+        bool(os.environ.get("GROQ_API_KEY")) or
+        bool(os.environ.get("ANTHROPIC_API_KEY"))
+    )
 
     return {
         "status": "healthy",
-        "name": "GOD MODE+ V5 — Manus · Genspark · Devin",
-        "version": "5.0.0",
+        "name": "God Agent OS V7",
+        "version": "7.0.0",
         "timestamp": time.time(),
         "platform": {
-            "mode": "god_mode_plus_v5",
+            "mode": "god_agent_v7",
             "agents": orchestrator.get_status()["agents"] if orchestrator else [],
             "agent_count": orchestrator.get_status()["total_agents"] if orchestrator else 0,
         },
         "ai_router": {
-            "active_providers": active_providers,
-            "ai_ready": len(active_providers) > 0,
-            "provider_details": provider_details,
+            "providers": {k: v.get("available", False) for k, v in ai_stats.items()},
+            "ai_ready": ai_ready,
+            "gemini_keys": len(GEMINI_KEYS),
+            "sambanova_keys": len(SAMBANOVA_KEYS),
+            "github_keys": len(GITHUB_KEYS),
         },
         "connectors": {
             "connected": cs.get("connected", 0),
             "total": cs.get("total", 0),
-            "ai_ready": cs.get("ai_ready", False),
+            "ai_ready": ai_ready,
         },
         "task_engine": {
             "queue_size": engine._queue.qsize(),
@@ -51,13 +67,14 @@ async def health(request: Request):
             "rooms": list(stats["rooms"].keys()),
         },
         "phases": [
-            "Phase 1-9: God Mode+ V3 ✅",
-            "Phase 10: V5 Multi-Provider AI Router ✅",
-            "Phase 11: Gemini Key Pool (6 keys) ✅",
-            "Phase 12: SambaNova Key Pool (9 keys) ✅",
-            "Phase 13: GitHub Models Key Pool (9 keys) ✅",
-            "Phase 14: Sandbox Crash Fix ✅",
-            "Phase 15: Connector Loop Fix ✅",
+            "V7: Gemini 2.0 Flash multi-key pool ✅",
+            "V7: SambaNova Llama 3.3 70B multi-key pool ✅",
+            "V7: GitHub Models GPT-4o multi-key pool ✅",
+            "V7: Task-based smart routing ✅",
+            "V7: Mission Control UI ✅",
+            "V7: Self-healing execution loop ✅",
+            "V7: Real terminal sandbox ✅",
+            "V7: GitHub autonomy ✅",
         ],
     }
 
@@ -79,5 +96,10 @@ async def metrics():
             "used_gb": round(disk.used / 1024 / 1024 / 1024, 1),
             "percent": disk.percent,
         },
+        "llm_pools": {
+            "gemini_keys": len(GEMINI_KEYS),
+            "sambanova_keys": len(SAMBANOVA_KEYS),
+            "github_keys": len(GITHUB_KEYS),
+        },
         "timestamp": time.time(),
     }

requirements.txt

@@ -3,20 +3,17 @@ uvicorn[standard]==0.29.0
 websockets==12.0
 pydantic==2.7.1
 pydantic-settings==2.2.1
-python-jose[cryptography]==3.3.0
 python-multipart==0.0.9
 aiohttp==3.9.5
 aiosqlite==0.20.0
-sqlalchemy[asyncio]==2.0.30
 httpx==0.27.0
-openai==1.30.1
-anthropic==0.26.1
 gitpython==3.1.43
 pygithub==2.3.0
 python-dotenv==1.0.1
 slowapi==0.1.9
 structlog==24.1.0
 rich==13.7.1
+psutil==5.9.8
+python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
 cryptography==42.0.7
-psutil==5.9.8