🚀 God Agent OS v7 deploy 2026-05-15 10:23:55 UTC

Dockerfile.hf

@@ -1,22 +1,27 @@
-FROM python:3.12-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    git curl build-essential \
-    && rm -rf /var/lib/apt/lists/*
+# System deps
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git curl build-essential && \
+    rm -rf /var/lib/apt/lists/*
 
+# Python deps
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Copy backend source
 COPY . .
 
-RUN mkdir -p /tmp/god_workspace /tmp/workspace
+# Workspace dir
+RUN mkdir -p /tmp/god_workspace
 
-ENV PYTHONUNBUFFERED=1
-ENV DB_PATH=/tmp/devin_agent.db
+# HF Spaces runs on port 7860
+ENV PORT=7860
 ENV WORKSPACE_DIR=/tmp/god_workspace
+ENV PYTHONPATH=/app
 
 EXPOSE 7860
 
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+CMD ["uvicorn", "main_v7:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -7,46 +7,10 @@ sdk: docker
 app_port: 7860
 pinned: true
 license: mit
-short_description: Autonomous Engineering OS v7 — 16 AI Agents
+short_description: Autonomous Engineering OS — Manus + Genspark + Devin
 ---
 
-# 🤖 GOD AGENT OS v7
-**Autonomous Engineering Operating System**
-*Manus + Genspark + Devin (OneHand) — Combined*
+# 🤖 God Agent OS v7
+**Autonomous Engineering Platform — Manus + Genspark + Devin (OneHand)**
 
-[![GitHub](https://img.shields.io/badge/GitHub-god--agent--os-blue?logo=github)](https://github.com/pyaesonegtckglay-dotcom/god-agent-os)
-
-## 🚀 16-Agent Fleet
-
-| Agent | Capability |
-|-------|-----------|
-| 🧠 OrchestratorV7 | Central brain, parallel routing |
-| 📋 Planner | Task graph decomposition |
-| 💻 Coding | Production code generation |
-| 🐛 Debug | Self-healing error resolution |
-| 🌐 **Browser** ⭐ | Web research & scraping |
-| 📁 **File** ⭐ | File system & project scaffold |
-| 🔀 **Git** ⭐ | Git ops & GitHub PR creation |
-| 🧪 **Test** ⭐ | Auto test generation & execution |
-| 🎨 **Vision** ⭐ | Design-to-code UI generation |
-| 🖥️ Sandbox | Isolated code execution |
-| 🚀 Deploy | Auto-deploy to cloud |
-| 🔌 Connector | External integrations |
-| 🧠 Memory | Long-term context |
-| ⚙️ Workflow | n8n automation |
-| 🎯 UI | Real-time UI updates |
-| 🤔 Reasoning | Deep reasoning chains |
-
-## 🔑 Environment Variables (Set in Space Settings)
-
-| Variable | Description |
-|----------|-------------|
-| `OPENAI_API_KEY` | GPT-4o (optional) |
-| `GROQ_API_KEY` | Llama 3.3 70B — **Free & Recommended!** |
-| `OPENROUTER_API_KEY` | 100+ models |
-| `ANTHROPIC_API_KEY` | Claude 3.5 |
-| `GITHUB_TOKEN` | Git operations |
-
-## API
-- `/api/docs` — Interactive API documentation
-- `/` — System status & agent list
+16-agent system for autonomous software engineering.

ai_router/router.py

@@ -1,98 +1,85 @@
 """
-God Agent OS V7 — Multi-LLM Router
-Gemini (6 keys) + SambaNova (9 keys) + GitHub Models (9 keys)
-Smart pool rotation, failover, task-based routing
+Multi-Model AI Router — Phase 9
+Supports: OpenAI, Groq, Cerebras, OpenRouter, HuggingFace
+Automatic failover chain: OpenAI → Groq → Cerebras → OpenRouter → HF
 """
 
 import asyncio
 import json
 import os
 import time
-import random
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 import httpx
 import structlog
 
 log = structlog.get_logger()
 
-# ─── 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)
+# ─── Provider Config ──────────────────────────────────────────────────────────
+PROVIDERS = [
+    {
+        "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",
+        },
+    },
+]
 
 
 class AIRouter:
     """
-    God Agent OS V7 Multi-LLM Router
-    Priority: Gemini → SambaNova → GitHub Models → OpenAI → Groq → Anthropic
+    God Mode AI Router — automatically routes and fails over across providers.
+    Supports streaming token output via WebSocket.
     """
 
     def __init__(self, ws_manager=None):
         self.ws = ws_manager
-        self._gemini_pool = KeyPool(GEMINI_KEYS)
-        self._sambanova_pool = KeyPool(SAMBANOVA_KEYS)
-        self._github_pool = KeyPool(GITHUB_KEYS)
-        self._stats: Dict[str, Dict] = {}
+        self._stats: Dict[str, Dict] = {p["name"]: {"calls": 0, "errors": 0, "latency": []} for p in PROVIDERS}
 
-    # ─── Task Classifier ─────────────────────────────────────────────────────
+    def _get_provider(self, name: str) -> Optional[Dict]:
+        return next((p for p in PROVIDERS if p["name"] == name), None)
 
-    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"]
+    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"], "")]
 
     # ─── Main Entry Point ─────────────────────────────────────────────────────
 
@@ -106,195 +93,46 @@ class AIRouter:
         preferred_model: str = "",
         stream: bool = True,
     ) -> str:
-        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])
+        """Route completion through available providers with failover."""
+        providers = self._available_providers()
+
+        if not providers:
+            return await self._demo_stream(messages, task_id, session_id)
 
         last_error = None
-        for provider_name in provider_order:
+        for provider in providers:
             try:
-                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
+                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
             except Exception as e:
                 last_error = e
-                log.warning("AI Router failover", provider=provider_name, error=str(e)[:100])
+                self._stats[provider["name"]]["errors"] += 1
+                log.warning("AI Router failover", provider=provider["name"], error=str(e))
                 continue
 
-        # Last resort: demo stream
-        log.error("All providers failed", error=str(last_error))
+        log.error("All AI providers failed", last_error=str(last_error))
         return await self._demo_stream(messages, task_id, session_id)
 
-    # ─── 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)}]}]
-
-        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 ───────────────────────────────────────────────
+    # ─── OpenAI-compatible Stream (OpenAI, Groq, Cerebras, OpenRouter) ────────
 
-    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",
-        }
+    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 = {
             "model": model,
             "messages": messages,
@@ -302,47 +140,36 @@ class AIRouter:
             "temperature": temperature,
             "max_tokens": max_tokens,
         }
-
         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
+        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
 
-    # ─── Anthropic ────────────────────────────────────────────────────────────
+    # ─── Anthropic Stream ─────────────────────────────────────────────────────
 
-    async def _call_anthropic(
-        self, messages: List[Dict],
-        task_id: str, session_id: str,
-        temperature: float, max_tokens: int
-    ) -> Optional[str]:
+    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)
         system = ""
         filtered = []
         for m in messages:
@@ -350,26 +177,19 @@ class AIRouter:
                 system = m["content"]
             else:
                 filtered.append(m)
-
         payload = {
-            "model": "claude-3-5-sonnet-20241022",
+            "model": provider["default_model"],
             "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", "https://api.anthropic.com/v1/messages",
-                headers={
-                    "x-api-key": ANTHROPIC_KEY,
-                    "anthropic-version": "2023-06-01",
-                    "Content-Type": "application/json",
-                },
-                json=payload
+                "POST", f"{provider['base_url']}/messages",
+                headers=headers, json=payload
             ) as resp:
                 resp.raise_for_status()
                 async for line in resp.aiter_lines():
@@ -384,44 +204,37 @@ class AIRouter:
                                 await self._emit_chunk(delta, task_id, session_id)
                     except Exception:
                         pass
-        return full_text if full_text else None
+        return full_text
 
     # ─── Demo Stream ──────────────────────────────────────────────────────────
 
-    async def _demo_stream(self, messages: List[Dict], task_id: str, session_id: str) -> str:
+    async def _demo_stream(self, messages, task_id, session_id) -> str:
         last_user = next(
-            (m["content"] for m in reversed(messages) if m.get("role") == "user"), "Hello"
+            (m["content"] for m in reversed(messages) if m["role"] == "user"), "Hello"
         )
-        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 = ""
+        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 = ""
         for word in response.split():
             chunk = word + " "
-            full += chunk
+            full_text += chunk
             await asyncio.sleep(0.02)
             await self._emit_chunk(chunk, task_id, session_id, demo=True)
-        return full
+        return full_text
 
     # ─── Emit Helper ──────────────────────────────────────────────────────────
 
@@ -437,38 +250,15 @@ class AIRouter:
     # ─── Stats ────────────────────────────────────────────────────────────────
 
     def get_stats(self) -> Dict:
-        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,
-            },
-        }
+        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

api/routes/agents.py

@@ -1,11 +1,9 @@
 """
-God Agent Orchestrator API Routes — GOD MODE+ V5
-Added: sandbox execute/write/workspace endpoints with timeout guards
+God Agent Orchestrator API Routes
 """
 from fastapi import APIRouter, Request, HTTPException
 from pydantic import BaseModel
 from typing import Optional, Dict, Any
-import asyncio
 
 router = APIRouter()
 
@@ -21,17 +19,16 @@ class SandboxExecRequest(BaseModel):
     command: str
     cwd: str = ""
     timeout: int = 30
-    session_id: str = "default"
 
 
 class FileWriteRequest(BaseModel):
     filename: str
     content: str
-    session_id: str = "default"
 
 
 @router.post("/orchestrate")
 async def orchestrate(req: OrchestrateRequest, request: Request):
+    """Route message through God Agent Orchestrator."""
     orchestrator = getattr(request.app.state, "orchestrator", None)
     if not orchestrator:
         raise HTTPException(500, "Orchestrator not initialized")
@@ -46,6 +43,7 @@ async def orchestrate(req: OrchestrateRequest, request: Request):
 
 @router.get("/status")
 async def agent_status(request: Request):
+    """Get all agent statuses."""
     orchestrator = getattr(request.app.state, "orchestrator", None)
     if not orchestrator:
         return {"status": "not_initialized"}
@@ -54,26 +52,18 @@ async def agent_status(request: Request):
 
 @router.post("/sandbox/execute")
 async def sandbox_execute(req: SandboxExecRequest, request: Request):
-    """Execute command in sandbox — with timeout guard to prevent app freeze."""
+    """Execute command in sandbox."""
     orchestrator = getattr(request.app.state, "orchestrator", None)
     if not orchestrator:
         raise HTTPException(500, "Orchestrator not initialized")
     sandbox = orchestrator.get_agent("sandbox")
     if not sandbox:
         raise HTTPException(503, "SandboxAgent not available")
-    try:
-        result = await asyncio.wait_for(
-            sandbox.execute(req.command, cwd=req.cwd, timeout=req.timeout, session_id=req.session_id),
-            timeout=float(req.timeout) + 5.0,
-        )
-    except asyncio.TimeoutError:
-        result = f"⏱️ Command timed out after {req.timeout}s"
-    except Exception as e:
-        result = f"❌ Error: {str(e)}"
-    return {"result": result, "command": req.command, "session_id": req.session_id}
-
-
-@router.post("/sandbox/write")
+    result = await sandbox.execute(req.command, cwd=req.cwd, timeout=req.timeout)
+    return {"result": result, "command": req.command}
+
+
+@router.post("/sandbox/file")
 async def sandbox_write_file(req: FileWriteRequest, request: Request):
     """Write file to sandbox workspace."""
     orchestrator = getattr(request.app.state, "orchestrator", None)
@@ -82,32 +72,27 @@ async def sandbox_write_file(req: FileWriteRequest, request: Request):
     sandbox = orchestrator.get_agent("sandbox")
     if not sandbox:
         raise HTTPException(503, "SandboxAgent not available")
-    result = await sandbox.write_file(req.filename, req.content, session_id=req.session_id)
-    return {"result": result, "filename": req.filename, "session_id": req.session_id}
-
-
-@router.post("/sandbox/file")
-async def sandbox_write_file_compat(req: FileWriteRequest, request: Request):
-    """Backwards compat alias for /sandbox/write."""
-    return await sandbox_write_file(req, request)
+    result = await sandbox.write_file(req.filename, req.content)
+    return {"result": result, "filename": req.filename}
 
 
 @router.get("/sandbox/workspace")
-async def sandbox_workspace(request: Request, session_id: str = "default"):
-    """Get workspace file listing for a session."""
+async def sandbox_workspace(request: Request):
+    """Get workspace info."""
     orchestrator = getattr(request.app.state, "orchestrator", None)
     if not orchestrator:
         raise HTTPException(500, "Orchestrator not initialized")
     sandbox = orchestrator.get_agent("sandbox")
     if not sandbox:
         raise HTTPException(503, "SandboxAgent not available")
-    info = await sandbox.get_workspace_info(session_id=session_id)
+    info = await sandbox.get_workspace_info()
     return info
 
 
 @router.get("/ai-router/stats")
 async def ai_router_stats(request: Request):
+    """Get AI router statistics."""
     ai_router = getattr(request.app.state, "ai_router", None)
     if not ai_router:
         return {"stats": {}}
-    return {"stats": ai_router.get_provider_status()}
+    return {"stats": ai_router.get_stats()}

api/routes/chat.py

@@ -1,16 +1,12 @@
 """
-Chat API Routes — GOD MODE+ V5
-Real SSE streaming with Gemini/SambaNova/GitHub Models/OpenAI/Groq
-No demo mode when keys exist. Fixed provider routing.
+Chat + Goal API Routes — Real-time streaming responses
 """
 
 import asyncio
 import json
-import os
 import time
 import uuid
 
-import httpx
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 
@@ -20,10 +16,6 @@ from memory.db import save_memory, get_history
 router = APIRouter()
 
 
-def get_ai_router(request: Request):
-    return getattr(request.app.state, "ai_router", None)
-
-
 def get_engine(request: Request):
     return request.app.state.task_engine
 
@@ -32,235 +24,133 @@ def get_ws(request: Request):
     return request.app.state.ws_manager
 
 
-# ─── SSE stream generators ─────────────────────────────────────────────────────
-
-async def _gemini_stream_sse(messages, key, model="gemini-2.0-flash"):
-    contents = []
-    system_txt = ""
-    for m in messages:
-        if m["role"] == "system":
-            system_txt = m["content"]
-        elif m["role"] == "user":
-            contents.append({"role": "user", "parts": [{"text": m["content"]}]})
-        elif m["role"] == "assistant":
-            contents.append({"role": "model", "parts": [{"text": m["content"]}]})
-
-    if not contents:
-        contents = [{"role": "user", "parts": [{"text": "Hello"}]}]
-
-    payload = {"contents": contents, "generationConfig": {"maxOutputTokens": 2048, "temperature": 0.7}}
-    if system_txt:
-        payload["systemInstruction"] = {"parts": [{"text": system_txt}]}
-
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:streamGenerateContent?alt=sse&key={key}"
-    full = ""
-    try:
-        async with httpx.AsyncClient(timeout=90) as client:
-            async with client.stream("POST", url, json=payload) as resp:
-                if resp.status_code != 200:
-                    error_body = await resp.aread()
-                    raise Exception(f"Gemini {resp.status_code}: {error_body[:200]}")
-                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)
-                        delta = (
-                            data.get("candidates", [{}])[0]
-                            .get("content", {})
-                            .get("parts", [{}])[0]
-                            .get("text", "")
-                        )
-                        if delta:
-                            full += delta
-                            yield delta, full, None
-                    except Exception:
-                        pass
-    except Exception as e:
-        yield None, full, str(e)
-
-
-async def _openai_compat_stream_sse(messages, api_key, base_url, model):
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-    payload = {"model": model, "messages": messages, "stream": True, "max_tokens": 2048, "temperature": 0.7}
-    url = f"{base_url.rstrip('/')}/chat/completions"
-    full = ""
-    try:
-        async with httpx.AsyncClient(timeout=90) as client:
-            async with client.stream("POST", url, headers=headers, json=payload) as resp:
-                if resp.status_code != 200:
-                    error_body = await resp.aread()
-                    raise Exception(f"{base_url} {resp.status_code}: {error_body[:200]}")
-                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 += delta
-                            yield delta, full, None
-                    except Exception:
-                        pass
-    except Exception as e:
-        yield None, full, str(e)
+# ─── Chat (REST + SSE streaming) ───────────────────────────────────────────────
 
+@router.post("/chat", summary="Chat with the agent")
+async def chat(req: ChatRequest, request: Request):
+    from core.agent import AgentCore
+    ws = get_ws(request)
+    agent = AgentCore(ws)
 
-async def _sse_generator(req: ChatRequest, ai_router):
-    """Main SSE generator — tries all providers, no demo if keys exist."""
     messages = [{"role": m.role, "content": m.content} for m in req.messages]
-    session_id = req.session_id
-    full_response = ""
-    provider_tried = False
-
-    providers = ai_router._available_providers() if ai_router else []
-
-    for name in providers:
-        pool = ai_router.pools.get(name)
-        if not pool:
-            continue
-        key = pool.pick()
-        if not key:
-            continue
-
-        cfg = ai_router.provider_configs.get(name, {})
-        provider_tried = True
-        success = False
 
-        try:
-            if name == "gemini":
-                async for delta, full, err in _gemini_stream_sse(messages, key, cfg.get("model", "gemini-2.0-flash")):
-                    if err:
-                        pool.mark_fail(key)
-                        break
-                    if delta:
-                        full_response = full
-                        yield f"data: {json.dumps({'type':'llm_chunk','data':{'chunk':delta},'session_id':session_id})}\n\n"
-                if full_response:
-                    pool.mark_success(key)
-                    success = True
-
-            elif name in ("sambanova", "github_models", "openai", "groq", "cerebras", "openrouter"):
-                base_url = cfg.get("base_url", "https://api.openai.com/v1")
-                model = cfg.get("model", "gpt-4o")
-                async for delta, full, err in _openai_compat_stream_sse(messages, key, base_url, model):
-                    if err:
-                        pool.mark_fail(key)
-                        break
-                    if delta:
-                        full_response = full
-                        yield f"data: {json.dumps({'type':'llm_chunk','data':{'chunk':delta},'session_id':session_id})}\n\n"
-                if full_response:
-                    pool.mark_success(key)
-                    success = True
-
-            elif name == "anthropic":
+    if req.stream:
+        async def stream_gen():
+            async def _run():
+                result = await agent.llm_stream(
+                    messages=messages,
+                    session_id=req.session_id,
+                    model=req.model,
+                    temperature=req.temperature,
+                    max_tokens=req.max_tokens,
+                )
+                await save_memory(
+                    content=result,
+                    memory_type="conversation",
+                    session_id=req.session_id,
+                    project_id=req.project_id,
+                    key="assistant",
+                )
+                # Save user message too
+                user_msg = next((m["content"] for m in reversed(messages) if m["role"] == "user"), "")
+                await save_memory(
+                    content=user_msg,
+                    memory_type="conversation",
+                    session_id=req.session_id,
+                    project_id=req.project_id,
+                    key="user",
+                )
+                return result
+
+            room_buffer = []
+            original_emit_chat = ws.emit_chat
+            async def capture_emit(sid, etype, data):
+                if etype == "llm_chunk":
+                    chunk = data.get("chunk", "")
+                    room_buffer.append(chunk)
+                    yield_data = json.dumps({"type": etype, "data": data, "session_id": sid})
+                    return yield_data
+                return None
+
+            # Stream tokens directly
+            full = ""
+            from core.agent import AgentCore as _A
+            import httpx
+            import os
+            OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+            ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
+
+            if OPENAI_API_KEY:
                 headers = {
-                    "x-api-key": key,
-                    "anthropic-version": "2023-06-01",
-                    "content-type": "application/json",
+                    "Authorization": f"Bearer {OPENAI_API_KEY}",
+                    "Content-Type": "application/json",
                 }
-                anthropic_msgs = [m for m in messages if m["role"] != "system"]
-                system_txt = next((m["content"] for m in messages if m["role"] == "system"), "")
                 payload = {
-                    "model": cfg.get("model", "claude-3-5-haiku-20241022"),
-                    "max_tokens": 2048,
+                    "model": req.model,
+                    "messages": messages,
                     "stream": True,
-                    "messages": anthropic_msgs,
-                    "temperature": 0.7,
+                    "temperature": req.temperature,
+                    "max_tokens": req.max_tokens,
                 }
-                if system_txt:
-                    payload["system"] = system_txt
-                try:
-                    async with httpx.AsyncClient(timeout=90) as client:
-                        async with client.stream(
-                            "POST", "https://api.anthropic.com/v1/messages",
-                            headers=headers, json=payload
-                        ) as resp:
-                            async for line in resp.aiter_lines():
-                                if not line.startswith("data:"):
-                                    continue
-                                chunk_str = line[6:].strip()
-                                try:
-                                    data = json.loads(chunk_str)
-                                    if data.get("type") == "content_block_delta":
-                                        delta = data.get("delta", {}).get("text", "")
-                                        if delta:
-                                            full_response += delta
-                                            yield f"data: {json.dumps({'type':'llm_chunk','data':{'chunk':delta},'session_id':session_id})}\n\n"
-                                except Exception:
-                                    pass
-                    if full_response:
-                        pool.mark_success(key)
-                        success = True
-                except Exception as e:
-                    pool.mark_fail(key)
-
-        except Exception as e:
-            pool.mark_fail(key)
-            continue
+                from core.agent import OPENAI_BASE_URL
+                async with httpx.AsyncClient(timeout=120) as client:
+                    async with client.stream("POST", f"{OPENAI_BASE_URL}/chat/completions",
+                                             headers=headers, json=payload) as resp:
+                        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 += delta
+                                    yield f"data: {json.dumps({'type': 'llm_chunk', 'data': {'chunk': delta}, 'session_id': req.session_id})}\n\n"
+                            except Exception:
+                                pass
+            else:
+                # Demo streaming
+                demo = (
+                    f"Hello! I'm your Devin-style AI Agent. I received: '{req.messages[-1].content[:80]}'. "
+                    f"Set OPENAI_API_KEY or ANTHROPIC_API_KEY for real AI responses. "
+                    f"I support real-time streaming, task planning, GitHub automation, and more!"
+                )
+                for word in demo.split():
+                    chunk = word + " "
+                    full += chunk
+                    await asyncio.sleep(0.04)
+                    yield f"data: {json.dumps({'type': 'llm_chunk', 'data': {'chunk': chunk}, 'session_id': req.session_id})}\n\n"
+
+            yield f"data: {json.dumps({'type': 'stream_end', 'data': {'full_response': full}, 'session_id': req.session_id})}\n\n"
 
-        if success:
-            break
-
-    # Only show error if truly no response
-    if not full_response:
-        if provider_tried:
-            error_msg = "⚠️ All AI providers returned errors. Please check API keys in Connectors panel or try again."
-        else:
-            error_msg = (
-                "⚠️ No AI providers configured.\n\n"
-                "Add API keys via **Connectors** panel:\n"
-                "- Gemini (GEMINI_API_KEYS)\n"
-                "- SambaNova (SAMBANOVA_API_KEYS)\n"
-                "- GitHub Models (GITHUB_API_KEYS)"
-            )
-        for word in error_msg.split():
-            chunk = word + " "
-            full_response += chunk
-            yield f"data: {json.dumps({'type':'llm_chunk','data':{'chunk':chunk},'session_id':session_id})}\n\n"
-            await asyncio.sleep(0.01)
-
-    yield f"data: {json.dumps({'type':'stream_end','data':{'full_response':full_response},'session_id':session_id})}\n\n"
-
-
-# ─── Routes ────────────────────────────────────────────────────────────────────
-
-@router.post("/chat", summary="Chat with God Agent — V5 streaming")
-async def chat(req: ChatRequest, request: Request):
-    ai_router = get_ai_router(request)
-    if req.stream:
         return StreamingResponse(
-            _sse_generator(req, ai_router),
+            stream_gen(),
             media_type="text/event-stream",
             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
         )
     else:
-        full = ""
-        async for chunk in _sse_generator(req, ai_router):
-            if chunk.startswith("data:"):
-                try:
-                    d = json.loads(chunk[6:].strip())
-                    if d.get("type") == "llm_chunk":
-                        full += d["data"].get("chunk", "")
-                except Exception:
-                    pass
-        return {"response": full, "session_id": req.session_id, "timestamp": time.time()}
-
-
-@router.post("/chat/stream", summary="Explicit streaming chat")
+        # Non-streaming
+        agent = AgentCore(get_ws(request))
+        result = await agent.llm_stream(messages, session_id=req.session_id)
+        return {
+            "response": result,
+            "session_id": req.session_id,
+            "model": req.model,
+            "timestamp": time.time(),
+        }
+
+
+@router.post("/chat/stream", summary="Explicit streaming chat endpoint")
 async def chat_stream(req: ChatRequest, request: Request):
     req.stream = True
     return await chat(req, request)
 
 
-@router.post("/goal", summary="Submit high-level goal to task engine")
+# ─── Goal API (create task from goal) ─────────────────────────────────────────
+
+@router.post("/goal", summary="Submit a high-level goal to the agent")
 async def submit_goal(req: GoalRequest, request: Request):
     engine = get_engine(request)
     task_req = TaskCreateRequest(
@@ -268,7 +158,7 @@ async def submit_goal(req: GoalRequest, request: Request):
         session_id=req.session_id,
         project_id=req.project_id,
         stream=req.stream,
-        metadata={"source": "goal_api", "github_repo": req.github_repo or ""},
+        metadata={"source": "goal_api", "github_repo": req.github_repo},
     )
     task_id = await engine.submit(task_req)
     return {
@@ -277,29 +167,48 @@ async def submit_goal(req: GoalRequest, request: Request):
         "status": "queued",
         "session_id": req.session_id,
         "ws_url": f"/ws/tasks/{task_id}",
+        "stream_url": f"/api/v1/tasks/{task_id}/stream",
     }
 
 
-@router.post("/goal/stream")
+@router.post("/goal/stream", summary="Submit goal with SSE streaming response")
 async def submit_goal_stream(req: GoalRequest, request: Request):
     req.stream = True
     return await submit_goal(req, request)
 
 
-@router.post("/execute")
-async def execute(tool: str, task: str, request: Request, session_id: str = ""):
+# ─── Execute (direct tool execution) ──────────────────────────────────────────
+
+@router.post("/execute", summary="Execute a tool directly")
+async def execute(
+    tool: str,
+    task: str,
+    request: Request,
+    session_id: str = "",
+):
     from tools.executor import ToolExecutor
     ws = get_ws(request)
     executor = ToolExecutor(ws)
-    result = await executor.run(tool=tool, task=task, session_id=session_id)
-    return {"tool": tool, "task": task, "result": result}
+    result = await executor.run(
+        tool=tool,
+        task=task,
+        session_id=session_id,
+    )
+    return {"tool": tool, "task": task, "result": result, "session_id": session_id}
 
 
-@router.post("/plan")
+# ─── Plan (generate plan without executing) ───────────────────────────────────
+
+@router.post("/plan", summary="Generate execution plan for a goal")
 async def generate_plan(req: GoalRequest, request: Request):
     from core.agent import AgentCore
     ws = get_ws(request)
     agent = AgentCore(ws)
     task_id = f"plan_{uuid.uuid4().hex[:8]}"
     plan = await agent.plan(goal=req.goal, task_id=task_id, session_id=req.session_id)
-    return {"goal": req.goal, "plan": plan.model_dump(), "task_id": task_id}
+    return {
+        "goal": req.goal,
+        "plan": plan.model_dump(),
+        "session_id": req.session_id,
+        "task_id": task_id,
+    }

api/routes/connectors.py

@@ -1,21 +1,13 @@
 """
-Connectors API — GOD MODE+ V5
-Fix: No auto-reconnect loop. Runtime tokens tracked separately from HF Secrets.
+Connectors API — Manus-style connector management
 """
-import os
-import httpx
 from fastapi import APIRouter, Request, HTTPException
 from pydantic import BaseModel
 from typing import Optional
 from connectors.manager import ConnectorManager
 
 router = APIRouter()
-
-# Track tokens set at runtime (not from HF Secrets) so we can safely remove them
-_runtime_tokens: dict = {}
-
-# Use a single shared manager instance
-_manager = ConnectorManager()
+connector_manager = ConnectorManager()
 
 
 class SetTokenRequest(BaseModel):
@@ -23,145 +15,35 @@ class SetTokenRequest(BaseModel):
     token: str
 
 
-class DisconnectRequest(BaseModel):
-    connector_id: str
-
-
 @router.get("/")
 async def get_all_connectors():
-    return {"connectors": _manager.get_all()}
+    return {"connectors": connector_manager.get_all()}
 
 
 @router.get("/connected")
 async def get_connected():
-    return {"connectors": _manager.get_connected()}
+    return {"connectors": connector_manager.get_connected()}
 
 
 @router.get("/summary")
 async def get_summary():
-    return _manager.get_summary()
+    return connector_manager.get_summary()
 
 
 @router.get("/category/{category}")
 async def get_by_category(category: str):
-    return {"connectors": _manager.get_by_category(category)}
-
-
-@router.post("/connect")
-async def connect_connector(req: SetTokenRequest):
-    """Connect a connector by setting its token at runtime."""
-    env_key = _manager.get_env_key(req.connector_id)
-    if not env_key:
-        raise HTTPException(400, f"Unknown connector: {req.connector_id}")
-
-    # Set in environment and track as runtime token
-    os.environ[env_key] = req.token
-    _runtime_tokens[env_key] = req.token
-    _manager.set_token(req.connector_id, req.token)
-
-    return {
-        "status": "connected",
-        "connector_id": req.connector_id,
-        "connected": True,
-    }
+    return {"connectors": connector_manager.get_by_category(category)}
 
 
 @router.post("/set-token")
 async def set_token(req: SetTokenRequest):
-    """Alias for /connect for backwards compatibility."""
-    return await connect_connector(req)
-
-
-@router.post("/disconnect")
-async def disconnect_connector(req: DisconnectRequest):
-    """Disconnect a connector — only removes runtime tokens, not HF Secrets."""
-    env_key = _manager.get_env_key(req.connector_id)
-    if not env_key:
-        raise HTTPException(400, f"Unknown connector: {req.connector_id}")
-
-    # Only remove if we set it at runtime (don't wipe HF Secrets)
-    if env_key in _runtime_tokens:
-        os.environ.pop(env_key, None)
-        del _runtime_tokens[env_key]
-        _manager.clear_token(req.connector_id)
-        return {"status": "disconnected", "connector_id": req.connector_id}
-    else:
-        # It's a HF Secret — just report it as persistent
-        return {
-            "status": "persistent",
-            "connector_id": req.connector_id,
-            "message": "Token is a HuggingFace Secret and cannot be removed at runtime.",
-        }
-
-
-@router.post("/test")
-async def test_connector(req: DisconnectRequest):
-    """Test a connector's API connectivity."""
-    connector_id = req.connector_id
-    env_key = _manager.get_env_key(connector_id)
-    token = os.environ.get(env_key, "") if env_key else ""
-
-    if not token:
-        return {"connector_id": connector_id, "status": "not_configured", "ok": False}
-
-    try:
-        if connector_id == "github":
-            async with httpx.AsyncClient(timeout=10) as client:
-                r = await client.get(
-                    "https://api.github.com/user",
-                    headers={"Authorization": f"Bearer {token}"},
-                )
-                ok = r.status_code == 200
-                data = r.json() if ok else {}
-                return {"connector_id": connector_id, "ok": ok, "user": data.get("login", "")}
-
-        elif connector_id == "huggingface":
-            async with httpx.AsyncClient(timeout=10) as client:
-                r = await client.get(
-                    "https://huggingface.co/api/whoami-v2",
-                    headers={"Authorization": f"Bearer {token}"},
-                )
-                ok = r.status_code == 200
-                data = r.json() if ok else {}
-                return {"connector_id": connector_id, "ok": ok, "user": data.get("name", "")}
-
-        elif connector_id == "vercel":
-            async with httpx.AsyncClient(timeout=10) as client:
-                r = await client.get(
-                    "https://api.vercel.com/v2/user",
-                    headers={"Authorization": f"Bearer {token}"},
-                )
-                ok = r.status_code == 200
-                data = r.json() if ok else {}
-                return {"connector_id": connector_id, "ok": ok, "user": data.get("user", {}).get("username", "")}
-
-        elif connector_id == "gemini":
-            # Test with a tiny generateContent call
-            url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={token}"
-            async with httpx.AsyncClient(timeout=15) as client:
-                r = await client.post(url, json={"contents": [{"parts": [{"text": "hi"}]}]})
-                ok = r.status_code == 200
-                return {"connector_id": connector_id, "ok": ok}
-
-        elif connector_id == "sambanova":
-            async with httpx.AsyncClient(timeout=15) as client:
-                r = await client.get(
-                    "https://api.sambanova.ai/v1/models",
-                    headers={"Authorization": f"Bearer {token}"},
-                )
-                ok = r.status_code == 200
-                return {"connector_id": connector_id, "ok": ok}
-
-        else:
-            return {"connector_id": connector_id, "ok": True, "status": "assumed_ok"}
-
-    except Exception as e:
-        return {"connector_id": connector_id, "ok": False, "error": str(e)}
+    connector_manager.set_token(req.connector_id, req.token)
+    return {"status": "ok", "connector": req.connector_id, "connected": True}
 
 
 @router.get("/{connector_id}/status")
 async def get_status(connector_id: str):
     return {
         "connector_id": connector_id,
-        "connected": _manager.is_connected(connector_id),
+        "connected": connector_manager.is_connected(connector_id),
     }

api/routes/github.py

@@ -1,9 +1,336 @@
 """
-GitHub API Routes (legacy compat + new)
+GitHub Autonomous Engineering API Routes
+Clone, commit, push, PR, issues — all autonomous
 """
-from fastapi import APIRouter
+
+import os
+import time
+import asyncio
+import tempfile
+import shutil
+from typing import Optional
+
+import httpx
+from fastapi import APIRouter, HTTPException, Request
+
+from core.models import (
+    GitHubCloneRequest, GitHubCreateRepoRequest,
+    GitHubCommitRequest, GitHubPRRequest, GitHubIssueRequest,
+)
+from memory.db import save_memory
+
 router = APIRouter()
 
-@router.get("/info")
-async def github_info():
-    return {"status": "GitHub routes active — use /api/v1/exec/github/* for full ops"}
+GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN", "")
+GITHUB_OWNER = os.environ.get("GITHUB_OWNER", "")
+GITHUB_API = "https://api.github.com"
+
+
+def gh_headers():
+    if not GITHUB_TOKEN:
+        raise HTTPException(status_code=400, detail="GITHUB_TOKEN not configured")
+    return {
+        "Authorization": f"Bearer {GITHUB_TOKEN}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+
+
+async def gh_get(path: str) -> dict:
+    async with httpx.AsyncClient(timeout=30) as client:
+        r = await client.get(f"{GITHUB_API}{path}", headers=gh_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+async def gh_post(path: str, data: dict) -> dict:
+    async with httpx.AsyncClient(timeout=30) as client:
+        r = await client.post(f"{GITHUB_API}{path}", headers=gh_headers(), json=data)
+        r.raise_for_status()
+        return r.json()
+
+
+async def gh_put(path: str, data: dict) -> dict:
+    async with httpx.AsyncClient(timeout=30) as client:
+        r = await client.put(f"{GITHUB_API}{path}", headers=gh_headers(), json=data)
+        r.raise_for_status()
+        return r.json()
+
+
+async def gh_patch(path: str, data: dict) -> dict:
+    async with httpx.AsyncClient(timeout=30) as client:
+        r = await client.patch(f"{GITHUB_API}{path}", headers=gh_headers(), json=data)
+        r.raise_for_status()
+        return r.json()
+
+
+# ─── Clone ────────────────────────────────────────────────────────────────────
+
+@router.post("/clone", summary="Clone a GitHub repository")
+async def clone_repo(req: GitHubCloneRequest):
+    try:
+        import git
+    except ImportError:
+        raise HTTPException(status_code=500, detail="gitpython not installed")
+
+    local_path = req.local_path or f"/tmp/repos/{req.repo_url.split('/')[-1].replace('.git', '')}"
+    os.makedirs(local_path, exist_ok=True)
+
+    if GITHUB_TOKEN:
+        url = req.repo_url.replace("https://", f"https://{GITHUB_TOKEN}@")
+    else:
+        url = req.repo_url
+
+    try:
+        if os.path.exists(os.path.join(local_path, ".git")):
+            repo = git.Repo(local_path)
+            repo.remotes.origin.pull()
+            action = "pulled"
+        else:
+            repo = git.Repo.clone_from(url, local_path, branch=req.branch, depth=1)
+            action = "cloned"
+
+        files = []
+        for root, dirs, fnames in os.walk(local_path):
+            dirs[:] = [d for d in dirs if d not in [".git", "node_modules", "__pycache__"]]
+            for f in fnames[:50]:
+                files.append(os.path.relpath(os.path.join(root, f), local_path))
+
+        # Save to memory
+        await save_memory(
+            content=f"Repo {req.repo_url} cloned to {local_path}. Files: {', '.join(files[:20])}",
+            memory_type="repo",
+            key=req.repo_url,
+        )
+
+        return {
+            "action": action,
+            "repo_url": req.repo_url,
+            "local_path": local_path,
+            "branch": req.branch,
+            "files_count": len(files),
+            "files": files[:30],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Clone failed: {str(e)}")
+
+
+# ─── Create Repo ──────────────────────────────────────────────────────────────
+
+@router.post("/create_repo", summary="Create a new GitHub repository")
+async def create_repo(req: GitHubCreateRepoRequest):
+    data = {
+        "name": req.name,
+        "description": req.description,
+        "private": req.private,
+        "auto_init": req.auto_init,
+    }
+    try:
+        result = await gh_post("/user/repos", data)
+        return {
+            "repo": result["full_name"],
+            "url": result["html_url"],
+            "clone_url": result["clone_url"],
+            "default_branch": result.get("default_branch", "main"),
+            "private": result["private"],
+        }
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
+
+
+# ─── Commit Files ────────��────────────────────────────────────────────────────
+
+@router.post("/commit", summary="Commit files to a repository")
+async def commit_files(req: GitHubCommitRequest):
+    import base64
+
+    owner_repo = req.repo if "/" in req.repo else f"{GITHUB_OWNER}/{req.repo}"
+    results = []
+
+    for file_path, content in req.files.items():
+        encoded = base64.b64encode(content.encode()).decode()
+
+        # Get current SHA if file exists
+        sha = None
+        try:
+            existing = await gh_get(f"/repos/{owner_repo}/contents/{file_path}?ref={req.branch}")
+            sha = existing.get("sha")
+        except Exception:
+            pass
+
+        payload = {
+            "message": req.message,
+            "content": encoded,
+            "branch": req.branch,
+        }
+        if sha:
+            payload["sha"] = sha
+
+        try:
+            result = await gh_put(f"/repos/{owner_repo}/contents/{file_path}", payload)
+            results.append({"file": file_path, "status": "committed", "sha": result["content"]["sha"]})
+        except Exception as e:
+            results.append({"file": file_path, "status": "error", "error": str(e)})
+
+    return {
+        "repo": owner_repo,
+        "branch": req.branch,
+        "message": req.message,
+        "files": results,
+        "committed": sum(1 for r in results if r["status"] == "committed"),
+    }
+
+
+# ─── Push ─────────────────────────────────────────────────────────────────────
+
+@router.post("/push", summary="Push local changes to remote")
+async def push_changes(
+    repo_path: str,
+    branch: str = "main",
+    message: str = "Auto-commit by Devin Agent",
+):
+    try:
+        import git
+        repo = git.Repo(repo_path)
+        repo.git.add(A=True)
+        if repo.index.diff("HEAD") or repo.untracked_files:
+            repo.index.commit(message)
+        origin = repo.remote("origin")
+        origin.push(refspec=f"HEAD:{branch}")
+        return {"status": "pushed", "branch": branch, "message": message}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Push failed: {str(e)}")
+
+
+# ─── Create PR ────────────────────────────────────────────────────────────────
+
+@router.post("/pr/create", summary="Create a Pull Request")
+async def create_pr(req: GitHubPRRequest):
+    owner_repo = req.repo if "/" in req.repo else f"{GITHUB_OWNER}/{req.repo}"
+    data = {
+        "title": req.title,
+        "body": req.body,
+        "head": req.head,
+        "base": req.base,
+        "draft": req.draft,
+    }
+    try:
+        result = await gh_post(f"/repos/{owner_repo}/pulls", data)
+        return {
+            "pr_number": result["number"],
+            "title": result["title"],
+            "url": result["html_url"],
+            "state": result["state"],
+            "head": req.head,
+            "base": req.base,
+        }
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
+
+
+# ─── Create Issue ─────────────────────────────────────────────────────────────
+
+@router.post("/issues/create", summary="Create a GitHub Issue")
+async def create_issue(req: GitHubIssueRequest):
+    owner_repo = req.repo if "/" in req.repo else f"{GITHUB_OWNER}/{req.repo}"
+    data = {"title": req.title, "body": req.body, "labels": req.labels}
+    try:
+        result = await gh_post(f"/repos/{owner_repo}/issues", data)
+        return {
+            "issue_number": result["number"],
+            "title": result["title"],
+            "url": result["html_url"],
+            "state": result["state"],
+        }
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
+
+
+# ─── Code Review ──────────────────────────────────────────────────────────────
+
+@router.post("/review", summary="AI code review for a PR")
+async def review_pr(repo: str, pr_number: int, request: Request):
+    owner_repo = repo if "/" in repo else f"{GITHUB_OWNER}/{repo}"
+    try:
+        pr = await gh_get(f"/repos/{owner_repo}/pulls/{pr_number}")
+        files = await gh_get(f"/repos/{owner_repo}/pulls/{pr_number}/files")
+
+        file_changes = []
+        for f in files[:10]:
+            file_changes.append(f"{f['filename']}: +{f.get('additions',0)}/-{f.get('deletions',0)}")
+
+        ws = request.app.state.ws_manager
+        from core.agent import AgentCore
+        agent = AgentCore(ws)
+
+        review_prompt = (
+            f"Review this Pull Request:\n"
+            f"Title: {pr['title']}\n"
+            f"Description: {pr.get('body', 'No description')}\n"
+            f"Files changed: {chr(10).join(file_changes)}\n\n"
+            f"Provide a constructive code review with: summary, potential issues, suggestions, and verdict."
+        )
+        messages = [
+            {"role": "system", "content": "You are a senior software engineer doing code review. Be constructive, specific, and helpful."},
+            {"role": "user", "content": review_prompt},
+        ]
+        review = await agent.llm_stream(messages)
+
+        # Post review comment
+        if GITHUB_TOKEN:
+            await gh_post(f"/repos/{owner_repo}/issues/{pr_number}/comments", {"body": f"🤖 **Devin Agent Code Review**\n\n{review}"})
+
+        return {
+            "pr_number": pr_number,
+            "title": pr["title"],
+            "review": review,
+            "files_reviewed": len(files),
+            "posted_to_github": bool(GITHUB_TOKEN),
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ─── Repo Info ────────────────────────────────────────────────────────────────
+
+@router.get("/repo/{owner}/{repo}", summary="Get repository info")
+async def get_repo_info(owner: str, repo: str):
+    try:
+        info = await gh_get(f"/repos/{owner}/{repo}")
+        return {
+            "name": info["name"],
+            "full_name": info["full_name"],
+            "description": info.get("description"),
+            "url": info["html_url"],
+            "default_branch": info["default_branch"],
+            "language": info.get("language"),
+            "stars": info["stargazers_count"],
+            "forks": info["forks_count"],
+            "open_issues": info["open_issues_count"],
+            "private": info["private"],
+        }
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
+
+
+# ─── Status check ─────────────────────────────────────────────────────────────
+
+@router.get("/status", summary="GitHub integration status")
+async def github_status():
+    configured = bool(GITHUB_TOKEN)
+    user = None
+    if configured:
+        try:
+            user_info = await gh_get("/user")
+            user = user_info.get("login")
+        except Exception:
+            configured = False
+    return {
+        "configured": configured,
+        "user": user,
+        "owner": GITHUB_OWNER or user,
+        "capabilities": [
+            "clone", "create_repo", "commit", "push",
+            "pr/create", "issues/create", "review"
+        ],
+    }

api/routes/health.py

@@ -1,5 +1,5 @@
 """
-Health + Status Routes — God Agent OS V7
+Health + Status Routes — God Mode+ v3.0
 """
 
 import time
@@ -9,10 +9,6 @@ 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):
@@ -26,37 +22,24 @@ async def health(request: Request):
     cs = connector_manager.get_summary() if connector_manager else {}
     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 Agent OS V7",
-        "version": "7.0.0",
+        "name": "GOD MODE+ AI Operating System",
+        "version": "3.0.0",
         "timestamp": time.time(),
         "platform": {
-            "mode": "god_agent_v7",
+            "mode": "god_mode_plus",
             "agents": orchestrator.get_status()["agents"] if orchestrator else [],
             "agent_count": orchestrator.get_status()["total_agents"] if orchestrator else 0,
         },
         "ai_router": {
-            "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),
+            "providers": {k: v["available"] for k, v in ai_stats.items()},
+            "ai_ready": any(v["available"] for v in ai_stats.values()),
         },
         "connectors": {
             "connected": cs.get("connected", 0),
             "total": cs.get("total", 0),
-            "ai_ready": ai_ready,
+            "ai_ready": cs.get("ai_ready", False),
         },
         "task_engine": {
             "queue_size": engine._queue.qsize(),
@@ -67,14 +50,16 @@ async def health(request: Request):
             "rooms": list(stats["rooms"].keys()),
         },
         "phases": [
-            "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 ✅",
+            "Phase 1: God Agent Orchestrator ✅",
+            "Phase 2: Sandbox Agent ✅",
+            "Phase 3: Connector System ✅",
+            "Phase 4: Autonomous Coding Engine ✅",
+            "Phase 5: Memory System ✅",
+            "Phase 6: Real-time Streaming ✅",
+            "Phase 7: Workflow Factor OS ✅",
+            "Phase 8: Modern UI Rebuild ✅",
+            "Phase 9: Multi-Model AI Router ✅",
+            "Phase 10-12: Observability + Security + God Mode+ ✅",
         ],
     }
 
@@ -96,10 +81,5 @@ 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(),
     }

connectors/manager.py

@@ -1,7 +1,6 @@
 """
-Connector Manager — GOD MODE+ V5
-16 connectors including Gemini, SambaNova, GitHub Models
-Multi-key aware: checks comma-separated env values
+Connector Manager — Manus-style connector ecosystem
+Manages OAuth tokens, connection state, API access
 """
 import json
 import os
@@ -12,123 +11,200 @@ import structlog
 log = structlog.get_logger()
 
 CONNECTORS_CONFIG = [
-    # ── Code ──────────────────────────────────────────────────────────────────
-    {"id": "github", "name": "GitHub", "icon": "github", "color": "#24292e",
-     "env_key": "GITHUB_TOKEN", "description": "Repos, Issues, PRs, Commits",
-     "scopes": ["repo", "issues", "pull_requests"], "category": "code"},
-    # ── Deploy ────────────────────────────────────────────────────────────────
-    {"id": "huggingface", "name": "HuggingFace", "icon": "huggingface", "color": "#ff9d00",
-     "env_key": "HF_TOKEN", "description": "Spaces, Models, Datasets",
-     "scopes": ["spaces", "models"], "category": "deploy"},
-    {"id": "vercel", "name": "Vercel", "icon": "vercel", "color": "#000000",
-     "env_key": "VERCEL_TOKEN", "description": "Deployments, Domains, Functions",
-     "scopes": ["deployments", "projects"], "category": "deploy"},
-    # ── AI Providers ──────────────────────────────────────────────────────────
-    {"id": "gemini", "name": "Gemini", "icon": "google", "color": "#4285f4",
-     "env_key": "GEMINI_API_KEYS", "description": "Gemini 2.0 Flash — 6 key pool",
-     "scopes": ["chat", "vision"], "category": "ai", "multi_key": True},
-    {"id": "sambanova", "name": "SambaNova", "icon": "sambanova", "color": "#e84142",
-     "env_key": "SAMBANOVA_API_KEYS", "description": "Llama 3.3 70B — 9 key pool",
-     "scopes": ["chat"], "category": "ai", "multi_key": True},
-    {"id": "github_models", "name": "GitHub Models", "icon": "github", "color": "#6e40c9",
-     "env_key": "GITHUB_API_KEYS", "description": "GPT-4o via Azure — 9 key pool",
-     "scopes": ["chat"], "category": "ai", "multi_key": True},
-    {"id": "openai", "name": "OpenAI", "icon": "openai", "color": "#10a37f",
-     "env_key": "OPENAI_API_KEY", "description": "GPT-4o, Embeddings, DALL-E",
-     "scopes": ["chat", "embeddings"], "category": "ai"},
-    {"id": "groq", "name": "Groq", "icon": "groq", "color": "#f55036",
-     "env_key": "GROQ_API_KEY", "description": "Llama 3.3 70B — Ultra Fast",
-     "scopes": ["chat"], "category": "ai"},
-    {"id": "cerebras", "name": "Cerebras", "icon": "cerebras", "color": "#7c3aed",
-     "env_key": "CEREBRAS_API_KEY", "description": "Llama 3.3 70B — Lightning Fast",
-     "scopes": ["chat"], "category": "ai"},
-    {"id": "anthropic", "name": "Anthropic", "icon": "anthropic", "color": "#d97706",
-     "env_key": "ANTHROPIC_API_KEY", "description": "Claude 3.5 Haiku / Sonnet",
-     "scopes": ["chat"], "category": "ai"},
-    {"id": "openrouter", "name": "OpenRouter", "icon": "openrouter", "color": "#6366f1",
-     "env_key": "OPENROUTER_API_KEY", "description": "100+ models via OpenRouter",
-     "scopes": ["chat"], "category": "ai"},
-    # ── Storage / Data ────────────────────────────────────────────────────────
-    {"id": "supabase", "name": "Supabase", "icon": "supabase", "color": "#3ecf8e",
-     "env_key": "SUPABASE_URL", "description": "Database, Auth, Storage",
-     "scopes": ["database", "auth"], "category": "data"},
-    {"id": "mongodb", "name": "MongoDB", "icon": "mongodb", "color": "#13aa52",
-     "env_key": "MONGODB_URI", "description": "NoSQL Database",
-     "scopes": ["database"], "category": "data"},
-    # ── Comms ─────────────────────────────────────────────────────────────────
-    {"id": "slack", "name": "Slack", "icon": "slack", "color": "#4a154b",
-     "env_key": "SLACK_BOT_TOKEN", "description": "Messages, Channels, Notifications",
-     "scopes": ["messages", "channels"], "category": "comms"},
-    {"id": "discord", "name": "Discord", "icon": "discord", "color": "#5865f2",
-     "env_key": "DISCORD_BOT_TOKEN", "description": "Bot, Messages, Webhooks",
-     "scopes": ["messages"], "category": "comms"},
-    {"id": "telegram", "name": "Telegram", "icon": "telegram", "color": "#2ca5e0",
-     "env_key": "TELEGRAM_BOT_TOKEN", "description": "Bot API, Messages",
-     "scopes": ["messages"], "category": "comms"},
+    {
+        "id": "github",
+        "name": "GitHub",
+        "icon": "github",
+        "color": "#24292e",
+        "env_key": "GITHUB_TOKEN",
+        "description": "Repos, Issues, PRs, Commits",
+        "scopes": ["repo", "issues", "pull_requests"],
+        "category": "code",
+    },
+    {
+        "id": "huggingface",
+        "name": "HuggingFace",
+        "icon": "huggingface",
+        "color": "#ff9d00",
+        "env_key": "HF_TOKEN",
+        "description": "Spaces, Models, Datasets",
+        "scopes": ["spaces", "models"],
+        "category": "ai",
+    },
+    {
+        "id": "vercel",
+        "name": "Vercel",
+        "icon": "vercel",
+        "color": "#000000",
+        "env_key": "VERCEL_TOKEN",
+        "description": "Deployments, Domains, Functions",
+        "scopes": ["deployments", "projects"],
+        "category": "deploy",
+    },
+    {
+        "id": "openai",
+        "name": "OpenAI",
+        "icon": "openai",
+        "color": "#10a37f",
+        "env_key": "OPENAI_API_KEY",
+        "description": "GPT-4o, Embeddings, DALL-E",
+        "scopes": ["chat", "embeddings"],
+        "category": "ai",
+    },
+    {
+        "id": "groq",
+        "name": "Groq",
+        "icon": "groq",
+        "color": "#f55036",
+        "env_key": "GROQ_API_KEY",
+        "description": "Llama 3.3 70B — Ultra Fast",
+        "scopes": ["chat"],
+        "category": "ai",
+    },
+    {
+        "id": "cerebras",
+        "name": "Cerebras",
+        "icon": "cerebras",
+        "color": "#7c3aed",
+        "env_key": "CEREBRAS_API_KEY",
+        "description": "Llama 3.1 70B — Long Context",
+        "scopes": ["chat"],
+        "category": "ai",
+    },
+    {
+        "id": "openrouter",
+        "name": "OpenRouter",
+        "icon": "openrouter",
+        "color": "#6366f1",
+        "env_key": "OPENROUTER_API_KEY",
+        "description": "Multi-model router, free tier",
+        "scopes": ["chat"],
+        "category": "ai",
+    },
+    {
+        "id": "anthropic",
+        "name": "Anthropic",
+        "icon": "anthropic",
+        "color": "#d4a27f",
+        "env_key": "ANTHROPIC_API_KEY",
+        "description": "Claude 3.5 Sonnet",
+        "scopes": ["chat"],
+        "category": "ai",
+    },
+    {
+        "id": "n8n",
+        "name": "n8n",
+        "icon": "n8n",
+        "color": "#ea4b71",
+        "env_key": "N8N_URL",
+        "description": "Workflow automation engine",
+        "scopes": ["workflows", "executions"],
+        "category": "workflow",
+    },
+    {
+        "id": "telegram",
+        "name": "Telegram",
+        "icon": "telegram",
+        "color": "#0088cc",
+        "env_key": "TELEGRAM_BOT_TOKEN",
+        "description": "Bot API, messages, webhooks",
+        "scopes": ["messages", "bots"],
+        "category": "messaging",
+    },
+    {
+        "id": "discord",
+        "name": "Discord",
+        "icon": "discord",
+        "color": "#5865f2",
+        "env_key": "DISCORD_BOT_TOKEN",
+        "description": "Bot, channels, webhooks",
+        "scopes": ["messages", "bots"],
+        "category": "messaging",
+    },
+    {
+        "id": "slack",
+        "name": "Slack",
+        "icon": "slack",
+        "color": "#4a154b",
+        "env_key": "SLACK_BOT_TOKEN",
+        "description": "Messages, channels, workflows",
+        "scopes": ["messages", "channels"],
+        "category": "messaging",
+    },
+    {
+        "id": "cloudflare",
+        "name": "Cloudflare",
+        "icon": "cloudflare",
+        "color": "#f38020",
+        "env_key": "CLOUDFLARE_API_TOKEN",
+        "description": "Workers, KV, Pages",
+        "scopes": ["workers", "kv", "pages"],
+        "category": "infra",
+    },
 ]
 
 
 class ConnectorManager:
-    def __init__(self):
-        self._tokens: Dict[str, str] = {}
+    """Manages all platform connectors — connection state, tokens, status."""
 
-    def _is_configured(self, connector: dict) -> bool:
-        """Check if a connector has its env var set (supports comma-separated multi-key)."""
-        val = os.environ.get(connector["env_key"], "").strip()
-        if not val:
-            return False
-        # For multi-key connectors, at least one key must be present
-        keys = [k.strip() for k in val.split(",") if k.strip()]
-        return len(keys) > 0
+    def __init__(self):
+        self._configs = {c["id"]: c for c in CONNECTORS_CONFIG}
 
-    def get_all(self) -> List[dict]:
+    def get_all(self) -> List[Dict]:
+        """Get all connectors with connection status."""
         result = []
-        for c in CONNECTORS_CONFIG:
-            connected = self._is_configured(c) or c["id"] in self._tokens
+        for cfg in CONNECTORS_CONFIG:
+            token = os.environ.get(cfg["env_key"], "")
             result.append({
-                **c,
-                "connected": connected,
-                "has_token": connected,
+                **cfg,
+                "connected": bool(token),
+                "token_preview": f"{token[:8]}..." if token else None,
             })
         return result
 
-    def get_connected(self) -> List[dict]:
+    def get_connected(self) -> List[Dict]:
+        """Get only connected connectors."""
         return [c for c in self.get_all() if c["connected"]]
 
-    def get_by_category(self, category: str) -> List[dict]:
-        return [c for c in self.get_all() if c.get("category") == category]
+    def get_by_category(self, category: str) -> List[Dict]:
+        """Get connectors by category."""
+        return [c for c in self.get_all() if c["category"] == category]
 
     def is_connected(self, connector_id: str) -> bool:
-        c = next((x for x in CONNECTORS_CONFIG if x["id"] == connector_id), None)
-        if not c:
+        cfg = self._configs.get(connector_id)
+        if not cfg:
             return False
-        return self._is_configured(c) or connector_id in self._tokens
-
-    def set_token(self, connector_id: str, token: str):
-        self._tokens[connector_id] = token
+        return bool(os.environ.get(cfg["env_key"], ""))
 
-    def clear_token(self, connector_id: str):
-        self._tokens.pop(connector_id, None)
+    def get_token(self, connector_id: str) -> Optional[str]:
+        cfg = self._configs.get(connector_id)
+        if not cfg:
+            return None
+        return os.environ.get(cfg["env_key"]) or None
 
-    def get_env_key(self, connector_id: str) -> Optional[str]:
-        c = next((x for x in CONNECTORS_CONFIG if x["id"] == connector_id), None)
-        return c["env_key"] if c else None
+    def set_token(self, connector_id: str, token: str):
+        """Set connector token at runtime (does not persist across restarts)."""
+        cfg = self._configs.get(connector_id)
+        if cfg:
+            os.environ[cfg["env_key"]] = token
+            log.info("Connector token set", connector=connector_id)
 
-    def get_summary(self) -> dict:
+    def get_summary(self) -> Dict:
         all_c = self.get_all()
         connected = [c for c in all_c if c["connected"]]
-
-        # AI ready = at least one of the primary AI providers is connected
-        ai_providers = {"gemini", "sambanova", "github_models", "openai", "groq", "cerebras", "anthropic", "openrouter"}
-        ai_ready = any(c["id"] in ai_providers for c in connected)
-
+        by_cat = {}
+        for c in all_c:
+            cat = c["category"]
+            if cat not in by_cat:
+                by_cat[cat] = {"total": 0, "connected": 0}
+            by_cat[cat]["total"] += 1
+            if c["connected"]:
+                by_cat[cat]["connected"] += 1
         return {
             "total": len(all_c),
             "connected": len(connected),
-            "ai_ready": ai_ready,
-            "categories": {
-                cat: len([c for c in connected if c.get("category") == cat])
-                for cat in ["ai", "code", "deploy", "data", "comms"]
-            },
-            "connected_ids": [c["id"] for c in connected],
+            "by_category": by_cat,
+            "ai_ready": self.is_connected("openai") or self.is_connected("groq")
+                        or self.is_connected("openrouter") or self.is_connected("anthropic")
+                        or self.is_connected("cerebras"),
         }

core/agent.py

@@ -21,7 +21,7 @@ log = structlog.get_logger()
 OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
 ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
 DEFAULT_MODEL = os.environ.get("DEFAULT_MODEL", "gpt-4o")
-OPENAI_BASE_URL = os.environ.get("OPENAI_BASE_URL", os.environ.get("CUSTOM_GATEWAY_URL", "https://gateway.pyaesone-gtckglay.workers.dev/v1"))
+OPENAI_BASE_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1")
 
 
 SYSTEM_PROMPT = """You are an elite autonomous AI software engineer — like Devin or Manus.

main.py

@@ -1,7 +1,7 @@
 """
-🚀 GOD MODE+ Autonomous AI Operating System v4.0
-REAL Execution-First Architecture — Devin + Manus + Genspark Style
-Phase 4: Terminal Engine + FileSystem + GitHub + DAG + Self-Repair
+🚀 GOD MODE+ Autonomous AI Operating System
+Devin + Manus + Genspark Style — Production-Grade Backend
+Version: 3.0.0 — Full God Mode Upgrade
 """
 
 import asyncio
@@ -24,7 +24,6 @@ from slowapi.errors import RateLimitExceeded
 
 from api.routes import tasks, chat, memory, github, health
 from api.routes import connectors, agents as agents_router
-from api.routes import execution as execution_router
 from api.websocket_manager import WebSocketManager
 from core.task_engine import TaskEngine
 from memory.db import init_db
@@ -44,12 +43,6 @@ from agents.sandbox_agent import SandboxAgent
 from agents.ui_agent import UIAgent
 from connectors.manager import ConnectorManager
 
-# ─── New Execution Tools ───────────────────────────────────────────────────────
-from tools.terminal_engine import TerminalEngine
-from tools.filesystem import FileSystemTool
-from tools.github_tool import GitHubTool
-from tools.task_dag import DAGEngine
-
 # ─── Structured Logging ────────────────────────────────────────────────────────
 structlog.configure(
     processors=[
@@ -70,16 +63,11 @@ task_engine = TaskEngine(ws_manager)
 ai_router = AIRouter(ws_manager)
 connector_manager = ConnectorManager()
 
-# ─── Execution Tools ───────────────────────────────────────────────────────────
-terminal_engine = TerminalEngine(ws_manager)
-fs_tool = FileSystemTool()
-github_tool = GitHubTool()
-dag_engine = DAGEngine(ws_manager)
-
-
 # ─── Build God Agent Ecosystem ────────────────────────────────────────────────
 def build_orchestrator() -> GodAgentOrchestrator:
     orchestrator = GodAgentOrchestrator(ws_manager=ws_manager, ai_router=ai_router)
+
+    # Register all specialized agents
     orchestrator.register_agent("chat",      ChatAgent(ws_manager, ai_router))
     orchestrator.register_agent("planner",   PlannerAgent(ws_manager, ai_router))
     orchestrator.register_agent("coding",    CodingAgent(ws_manager, ai_router))
@@ -90,40 +78,34 @@ def build_orchestrator() -> GodAgentOrchestrator:
     orchestrator.register_agent("workflow",  WorkflowAgent(ws_manager, ai_router))
     orchestrator.register_agent("sandbox",   SandboxAgent(ws_manager, ai_router))
     orchestrator.register_agent("ui",        UIAgent(ws_manager, ai_router))
+
     log.info("🤖 God Agent Ecosystem initialized", agents=10)
     return orchestrator
 
-
 orchestrator = build_orchestrator()
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    log.info("🚀 Starting GOD MODE+ v4.0 AI Operating System...")
-    log.info("⚡ REAL Execution Engine: Terminal + FileSystem + GitHub + DAG")
+    """Startup + Shutdown lifecycle."""
+    log.info("🚀 Starting GOD MODE+ AI Operating System...")
     await init_db()
     await task_engine.start()
     asyncio.create_task(ws_manager.heartbeat_loop())
-
-    # Ensure workspace exists
-    ws_dir = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-    os.makedirs(ws_dir, exist_ok=True)
-
-    log.info("✅ GOD MODE+ v4.0 Platform ready")
+    log.info("✅ GOD MODE+ Platform ready — All agents online")
     log.info("🤖 Agents: Chat, Planner, Coding, Debug, Memory, Connector, Deploy, Workflow, Sandbox, UI")
-    log.info("🔧 Tools: TerminalEngine, FileSystem, GitHub, DAG Engine, SelfRepair")
     log.info("🌐 AI Router: OpenAI → Groq → Cerebras → OpenRouter → Anthropic")
     yield
-    log.info("🛑 Shutting down GOD MODE+ v4.0...")
+    log.info("🛑 Shutting down...")
     await task_engine.stop()
     log.info("✅ Shutdown complete")
 
 
 # ─── FastAPI App ───────────────────────────────────────────────────────────────
 app = FastAPI(
-    title="🤖 GOD MODE+ AI Operating System v4.0",
-    description="REAL Execution-First Autonomous AI Engineering Platform — Devin + Manus + Genspark",
-    version="4.0.0",
+    title="🤖 GOD MODE+ AI Operating System",
+    description="Devin + Manus + Genspark Autonomous AI Engineering Platform",
+    version="3.0.0",
     lifespan=lifespan,
     docs_url="/api/docs",
     redoc_url="/api/redoc",
@@ -138,10 +120,6 @@ app.state.task_engine = task_engine
 app.state.ai_router = ai_router
 app.state.orchestrator = orchestrator
 app.state.connector_manager = connector_manager
-app.state.terminal_engine = terminal_engine
-app.state.fs_tool = fs_tool
-app.state.github_tool = github_tool
-app.state.dag_engine = dag_engine
 
 # ─── Middleware ────────────────────────────────────────────────────────────────
 app.add_middleware(
@@ -171,10 +149,9 @@ app.include_router(memory.router,             prefix="/api/v1/memory",       tag
 app.include_router(github.router,             prefix="/api/v1/github",       tags=["github"])
 app.include_router(connectors.router,         prefix="/api/v1/connectors",   tags=["connectors"])
 app.include_router(agents_router.router,      prefix="/api/v1/agents",       tags=["agents"])
-app.include_router(execution_router.router,   prefix="/api/v1/exec",         tags=["execution"])
 
 
-# ─── WebSocket: Task Stream ────────────────────────────────────────────────────
+# ─── WebSocket Endpoints ───────────────────────────────────────────────────────
 @app.websocket("/ws/tasks/{task_id}")
 async def ws_task(websocket: WebSocket, task_id: str):
     await ws_manager.connect(websocket, room=f"task:{task_id}")
@@ -188,7 +165,6 @@ async def ws_task(websocket: WebSocket, task_id: str):
         ws_manager.disconnect(websocket, room=f"task:{task_id}")
 
 
-# ─── WebSocket: Logs ──────────────────────────────────────────────────────────
 @app.websocket("/ws/logs")
 async def ws_logs(websocket: WebSocket):
     await ws_manager.connect(websocket, room="logs")
@@ -202,7 +178,6 @@ async def ws_logs(websocket: WebSocket):
         ws_manager.disconnect(websocket, room="logs")
 
 
-# ─── WebSocket: Chat ──────────────────────────────────────────────────────────
 @app.websocket("/ws/chat/{session_id}")
 async def ws_chat(websocket: WebSocket, session_id: str):
     await ws_manager.connect(websocket, room=f"chat:{session_id}")
@@ -213,6 +188,7 @@ async def ws_chat(websocket: WebSocket, session_id: str):
             if msg.get("type") == "ping":
                 await websocket.send_json({"type": "pong", "timestamp": time.time()})
             elif msg.get("type") == "chat_message":
+                # Route through God Agent Orchestrator
                 asyncio.create_task(
                     orchestrator.orchestrate(
                         user_message=msg.get("content", ""),
@@ -221,6 +197,7 @@ async def ws_chat(websocket: WebSocket, session_id: str):
                     )
                 )
             elif msg.get("type") == "task_message":
+                # Create autonomous task via task engine
                 from core.models import TaskCreateRequest
                 req = TaskCreateRequest(
                     goal=msg.get("content", ""),
@@ -231,7 +208,6 @@ async def ws_chat(websocket: WebSocket, session_id: str):
         ws_manager.disconnect(websocket, room=f"chat:{session_id}")
 
 
-# ─── WebSocket: Agent Status ──────────────────────────────────────────────────
 @app.websocket("/ws/agent/status")
 async def ws_agent_status(websocket: WebSocket):
     await ws_manager.connect(websocket, room="agent_status")
@@ -250,112 +226,40 @@ async def ws_agent_status(websocket: WebSocket):
         ws_manager.disconnect(websocket, room="agent_status")
 
 
-# ─── WebSocket: Sandbox Terminal ──────────────────────────────────────────────
 @app.websocket("/ws/sandbox/{session_id}")
 async def ws_sandbox(websocket: WebSocket, session_id: str):
-    """Live streaming sandbox terminal."""
+    """Live sandbox terminal stream."""
     await ws_manager.connect(websocket, room=f"sandbox:{session_id}")
+    sandbox = orchestrator.get_agent("sandbox")
     try:
         while True:
             data = await websocket.receive_text()
             msg = json.loads(data)
-
             if msg.get("type") == "ping":
                 await websocket.send_json({"type": "pong", "timestamp": time.time()})
-
-            elif msg.get("type") == "execute":
+            elif msg.get("type") == "execute" and sandbox:
                 cmd = msg.get("command", "")
-                task_id = msg.get("task_id", "")
-
-                async def stream_line(line: str):
-                    try:
-                        await websocket.send_json({
-                            "type": "terminal_output",
-                            "line": line,
-                            "timestamp": time.time(),
-                        })
-                    except Exception:
-                        pass
-
-                result = await terminal_engine.execute(
-                    cmd,
-                    session_id=session_id,
-                    task_id=task_id,
-                    stream_callback=stream_line,
-                )
+                result = await sandbox.execute(cmd, session_id=session_id)
                 await websocket.send_json({
-                    "type": "terminal_result",
+                    "type": "terminal_output",
                     "command": cmd,
-                    "output": result.get("output", ""),
-                    "exit_code": result.get("exit_code", 0),
-                    "success": result.get("success", False),
-                    "duration": result.get("duration", 0),
+                    "output": result,
                     "timestamp": time.time(),
                 })
-
-            elif msg.get("type") == "kill":
-                result = await terminal_engine.kill(session_id)
-                await websocket.send_json({"type": "kill_result", **result})
-
-            elif msg.get("type") == "write_file":
-                filename = msg.get("filename", "")
-                content = msg.get("content", "")
-                result = await fs_tool.write_file(filename, content)
-                await websocket.send_json({"type": "file_result", **result})
-
-            elif msg.get("type") == "read_file":
-                filename = msg.get("filename", "")
-                result = await fs_tool.read_file(filename)
-                await websocket.send_json({"type": "file_result", **result})
-
-            elif msg.get("type") == "list_files":
-                result = await fs_tool.list_dir(msg.get("path", ""))
-                await websocket.send_json({"type": "file_list", **result})
-
-            elif msg.get("type") == "tree":
-                result = await fs_tool.tree(msg.get("path", ""))
-                await websocket.send_json({"type": "tree_result", **result})
-
     except WebSocketDisconnect:
         ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
 
 
-# ─── WebSocket: DAG Progress ──────────────────────────────────────────────────
-@app.websocket("/ws/dag/{dag_id}")
-async def ws_dag(websocket: WebSocket, dag_id: str):
-    """Real-time DAG execution progress."""
-    await ws_manager.connect(websocket, room=f"dag:{dag_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "get_dag":
-                dag = dag_engine.get_dag(dag_id)
-                if dag:
-                    await websocket.send_json({"type": "dag_state", "dag": dag.to_dict()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"dag:{dag_id}")
-
-
 # ─── Root ──────────────────────────────────────────────────────────────────────
 @app.get("/")
 async def root():
     cs = connector_manager.get_summary()
     return {
         "name": "🤖 GOD MODE+ AI Operating System",
-        "version": "4.0.0",
+        "version": "3.0.0",
         "status": "operational",
-        "mode": "god_mode_plus_v4",
-        "execution_engine": "REAL",
+        "mode": "god_mode_plus",
         "agents": orchestrator.get_status()["agents"],
-        "tools": {
-            "terminal": "TerminalEngine (streaming, self-repair)",
-            "filesystem": "FileSystemTool (read/write/patch/search/tree)",
-            "github": "GitHubTool (clone/commit/push/pr/issues)",
-            "dag": "DAGEngine (parallel, dependency-aware)",
-        },
         "connectors": {
             "connected": cs["connected"],
             "total": cs["total"],
@@ -368,7 +272,6 @@ async def root():
             "/ws/chat/{session_id}",
             "/ws/agent/status",
             "/ws/sandbox/{session_id}",
-            "/ws/dag/{dag_id}",
         ],
         "phases_complete": [
             "Phase 1: God Agent Orchestrator",
@@ -377,12 +280,7 @@ async def root():
             "Phase 4: Autonomous Coding Engine",
             "Phase 5: Memory System",
             "Phase 6: Real-time Streaming",
-            "Phase 7: Workflow Factory OS",
-            "Phase 8: Terminal Execution Engine",
+            "Phase 7: Workflow Factor OS",
             "Phase 9: Multi-Model AI Router",
-            "Phase 10: FileSystem Control",
-            "Phase 11: GitHub Autonomy",
-            "Phase 12: Task DAG Engine",
-            "Phase 13: Self-Repair Loop",
         ],
     }