stravinsky 0.2.40__py3-none-any.whl → 0.3.4__py3-none-any.whl

mcp_bridge/tools/agent_manager.py

@@ -11,6 +11,7 @@ import os
 import shutil
 import subprocess
 import signal
+import time
 import uuid
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
@@ -21,6 +22,85 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+# Model routing configuration
+# Specialized agents call external models via MCP tools:
+#   explore/dewey/document_writer/multimodal → invoke_gemini(gemini-3-flash)
+#   frontend → invoke_gemini(gemini-3-pro-high)
+#   delphi → invoke_openai(gpt-5.2)
+# Non-specialized coding tasks use Claude CLI with --model sonnet
+AGENT_MODEL_ROUTING = {
+    # Specialized agents - no CLI model flag, they call invoke_* tools
+    "explore": None,
+    "dewey": None,
+    "document_writer": None,
+    "multimodal": None,
+    "frontend": None,
+    "delphi": None,
+    "research-lead": None,  # Hierarchical orchestrator using gemini-3-flash
+    "implementation-lead": None,  # Hierarchical orchestrator using haiku
+    # Planner uses Opus for superior reasoning about dependencies and parallelization
+    "planner": "opus",
+    # Default for unknown agent types (coding tasks) - use Sonnet 4.5
+    "_default": "sonnet",
+}
+
+# Cost tier classification (from oh-my-opencode pattern)
+AGENT_COST_TIERS = {
+    "explore": "CHEAP",  # Uses gemini-3-flash
+    "dewey": "CHEAP",  # Uses gemini-3-flash
+    "document_writer": "CHEAP",  # Uses gemini-3-flash
+    "multimodal": "CHEAP",  # Uses gemini-3-flash
+    "research-lead": "CHEAP",  # Uses gemini-3-flash
+    "implementation-lead": "CHEAP",  # Uses haiku
+    "frontend": "MEDIUM",  # Uses gemini-3-pro-high
+    "delphi": "EXPENSIVE",  # Uses gpt-5.2 (OpenAI GPT)
+    "planner": "EXPENSIVE",  # Uses Claude Opus 4.5
+    "_default": "EXPENSIVE",  # Claude Sonnet 4.5 via CLI
+}
+
+# Display model names for output formatting (user-visible)
+AGENT_DISPLAY_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "document_writer": "gemini-3-flash",
+    "multimodal": "gemini-3-flash",
+    "research-lead": "gemini-3-flash",
+    "implementation-lead": "haiku",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2",
+    "planner": "opus-4.5",
+    "_default": "sonnet-4.5",
+}
+
+# Cost tier emoji indicators for visual differentiation
+# Colors indicate cost: 🟢 cheap/free, 🔵 medium, 🟣 expensive (GPT), 🟠 Claude
+COST_TIER_EMOJI = {
+    "CHEAP": "🟢",  # Free/cheap models (gemini-3-flash, haiku)
+    "MEDIUM": "🔵",  # Medium cost (gemini-3-pro-high)
+    "EXPENSIVE": "🟣",  # Expensive models (gpt-5.2, opus)
+}
+
+# Model family indicators
+MODEL_FAMILY_EMOJI = {
+    "gemini-3-flash": "🟢",
+    "gemini-3-pro-high": "🔵",
+    "haiku": "🟢",
+    "sonnet-4.5": "🟠",
+    "opus-4.5": "🟣",
+    "gpt-5.2": "🟣",
+}
+
+
+def get_agent_emoji(agent_type: str) -> str:
+    """Get the colored emoji indicator for an agent based on its cost tier."""
+    cost_tier = AGENT_COST_TIERS.get(agent_type, AGENT_COST_TIERS["_default"])
+    return COST_TIER_EMOJI.get(cost_tier, "⚪")
+
+
+def get_model_emoji(model_name: str) -> str:
+    """Get the colored emoji indicator for a model."""
+    return MODEL_FAMILY_EMOJI.get(model_name, "⚪")
+
 
 @dataclass
 class AgentTask:
