God Mode+ v3 fix: agents/base_agent.py

agents/base_agent.py

@@ -1,54 +1,60 @@
 """
-Base Agent — Abstract base for all God Mode agents
+BaseAgent — All agents inherit from this.
+Uses LLMRouter (never direct API calls).
 """
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+import asyncio
+from typing import Any, Dict, Optional
 import structlog
 
 log = structlog.get_logger()
 
 
-class BaseAgent(ABC):
-    """Abstract base class for all agents in the God Mode ecosystem."""
-
+class BaseAgent:
     def __init__(self, name: str, ws_manager=None, ai_router=None):
-        self.name = name
-        self.ws = ws_manager
-        self.ai_router = ai_router
-        self.log = structlog.get_logger().bind(agent=name)
+        self.name      = name
+        self.ws        = ws_manager
+        self.router    = ai_router   # LLMRouter instance
+        self._running  = False
 
-    @abstractmethod
     async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        """Execute the agent's primary task."""
-        pass
-
-    async def emit(self, room: str, event: str, data: Dict, session_id: str = ""):
-        """Emit WebSocket event if manager available."""
-        if self.ws:
-            await self.ws.emit(room, event, data, session_id=session_id)
-
-    async def emit_chat(self, session_id: str, event: str, data: Dict):
-        """Emit chat WebSocket event."""
-        if self.ws:
-            await self.ws.emit_chat(session_id, event, data)
-
-    async def llm(
+        raise NotImplementedError(f"{self.name}.run() not implemented")
+
+    async def emit(self, task_id: str, event_type: str, data: Dict, session_id: str = ""):
+        if not self.ws:
+            return
+        try:
+            if task_id:
+                await self.ws.emit(task_id, event_type, {
+                    **data, "agent": self.name
+                }, session_id=session_id)
+            elif session_id:
+                await self.ws.emit_chat(session_id, event_type, {
+                    **data, "agent": self.name
+                })
+        except Exception as e:
+            log.warning(f"BaseAgent.emit error", agent=self.name, error=str(e))
+
+    async def ask_llm(
         self,
-        messages: List[Dict],
-        task_id: str = "",
-        session_id: str = "",
+        messages: list,
+        task_id:    str   = "",
+        session_id: str   = "",
         temperature: float = 0.7,
-        max_tokens: int = 4096,
-        model: str = "",
+        max_tokens: int   = 4096,
+        model: str        = "",
     ) -> str:
-        """Route LLM call through AI router."""
-        if self.ai_router:
-            return await self.ai_router.complete(
+        """All agent LLM calls go through the shared LLMRouter."""
+        if self.router:
+            return await self.router.ask(
                 messages=messages,
                 task_id=task_id,
                 session_id=session_id,
                 temperature=temperature,
                 max_tokens=max_tokens,
-                preferred_model=model,
+                model=model,
+                stream=True,
             )
-        return f"[{self.name}] AI router not configured."
+        return f"[{self.name}] No LLM router available"
+
+    def get_status(self) -> Dict:
+        return {"name": self.name, "running": self._running}