stravinsky 0.2.38__py3-none-any.whl → 0.2.52__py3-none-any.whl

mcp_bridge/tools/agent_manager.py

@@ -8,8 +8,10 @@ This replaces the simple model-only invocation with true agentic execution.
 import asyncio
 import json
 import os
+import shutil
 import subprocess
 import signal
+import time
 import uuid
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
@@ -20,6 +22,38 @@ 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,
+    # 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
+    "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
+}
+
 
 @dataclass
 class AgentTask:
@@ -62,9 +96,13 @@ class AgentManager:
     - Provides notification mechanism for task completion
     """
 
-    CLAUDE_CLI = "/opt/homebrew/bin/claude"
+    # Dynamic CLI path - find claude in PATH, fallback to common locations
+    CLAUDE_CLI = shutil.which("claude") or "/opt/homebrew/bin/claude"
 
     def __init__(self, base_dir: Optional[str] = None):
+        # Initialize lock FIRST - used by _save_tasks and _load_tasks
+        self._lock = threading.RLock()
+
         if base_dir:
             self.base_dir = Path(base_dir)
         else:
@@ -81,8 +119,7 @@ class AgentManager:
 
         # In-memory tracking for running processes
         self._processes: Dict[str, subprocess.Popen] = {}
-        self._notification_queue: Dict[str, List[AgentTask]] = {}
-        self._lock = threading.RLock()
+        self._notification_queue: Dict[str, List[Dict[str, Any]]] = {}
 
     def _load_tasks(self) -> Dict[str, Any]:
         """Load tasks from persistent storage."""
@@ -151,7 +188,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,
@@ -216,11 +255,20 @@ class AgentManager:
                     full_prompt,
                     "--output-format",
                     "text",
+                    "--dangerously-skip-permissions",  # Critical: bypass permission prompts
                 ]
 
-                # Add model selection if specified
-                if model:
-                    cmd.extend(["--model", model])
+                # 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:
@@ -231,16 +279,18 @@ class AgentManager:
                 # Execute Claude CLI as subprocess with full tool access
                 logger.info(f"[AgentManager] Running: {' '.join(cmd[:3])}...")
 
-                with open(log_file, "w") as log_f:
-                    process = subprocess.Popen(
-                        cmd,
-                        stdout=subprocess.PIPE,
-                        stderr=log_f,
-                        text=True,
-                        cwd=str(Path.cwd()),
-                        env={**os.environ, "CLAUDE_CODE_ENTRYPOINT": "stravinsky-agent"},
-                        start_new_session=True,  # Allow process group management
-                    )
+                # Use PIPE for stderr to capture it properly
+                # (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,
+                    cwd=str(Path.cwd()),
+                    env={**os.environ, "CLAUDE_CODE_ENTRYPOINT": "stravinsky-agent"},
+                    start_new_session=True,  # Allow process group management
+                )
 
                 # Track the process
                 self._processes[task_id] = process
@@ -248,9 +298,13 @@ class AgentManager:
 
                 # Wait for completion with timeout
                 try:
-                    stdout, _ = process.communicate(timeout=timeout)
+                    stdout, stderr = process.communicate(timeout=timeout)
                     result = stdout.strip() if stdout else ""
 
+                    # Write stderr to log file
+                    if stderr:
+                        log_file.write_text(stderr)
+
                     if process.returncode == 0:
                         output_file.write_text(result)
                         self._update_task(
@@ -262,8 +316,8 @@ class AgentManager:
                         logger.info(f"[AgentManager] Agent {task_id} completed successfully")
                     else:
                         error_msg = f"Claude CLI exited with code {process.returncode}"
-                        if log_file.exists():
-                            error_msg += f"\n{log_file.read_text()}"
+                        if stderr:
+                            error_msg += f"\n{stderr}"
                         self._update_task(
                             task_id,
                             status="failed",
@@ -406,9 +460,13 @@ 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", "")
@@ -591,96 +649,128 @@ async def agent_spawn(
     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""",
     }
 
     system_prompt = system_prompts.get(agent_type, None)
 
-    # Override model and thinking_budget based on agent type for optimal performance
-    # Per project requirements:
-    # - Gemini tiers are controlled by thinking_budget, NOT model name
-    # - high: 32000, medium: 16000, low: 8000 thinking tokens
-    # - "gemini-3-pro-high" = gemini-3-pro-low + thinking_budget=32000
-    # - "gemini-3-flash" equivalent = gemini-3-pro-low + thinking_budget=0
-    agent_configs = {
-        "stravinsky": {"model": "claude-opus-4-5", "thinking_budget": 0},
-        "frontend": {"model": "gemini-3-pro-low", "thinking_budget": 32000},  # HIGH tier
-        "document_writer": {"model": "gemini-3-pro-low", "thinking_budget": 0},  # Flash equiv
-        "multimodal": {"model": "gemini-3-pro-low", "thinking_budget": 0},  # Flash equiv
-        "explore": {"model": "gemini-3-pro-low", "thinking_budget": 0},  # Flash equiv
-        "delphi": {"model": "gpt-5.2", "thinking_budget": 0},  # GPT-5.2 strategic
-        "dewey": {"model": "gemini-3-pro-low", "thinking_budget": 0},  # Flash equiv
-    }
-    config = agent_configs.get(agent_type, {"model": model, "thinking_budget": thinking_budget})
-    actual_model = config["model"]
-    actual_thinking_budget = config["thinking_budget"]
+    # 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
@@ -693,8 +783,8 @@ RESPONSE RULES:
         agent_type=agent_type,
         description=description or prompt[:50],
         system_prompt=system_prompt,
-        model=actual_model,
-        thinking_budget=actual_thinking_budget,
+        model=model,  # Not used for Claude CLI, kept for API compatibility
+        thinking_budget=thinking_budget,  # Not used for Claude CLI, kept for API compatibility
         timeout=timeout,
     )
 
@@ -702,8 +792,6 @@ RESPONSE RULES:
 
 **Task ID**: {task_id}
 **Agent Type**: {agent_type}
-**Model**: {actual_model}
-**Thinking Budget**: {actual_thinking_budget if actual_thinking_budget > 0 else "N/A"}
 **Description**: {description or prompt[:50]}
 
 The agent is now running. Use:

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,