@@ -86,7 +166,7 @@ class AgentManager:
 
         # In-memory tracking for running processes
         self._processes: Dict[str, subprocess.Popen] = {}
-        self._notification_queue: Dict[str, List[AgentTask]] = {}
+        self._notification_queue: Dict[str, List[Dict[str, Any]]] = {}
 
     def _load_tasks(self) -> Dict[str, Any]:
         """Load tasks from persistent storage."""
@@ -155,7 +235,9 @@ class AgentManager:
         Returns:
             Task ID for tracking
         """
-        task_id = f"agent_{uuid.uuid4().hex[:8]}"
+        import uuid as uuid_module  # Local import for MCP context
+
+        task_id = f"agent_{uuid_module.uuid4().hex[:8]}"
 
         task = AgentTask(
             id=task_id,
@@ -220,12 +302,20 @@ class AgentManager:
                     full_prompt,
                     "--output-format",
                     "text",
+                    "--dangerously-skip-permissions",  # Critical: bypass permission prompts
                 ]
 
-                # NOTE: We intentionally do NOT pass --model to Claude CLI
-                # The agent_configs have Stravinsky MCP model names (gemini-3-pro-low, gpt-5.2)
-                # which Claude CLI doesn't recognize. Agents use Claude's default model
-                # and can invoke Stravinsky MCP tools (invoke_gemini, invoke_openai) if needed.
+                # Model routing:
+                # - Specialized agents (explore/dewey/etc): None = use CLI default, they call invoke_*
+                # - Unknown agent types (coding tasks): Use Sonnet 4.5
+                if agent_type in AGENT_MODEL_ROUTING:
+                    cli_model = AGENT_MODEL_ROUTING[agent_type]  # None for specialized
+                else:
+                    cli_model = AGENT_MODEL_ROUTING.get("_default", "sonnet")
+
+                if cli_model:
+                    cmd.extend(["--model", cli_model])
+                    logger.info(f"[AgentManager] Using --model {cli_model} for {agent_type} agent")
 
                 # Add system prompt file if we have one
                 if system_prompt:
@@ -240,6 +330,7 @@ class AgentManager:
                 # (Previously used file handle which was closed before process finished)
                 process = subprocess.Popen(
                     cmd,
+                    stdin=subprocess.DEVNULL,  # Critical: prevent stdin blocking
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     text=True,
@@ -416,20 +507,28 @@ class AgentManager:
             start = datetime.now()
             while (datetime.now() - start).total_seconds() < timeout:
                 task = self.get_task(task_id)
-                if task["status"] != "running":
+                if not task or task["status"] != "running":
                     break
-                asyncio.sleep(0.5)
+                time.sleep(0.5)
+
+        # Refresh task state after potential blocking wait
+        if not task:
+            return f"Task {task_id} not found."
 
         status = task["status"]
         description = task.get("description", "")
         agent_type = task.get("agent_type", "unknown")
 
+        # Get cost-tier emoji for visual differentiation
+        cost_emoji = get_agent_emoji(agent_type)
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+
         if status == "completed":
             result = task.get("result", "(no output)")
-            return f"""✅ Agent Task Completed
+            return f"""{cost_emoji} ✅ Agent Task Completed
 
 **Task ID**: {task_id}
-**Agent**: {agent_type}
+**Agent**: {agent_type}:{display_model}
 **Description**: {description}
 
 **Result**:
@@ -437,29 +536,29 @@ class AgentManager:
 
         elif status == "failed":
             error = task.get("error", "(no error details)")
-            return f"""❌ Agent Task Failed
+            return f"""{cost_emoji} ❌ Agent Task Failed
 
 **Task ID**: {task_id}
-**Agent**: {agent_type}
+**Agent**: {agent_type}:{display_model}
 **Description**: {description}
 
 **Error**:
 {error}"""
 
         elif status == "cancelled":
-            return f"""⚠️ Agent Task Cancelled
+            return f"""{cost_emoji} ⚠️ Agent Task Cancelled
 
 **Task ID**: {task_id}
-**Agent**: {agent_type}
+**Agent**: {agent_type}:{display_model}
 **Description**: {description}"""
 
         else:  # pending or running
             pid = task.get("pid", "N/A")
             started = task.get("started_at", "N/A")
-            return f"""⏳ Agent Task Running
+            return f"""{cost_emoji} ⏳ Agent Task Running
 
 **Task ID**: {task_id}
-**Agent**: {agent_type}
+**Agent**: {agent_type}:{display_model}
 **Description**: {description}
 **PID**: {pid}
 **Started**: {started}
@@ -535,10 +634,14 @@ Use `agent_output` with block=true to wait for completion."""
             "cancelled": "⚠️",
         }.get(status, "❓")
 
-        result = f"""{status_emoji} **Agent Progress**
+        # Get cost-tier emoji for visual differentiation
+        cost_emoji = get_agent_emoji(agent_type)
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+
+        result = f"""{cost_emoji} {status_emoji} **Agent Progress**
 
 **Task ID**: {task_id}
-**Agent**: {agent_type}
+**Agent**: {agent_type}:{display_model}
 **Description**: {description}
 **Status**: {status}
 """
@@ -583,6 +686,7 @@ async def agent_spawn(
     model: str = "gemini-3-flash",
     thinking_budget: int = 0,
     timeout: int = 300,
+    blocking: bool = False,
 ) -> str:
     """
     Spawn a background agent.
@@ -594,95 +698,191 @@ async def agent_spawn(
         model: Model to use (gemini-3-flash, gemini-2.0-flash, claude)
         thinking_budget: Reserved reasoning tokens
         timeout: Execution timeout in seconds
+        blocking: If True, wait for completion and return result directly (use for delphi)
 
     Returns:
-        Task ID and instructions
+        Task ID and instructions, or full result if blocking=True
     """
     manager = get_manager()
 
     # Map agent types to system prompts
+    # ALL agents use invoke_gemini or invoke_openai - NOT Claude directly
+    # explore/dewey/document_writer/multimodal/frontend → gemini-3-flash
+    # delphi → openai gpt-5.2
     system_prompts = {
-        "explore": "You are a codebase exploration specialist. Find files, patterns, and answer 'where is X?' questions efficiently.",
-        "dewey": "You are a documentation and research specialist. Find implementation examples, official docs, and provide evidence-based answers.",
-        "frontend": """You are a Senior Frontend Architect & Avant-Garde UI Designer with 15+ years experience.
-
-OPERATIONAL DIRECTIVES:
-- Follow instructions. Execute immediately. No fluff.
-- Output First: Prioritize code and visual solutions.
-
-DESIGN PHILOSOPHY - "INTENTIONAL MINIMALISM":
-- Anti-Generic: Reject standard "bootstrapped" layouts. If it looks like a template, it's wrong.
-- Bespoke layouts, asymmetry, distinctive typography.
-- Before placing any element, calculate its purpose. No purpose = delete it.
-
-FRONTEND CODING STANDARDS:
-- Library Discipline: If a UI library (Shadcn, Radix, MUI) is detected, YOU MUST USE IT.
-- Do NOT build custom components if the library provides them.
-- Stack: Modern (React/Vue/Svelte), Tailwind/Custom CSS, semantic HTML5.
-- Focus on micro-interactions, perfect spacing, "invisible" UX.
-
-RESPONSE FORMAT:
-1. Rationale: (1 sentence on why elements were placed there)
-2. The Code.
-
-ULTRATHINK MODE (when user says "ULTRATHINK" or "think harder"):
-1. Deep Reasoning Chain: Detailed breakdown of architectural and design decisions
-2. Edge Case Analysis: What could go wrong and how we prevented it
-3. The Code: Optimized, bespoke, production-ready, utilizing existing libraries""",
-        "delphi": "You are a strategic advisor. Provide architecture guidance, debugging assistance, and code review.",
-        "document_writer": """You are a Technical Documentation Specialist. Your expertise is creating clear, comprehensive documentation.
-
-DOCUMENT TYPES YOU EXCEL AT:
-- README files with proper structure
-- API documentation with examples
-- Architecture decision records (ADRs)
-- User guides and tutorials
-- Inline code documentation
-
-DOCUMENTATION PRINCIPLES:
-- Audience-first: Know who's reading and what they need
-- Progressive disclosure: Overview → Details → Edge cases
-- Examples over explanations: Show, don't just tell
-- Keep it DRY: Reference rather than repeat
-- Version awareness: Note when behavior differs across versions
-
-RESPONSE FORMAT:
-1. Document type and target audience identified
-2. The documentation, properly formatted in markdown""",
-        "multimodal": """You interpret media files that cannot be read as plain text.
-
-Your job: examine the attached file and extract ONLY what was requested.
-
-CAPABILITIES:
-- PDFs: extract text, structure, tables, data from specific sections
-- Images: describe layouts, UI elements, text, diagrams, charts
-- Diagrams: explain relationships, flows, architecture depicted
-- Screenshots: analyze UI/UX, identify components, extract text
-
-HOW YOU WORK:
-1. Receive a file path and a goal describing what to extract
-2. Read and analyze the file deeply using Gemini's vision capabilities
-3. Return ONLY the relevant extracted information
-4. The main agent never processes the raw file - you save context tokens
-
-RESPONSE RULES:
-- Return extracted information directly, no preamble
-- If info not found, state clearly what's missing
-- Be thorough on the goal, concise on everything else""",
+        "explore": """You are a codebase exploration specialist. Find files, patterns, and answer 'where is X?' questions.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL analysis and reasoning.
+Use Claude's native tools (Read, Grep, Glob) ONLY for file access, then pass content to invoke_gemini.
+
+WORKFLOW:
+1. Use Read/Grep/Glob to get file contents
+2. Call invoke_gemini(prompt="Analyze this: <content>", model="gemini-3-flash", agent_context={"agent_type": "explore"}) for analysis
+3. Return the Gemini response""",
+        "dewey": """You are a documentation and research specialist. Find implementation examples and official docs.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL analysis, summarization, and reasoning.
+
+WORKFLOW:
+1. Gather information using available tools
+2. Call invoke_gemini(prompt="<task>", model="gemini-3-flash", agent_context={"agent_type": "dewey"}) for processing
+3. Return the Gemini response""",
+        "frontend": """You are a Senior Frontend Architect & UI Designer.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-pro-high" for ALL code generation and design work.
+
+DESIGN PHILOSOPHY:
+- Anti-Generic: Reject standard layouts. Bespoke, asymmetric, distinctive.
+- Library Discipline: Use existing UI libraries (Shadcn, Radix, MUI) if detected.
+- Stack: React/Vue/Svelte, Tailwind/Custom CSS, semantic HTML5.
+
+WORKFLOW:
+1. Analyze requirements
+2. Call invoke_gemini(prompt="Generate frontend code for: <task>", model="gemini-3-pro-high", agent_context={"agent_type": "frontend"})
+3. Return the code""",
+        "delphi": """You are a strategic technical advisor for architecture and hard debugging.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_openai with model="gpt-5.2" for ALL strategic advice and analysis.
+
+WORKFLOW:
+1. Gather context about the problem
+2. Call invoke_openai(prompt="<problem description>", model="gpt-5.2", agent_context={"agent_type": "delphi"})
+3. Return the GPT response""",
+        "document_writer": """You are a Technical Documentation Specialist.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL documentation generation.
+
+DOCUMENT TYPES: README, API docs, ADRs, user guides, inline docs.
+
+WORKFLOW:
+1. Gather context about what to document
+2. Call invoke_gemini(prompt="Write documentation for: <topic>", model="gemini-3-flash", agent_context={"agent_type": "document_writer"})
+3. Return the documentation""",
+        "multimodal": """You interpret media files (PDFs, images, diagrams, screenshots).
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL visual analysis.
+
+WORKFLOW:
+1. Receive file path and extraction goal
+2. Call invoke_gemini(prompt="Analyze this file: <path>. Extract: <goal>", model="gemini-3-flash", agent_context={"agent_type": "multimodal"})
+3. Return extracted information only""",
+        "planner": """You are a pre-implementation planning specialist. You analyze requests and produce structured implementation plans BEFORE any code changes begin.
+
+PURPOSE:
+- Analyze requests and produce actionable implementation plans
+- Identify dependencies and parallelization opportunities
+- Enable efficient parallel execution by the orchestrator
+- Prevent wasted effort through upfront planning
+
+METHODOLOGY:
+1. EXPLORE FIRST: Spawn explore agents IN PARALLEL to understand the codebase
+2. DECOMPOSE: Break request into atomic, single-purpose tasks
+3. ANALYZE DEPENDENCIES: What blocks what? What can run in parallel?
+4. ASSIGN AGENTS: Map each task to the right specialist (explore/dewey/frontend/delphi)
+5. OUTPUT STRUCTURED PLAN: Use the required format below
+
+REQUIRED OUTPUT FORMAT:
+```
+## PLAN: [Brief title]
+
+### ANALYSIS
+- **Request**: [One sentence summary]
+- **Scope**: [What's in/out of scope]
+- **Risk Level**: [Low/Medium/High]
+
+### EXECUTION PHASES
+
+#### Phase 1: [Name] (PARALLEL)
+| Task | Agent | Files | Est |
+|------|-------|-------|-----|
+| [description] | explore | file.py | S/M/L |
+
+#### Phase 2: [Name] (SEQUENTIAL after Phase 1)
+| Task | Agent | Files | Est |
+|------|-------|-------|-----|
+
+### AGENT SPAWN COMMANDS
+```python
+# Phase 1 - Fire all in parallel
+agent_spawn(prompt="...", agent_type="explore", description="...")
+```
+```
+
+CONSTRAINTS:
+- You ONLY plan. You NEVER execute code changes.
+- Every task must have a clear agent assignment
+- Parallel phases must be truly independent
+- Include ready-to-use agent_spawn commands""",
+        "research-lead": """You coordinate research tasks by spawning explore and dewey agents in parallel.
+
+## Your Role
+1. Receive research objective from Stravinsky
+2. Decompose into parallel search tasks
+3. Spawn explore/dewey agents for each task
+4. Collect and SYNTHESIZE results
+5. Return structured findings (not raw outputs)
+
+## Output Format
+Always return a Research Brief:
+```json
+{
+  "objective": "Original research goal",
+  "findings": [
+    {"source": "agent_id", "summary": "Key finding", "confidence": "high/medium/low"},
+    ...
+  ],
+  "synthesis": "Combined analysis of all findings",
+  "gaps": ["Information we couldn't find"],
+  "recommendations": ["Suggested next steps"]
+}
+```
+
+MODEL ROUTING:
+Use invoke_gemini with model="gemini-3-flash" for ALL synthesis work.
+""",
+        "implementation-lead": """You coordinate implementation based on research findings.
+
+## Your Role
+1. Receive Research Brief from Stravinsky
+2. Create implementation plan
+3. Delegate to specialists:
+   - frontend: UI/visual work
+   - debugger: Fix failures
+   - code-reviewer: Quality checks
+4. Verify with lsp_diagnostics
+5. Return Implementation Report
+
+## Output Format
+```json
+{
+  "objective": "What was implemented",
+  "files_changed": ["path/to/file.py"],
+  "tests_status": "pass/fail/skipped",
+  "diagnostics": "clean/warnings/errors",
+  "blockers": ["Issues preventing completion"]
+}
+```
+
+## Escalation Rules
+- After 2 failed attempts → spawn debugger
+- After debugger fails → escalate to Stravinsky with context
+- NEVER call delphi directly
+""",
     }
 
     system_prompt = system_prompts.get(agent_type, None)
 
-    # NOTE: All agents run via Claude CLI using Claude's default model.
-    # The agent_configs below are kept for documentation purposes only.
-    # Agents can invoke Stravinsky MCP tools (invoke_gemini, invoke_openai)
-    # within their prompts if they need to use other models.
-    #
-    # Agent model preferences (for reference - NOT passed to Claude CLI):
-    # - stravinsky: Claude Opus 4.5 (orchestration)
-    # - delphi: GPT-5.2 (strategic advice) - use invoke_openai
-    # - frontend: Gemini Pro High (UI/UX) - use invoke_gemini with thinking_budget
-    # - explore, dewey, document_writer, multimodal: Gemini Flash (fast) - use invoke_gemini
+    # Model routing (MANDATORY - enforced in system prompts):
+    # - explore, dewey, document_writer, multimodal → invoke_gemini(gemini-3-flash)
+    # - frontend → invoke_gemini(gemini-3-pro-high)
+    # - delphi → invoke_openai(gpt-5.2)
+    # - Unknown agent types (coding tasks) → Claude CLI --model sonnet
 
     # Get token store for authentication
     from ..auth.token_store import TokenStore
@@ -700,16 +900,20 @@ RESPONSE RULES:
         timeout=timeout,
     )
 
-    return f"""🚀 Background agent spawned successfully.
+    # Get display model and cost tier emoji for concise output
+    display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+    cost_emoji = get_agent_emoji(agent_type)
+    short_desc = (description or prompt[:50]).strip()
 
-**Task ID**: {task_id}
-**Agent Type**: {agent_type}
-**Description**: {description or prompt[:50]}
+    # If blocking mode (recommended for delphi), wait for completion
+    if blocking:
+        result = manager.get_output(task_id, block=True, timeout=timeout)
+        return f"{cost_emoji} {agent_type}:{display_model}('{short_desc}') [BLOCKING]\n\n{result}"
 
-The agent is now running. Use:
-- `agent_progress(task_id="{task_id}")` to monitor real-time progress
-- `agent_output(task_id="{task_id}")` to get final result
-- `agent_cancel(task_id="{task_id}")` to stop the agent"""
+    # Enhanced format: cost_emoji agent:model('description') status_emoji
+    # 🟢 explore:gemini-3-flash('Find auth...') ⏳
+    return f"""{cost_emoji} {agent_type}:{display_model}('{short_desc}') ⏳
+task_id={task_id}"""
 
 
 async def agent_output(task_id: str, block: bool = False) -> str:
@@ -799,7 +1003,7 @@ async def agent_list() -> str:
     if not tasks:
         return "No background agent tasks found."
 
-    lines = ["**Background Agent Tasks**", ""]
+    lines = []
 
     for t in sorted(tasks, key=lambda x: x.get("created_at", ""), reverse=True):
         status_emoji = {
@@ -810,8 +1014,14 @@ async def agent_list() -> str:
             "cancelled": "⚠️",
         }.get(t["status"], "❓")
 
+        agent_type = t.get("agent_type", "unknown")
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+        cost_emoji = get_agent_emoji(agent_type)
         desc = t.get("description", t.get("prompt", "")[:40])
-        lines.append(f"- {status_emoji} [{t['id']}] {t['agent_type']}: {desc}")
+        # Concise format: cost_emoji status agent:model('desc') id=xxx
+        lines.append(
+            f"{cost_emoji} {status_emoji} {agent_type}:{display_model}('{desc}') id={t['id']}"
+        )
 
     return "\n".join(lines)
 

mcp_bridge/tools/background_tasks.py

@@ -61,7 +61,8 @@ class BackgroundManager:
             json.dump(tasks, f, indent=2)
 
     def create_task(self, prompt: str, model: str) -> str:
-        task_id = str(uuid.uuid4())[:8]
+        import uuid as uuid_module  # Local import for MCP context
+        task_id = str(uuid_module.uuid4())[:8]
         task = BackgroundTask(
             id=task_id,
             prompt=prompt,