stravinsky 0.2.67__py3-none-any.whl → 0.4.66__py3-none-any.whl

mcp_bridge/prompts/stravinsky.py

@@ -12,8 +12,6 @@ Key naming conventions (Stravinsky equivalents):
 - agent_spawn (not call-omo-agent) - spawn background agents
 """
 
-from typing import Optional
-
 # Core role definition
 STRAVINSKY_ROLE_SECTION = """<Role>
 You are "Stravinsky" - Powerful AI Agent with orchestration capabilities from Stravinsky MCP.
@@ -36,7 +34,7 @@ Named after the composer known for revolutionary orchestration.
 </Role>"""
 
 
-STRAVINSKY_PHASE0_STEP1_3 = """### Step 0: Check Skills FIRST (BLOCKING)
+STRAVINSKY_PHASE0_STEP1_3 = """### Step 0: Check Skills FUWT (BLOCKING)
 
 **Before ANY classification or action, scan for matching skills.**
 
@@ -54,7 +52,7 @@ Skills are specialized workflows. When relevant, they handle the task better tha
 
 | Type | Signal | Action |
 |------|--------|--------|
-| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FIRST** via `skill_get` tool |
+| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FUWT** via `skill_get` tool |
 | **Trivial** | Single file, known location, direct answer | Direct tools only (UNLESS Key Trigger applies) |
 | **Explicit** | Specific file/line, clear command | Execute directly |
 | **Exploratory** | "How does X work?", "Find Y" | Fire explore (1-3) + tools in parallel |
@@ -159,7 +157,7 @@ STOP searching when:
 **DO NOT over-explore. Time is precious.**"""
 
 
-STRAVINSKY_PHASE2B_PRE_IMPLEMENTATION = """## ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
+STRAVINSKY_PHASE2B_PRE_IMPLEMENTATION = """## ⚠️ CRITICAL: PARALLEL-FUWT WORKFLOW
 
 **BLOCKING REQUIREMENT**: For implementation tasks, your response structure MUST be:
 
@@ -204,54 +202,78 @@ todowrite([todo1, todo2, todo3])
 4. THEN mark todos complete"""
 
 
-STRAVINSKY_DELEGATION_PROMPT_STRUCTURE = """### Delegation Prompt Structure (MANDATORY - ALL 7 sections):
+STRAVINSKY_DELEGATION_PROMPT_STRUCTURE = """### Delegation Prompt Structure (RECOMMENDED - 5 KEY SECTIONS):
 
-When delegating via `agent_spawn`, your prompt MUST include ALL 7 sections:
+When delegating via `agent_spawn`, your prompt SHOULD include these sections:
 
 ```
-1. TASK: Atomic, specific goal (one sentence)
+1. TASK: Clear, natural language description of what needs to be found/analyzed
 2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED TOOLS: Explicit tool whitelist (Read, Grep, Glob, etc.)
-4. MUST DO: Exhaustive requirements list
-5. MUST NOT DO: Forbidden actions (prevent rogue behavior)
-6. CONTEXT: File paths, existing patterns, constraints
-7. SUCCESS CRITERIA: How to verify completion
+3. MUST DO: Exhaustive requirements list
+4. MUST NOT DO: Forbidden actions (prevent rogue behavior)
+5. CONTEXT: File paths, existing patterns, constraints (if known)
 ```
 
-**Example Delegation Prompt:**
+**❌ WRONG - Over-Prescribing Tools:**
 ```
 ## TASK
 Find all API endpoint definitions in the auth module.
 
-## EXPECTED OUTCOME
-List of endpoints with: path, method, handler function, file location.
-
 ## REQUIRED TOOLS
-Read, Grep, Glob
+Read, Grep, Glob  # ❌ DON'T PRESCRIBE TOOLS - agents choose optimal approach
+
+## MUST DO
+- Use grep_search to find "def" patterns  # ❌ TOO SPECIFIC
+```
+
+**✅ CORRECT - Natural Language + Trust Agent Intelligence:**
+```
+## TASK
+Find and explain all API endpoint definitions in the auth module, including their request/response patterns and how they connect to each other.
+
+## EXPECTED OUTCOME
+Complete list of endpoints with: path, method, handler function, file location, and architectural notes on how they integrate.
 
 ## MUST DO
-- Search in src/auth/ directory
-- Include path parameters
-- Report line numbers
+- Search in src/auth/ directory and related integration points
+- Include path parameters and query string handling
+- Report exact line numbers for each endpoint
+- Explain the authentication flow across endpoints
 
 ## MUST NOT DO
 - Modify any files
-- Search outside src/auth/
+- Skip integration patterns (how endpoints call each other)
 
 ## CONTEXT
 Project uses FastAPI. Auth endpoints handle login, logout, token refresh.
+This is a CONCEPTUAL/ARCHITECTURAL query - the agent should use semantic_search + grep for comprehensive coverage.
 
 ## SUCCESS CRITERIA
-All endpoints documented with complete paths and handlers.
+All endpoints documented with complete paths, handlers, AND architectural understanding of how they work together.
 ```
 
+**WHY THIS WORKS BETTER:**
+- ✅ Explore agent has `semantic_search` in its toolset and knows when to use it
+- ✅ Natural language tasks → agent classifies as SEMANTIC → uses semantic_search
+- ✅ Agent combines semantic_search (concepts) + grep_search (exact matches) automatically
+- ❌ "REQUIRED TOOLS: grep_search" → blocks semantic_search even for conceptual queries
+
+**TRUST THE AGENTS:**
+The explore agent already has comprehensive tool selection logic:
+- Semantic queries → semantic_search (primary)
+- Exact syntax → grep_search
+- Code structure → ast_grep_search
+- Symbol navigation → LSP tools
+
+Let them choose the optimal search strategy based on your TASK description, not prescriptive tool lists.
+
 AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS:
 - DOES IT WORK AS EXPECTED?
 - DOES IT FOLLOW THE EXISTING CODEBASE PATTERN?
 - EXPECTED RESULT CAME OUT?
 - DID THE AGENT FOLLOW "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
 
-**Vague prompts = rejected. Be exhaustive.**"""
+**Natural language task descriptions = agent intelligence. Tool prescriptions = micromanagement.**"""
 
 
 STRAVINSKY_GITHUB_WORKFLOW = """### GitHub Workflow (CRITICAL - When mentioned in issues/PRs):
@@ -358,7 +380,7 @@ If verification fails:
 
 STRAVINSKY_KEY_TRIGGERS = """### Key Triggers (check BEFORE classification):
 
-**BLOCKING: Check skills FIRST before any action.**
+**BLOCKING: Check skills FUWT before any action.**
 If a skill matches, invoke it IMMEDIATELY via `skill_get` tool.
 
 - External library/source mentioned -> fire `dewey` background via `agent_spawn`
@@ -472,12 +494,12 @@ Delphi is an expensive, high-quality reasoning model. Use it wisely via `agent_s
 
 | Trigger | Action |
 |---------|--------|
-| Complex architecture design | Delphi FIRST, then implement |
-| After completing significant work | Delphi FIRST, then implement |
-| 2+ failed fix attempts | Delphi FIRST, then implement |
-| Unfamiliar code patterns | Delphi FIRST, then implement |
-| Security/performance concerns | Delphi FIRST, then implement |
-| Multi-system tradeoffs | Delphi FIRST, then implement |
+| Complex architecture design | Delphi FUWT, then implement |
+| After completing significant work | Delphi FUWT, then implement |
+| 2+ failed fix attempts | Delphi FUWT, then implement |
+| Unfamiliar code patterns | Delphi FUWT, then implement |
+| Security/performance concerns | Delphi FUWT, then implement |
+| Multi-system tradeoffs | Delphi FUWT, then implement |
 
 ### WHEN NOT to Consult:
 

mcp_bridge/proxy/client.py

@@ -0,0 +1,70 @@
+import os
+import httpx
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger("stravinsky.proxy_client")
+
+PROXY_URL = os.getenv("STRAVINSKY_PROXY_URL", "http://127.0.0.1:8765")
+
+async def proxy_invoke_gemini(
+    prompt: str,
+    model: str = "gemini-3-flash",
+    temperature: float = 0.7,
+    max_tokens: int = 8192,
+    thinking_budget: int = 0,
+    image_path: Optional[str] = None,
+    agent_context: Optional[dict[str, Any]] = None
+) -> str:
+    """Routes Gemini invocation to the proxy server."""
+    payload = {
+        "prompt": prompt,
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "thinking_budget": thinking_budget,
+        "image_path": image_path,
+        "agent_context": agent_context
+    }
+    
+    async with httpx.AsyncClient(timeout=130.0) as client:
+        try:
+            response = await client.post(f"{PROXY_URL}/v1/gemini/generate", json=payload)
+            response.raise_for_status()
+            return response.json()["response"]
+        except Exception as e:
+            logger.error(f"Proxy request failed: {e}")
+            raise
+
+async def proxy_invoke_openai(
+    prompt: str,
+    model: str = "gpt-5.2-codex",
+    temperature: float = 0.7,
+    max_tokens: int = 4096,
+    thinking_budget: int = 0,
+    reasoning_effort: str = "medium",
+    agent_context: Optional[dict[str, Any]] = None
+) -> str:
+    """Routes OpenAI invocation to the proxy server."""
+    payload = {
+        "prompt": prompt,
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "thinking_budget": thinking_budget,
+        "reasoning_effort": reasoning_effort,
+        "agent_context": agent_context
+    }
+    
+    async with httpx.AsyncClient(timeout=130.0) as client:
+        try:
+            response = await client.post(f"{PROXY_URL}/v1/openai/chat", json=payload)
+            response.raise_for_status()
+            return response.json()["response"]
+        except Exception as e:
+            logger.error(f"Proxy request failed: {e}")
+            raise
+
+def is_proxy_enabled() -> bool:
+    """Checks if proxy usage is enabled via environment variable."""
+    return os.getenv("STRAVINSKY_USE_PROXY", "false").lower() == "true"

mcp_bridge/proxy/model_server.py

@@ -0,0 +1,157 @@
+import logging
+import os
+import time
+import uuid
+from typing import Any
+
+import uvicorn
+from fastapi import FastAPI, HTTPException, Request
+from pydantic import BaseModel
+
+from mcp_bridge.auth.token_store import TokenStore
+from mcp_bridge.tools.model_invoke import invoke_gemini, invoke_openai
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger("stravinsky.proxy")
+
+app = FastAPI(title="Stravinsky Model Proxy")
+
+
+@app.middleware("http")
+async def add_process_time_header(request: Request, call_next):
+    request_id = str(uuid.uuid4())
+    start_time = time.time()
+    logger.info(f"[{request_id}] {request.method} {request.url.path}")
+    response = await call_next(request)
+    process_time = time.time() - start_time
+    response.headers["X-Process-Time"] = str(process_time)
+    response.headers["X-Request-ID"] = request_id
+    logger.info(f"[{request_id}] Completed in {process_time:.4f}s")
+    return response
+
+
+# Shared token store
+_token_store = None
+
+
+def get_token_store():
+    global _token_store
+    if _token_store is None:
+        _token_store = TokenStore()
+    return _token_store
+
+
+class GeminiRequest(BaseModel):
+    prompt: str
+    model: str = "gemini-3-flash"
+    temperature: float = 0.7
+    max_tokens: int = 8192
+    thinking_budget: int = 0
+    image_path: str | None = None
+    agent_context: dict[str, Any] | None = None
+
+
+class GeminiAgenticRequest(BaseModel):
+    prompt: str
+    model: str = "gemini-3-flash"
+    max_turns: int = 10
+    timeout: int = 120
+
+
+class OpenAIRequest(BaseModel):
+    prompt: str
+    model: str = "gpt-5.2-codex"
+    temperature: float = 0.7
+    max_tokens: int = 4096
+    thinking_budget: int = 0
+    reasoning_effort: str = "medium"
+    agent_context: dict[str, Any] | None = None
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@app.post("/v1/gemini/generate")
+async def gemini_generate(request: GeminiRequest):
+    """Proxy endpoint for Gemini generation."""
+    try:
+        token_store = get_token_store()
+        # We need to ensure agent_context is passed correctly if invoke_gemini supports it
+        # Based on previous read, invoke_gemini takes image_path, but agent_context
+        # might be extracted from hooks or passed in params.
+        # Actually, invoke_gemini extracts it from params.
+
+        response = await invoke_gemini(
+            token_store=token_store,
+            prompt=request.prompt,
+            model=request.model,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens,
+            thinking_budget=request.thinking_budget,
+            image_path=request.image_path,
+        )
+        return {"response": response}
+    except Exception as e:
+        logger.error(f"Error in gemini_generate proxy: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@app.post("/v1/gemini/agentic")
+async def gemini_agentic(request: GeminiAgenticRequest):
+    """Proxy endpoint for Agentic Gemini."""
+    try:
+        from mcp_bridge.tools.model_invoke import invoke_gemini_agentic
+
+        token_store = get_token_store()
+        response = await invoke_gemini_agentic(
+            token_store=token_store,
+            prompt=request.prompt,
+            model=request.model,
+            max_turns=request.max_turns,
+            timeout=request.timeout,
+        )
+        return {"response": response}
+    except Exception as e:
+        logger.error(f"Error in gemini_agentic proxy: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@app.post("/v1/openai/chat")
+async def openai_chat(request: OpenAIRequest):
+    """Proxy endpoint for OpenAI chat."""
+    try:
+        token_store = get_token_store()
+        response = await invoke_openai(
+            token_store=token_store,
+            prompt=request.prompt,
+            model=request.model,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens,
+            thinking_budget=request.thinking_budget,
+            reasoning_effort=request.reasoning_effort,
+        )
+        return {"response": response}
+    except Exception as e:
+        logger.error(f"Error in openai_chat proxy: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+def main():
+    """Entry point for the proxy server."""
+    # CRITICAL: Disable proxy usage within the proxy process to avoid infinite loops
+    os.environ["STRAVINSKY_USE_PROXY"] = "false"
+
+    port = int(os.getenv("STRAVINSKY_PROXY_PORT", 8765))
+    host = os.getenv("STRAVINSKY_PROXY_HOST", "127.0.0.1")
+    logger.info(f"Starting Stravinsky Model Proxy on {host}:{port}")
+    uvicorn.run(app, host=host, port=port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

mcp_bridge/routing/__init__.py

@@ -0,0 +1,43 @@
+"""
+Stravinsky Multi-Provider Routing System.
+
+This module provides intelligent routing between providers (Claude, OpenAI, Gemini)
+with automatic fallback when providers hit rate limits or capacity constraints.
+
+Components:
+- ProviderState: Tracks availability of each provider
+- ProviderStateTracker: Global state management for all providers
+- TaskClassifier: Classifies tasks to route to optimal providers
+- RoutingConfig: Project-local configuration loader
+"""
+
+from .config import (
+    DEFAULT_ROUTING_CONFIG,
+    RoutingConfig,
+    load_routing_config,
+)
+from .provider_state import (
+    ProviderState,
+    ProviderStateTracker,
+    get_provider_tracker,
+)
+from .task_classifier import (
+    TaskType,
+    classify_task,
+    get_routing_for_task,
+)
+
+__all__ = [
+    # Provider state
+    "ProviderState",
+    "ProviderStateTracker",
+    "get_provider_tracker",
+    # Task classification
+    "TaskType",
+    "classify_task",
+    "get_routing_for_task",
+    # Configuration
+    "load_routing_config",
+    "RoutingConfig",
+    "DEFAULT_ROUTING_CONFIG",
+]

mcp_bridge/routing/config.py

@@ -0,0 +1,250 @@
+"""
+Routing Configuration with Project-Local Priority.
+
+Loads routing configuration from:
+1. .stravinsky/routing.json (project-local - highest priority)
+2. ~/.stravinsky/routing.json (user-global fallback)
+3. Built-in defaults
+
+This allows per-project customization of routing behavior.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+logger = logging.getLogger(__name__)
+
+# Default routing configuration
+DEFAULT_ROUTING_CONFIG: dict[str, Any] = {
+    "routing": {
+        "enabled": True,
+        "task_routing": {
+            "code_generation": {
+                "provider": "claude",
+                "model": "claude-4.5-opus",
+                "tier": "premium",
+            },
+            "code_refactoring": {
+                "provider": "claude",
+                "model": "claude-4.5-sonnet",
+                "tier": "standard",
+            },
+            "debugging": {
+                "provider": "openai",
+                "model": "gpt-5.2",
+                "tier": "standard",
+            },
+            "architecture": {
+                "provider": "openai",
+                "model": "gpt-5.2",
+                "tier": "standard",
+            },
+            "documentation": {
+                "provider": "gemini",
+                "model": "gemini-3-flash-preview",
+                "tier": "standard",
+            },
+            "code_search": {
+                "provider": "gemini",
+                "model": "gemini-3-flash-preview",
+                "tier": "standard",
+            },
+            "security_review": {
+                "provider": "claude",
+                "model": "claude-4.5-opus",
+                "tier": "premium",
+            },
+            "general": {
+                "provider": "claude",
+                "model": "claude-4.5-sonnet",
+                "tier": "standard",
+            },
+        },
+        "fallback": {
+            "enabled": True,
+            "chain": ["claude", "openai", "gemini"],
+            "cooldown_seconds": 300,
+        },
+        "claude_limits": {
+            "detection_enabled": True,
+            "slow_response_threshold_seconds": 30,
+            "auto_fallback": True,
+        },
+    }
+}
+
+
+@dataclass
+class TaskRoutingRule:
+    """Routing rule for a specific task type."""
+
+    provider: str
+    model: str | None = None
+    tier: Literal["premium", "standard"] = "standard"
+
+
+@dataclass
+class FallbackConfig:
+    """Fallback configuration."""
+
+    enabled: bool = True
+    chain: list[str] = field(default_factory=lambda: ["claude", "openai", "gemini"])
+    cooldown_seconds: int = 300
+
+
+@dataclass
+class ClaudeLimitsConfig:
+    """Claude limits detection configuration."""
+
+    detection_enabled: bool = True
+    slow_response_threshold_seconds: int = 30
+    auto_fallback: bool = True
+
+
+@dataclass
+class RoutingConfig:
+    """Complete routing configuration."""
+
+    enabled: bool = True
+    task_routing: dict[str, TaskRoutingRule] = field(default_factory=dict)
+    fallback: FallbackConfig = field(default_factory=FallbackConfig)
+    claude_limits: ClaudeLimitsConfig = field(default_factory=ClaudeLimitsConfig)
+    source: str = "default"  # Where config was loaded from
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any], source: str = "dict") -> RoutingConfig:
+        """Create RoutingConfig from a dictionary."""
+        routing = data.get("routing", data)  # Handle both wrapped and unwrapped
+
+        # Parse task routing
+        task_routing = {}
+        for task_type, rule in routing.get("task_routing", {}).items():
+            if isinstance(rule, dict):
+                task_routing[task_type] = TaskRoutingRule(
+                    provider=rule.get("provider", "claude"),
+                    model=rule.get("model"),
+                )
+
+        # Parse fallback config
+        fallback_data = routing.get("fallback", {})
+        fallback = FallbackConfig(
+            enabled=fallback_data.get("enabled", True),
+            chain=fallback_data.get("chain", ["claude", "openai", "gemini"]),
+            cooldown_seconds=fallback_data.get("cooldown_seconds", 300),
+        )
+
+        # Parse claude limits config
+        claude_data = routing.get("claude_limits", {})
+        claude_limits = ClaudeLimitsConfig(
+            detection_enabled=claude_data.get("detection_enabled", True),
+            slow_response_threshold_seconds=claude_data.get("slow_response_threshold_seconds", 30),
+            auto_fallback=claude_data.get("auto_fallback", True),
+        )
+
+        return cls(
+            enabled=routing.get("enabled", True),
+            task_routing=task_routing,
+            fallback=fallback,
+            claude_limits=claude_limits,
+            source=source,
+        )
+
+    def get_routing_for_task(self, task_type: str) -> TaskRoutingRule:
+        """Get routing rule for a task type, with fallback to general."""
+        if task_type in self.task_routing:
+            return self.task_routing[task_type]
+        if "general" in self.task_routing:
+            return self.task_routing["general"]
+        return TaskRoutingRule(provider="claude", model=None)
+
+
+def load_routing_config(project_path: str = ".") -> RoutingConfig:
+    """
+    Load routing config with project-local priority.
+
+    Discovery order:
+    1. .stravinsky/routing.json (project-local)
+    2. ~/.stravinsky/routing.json (user-global)
+    3. Built-in defaults
+
+    Args:
+        project_path: Path to the project root
+
+    Returns:
+        RoutingConfig instance
+    """
+    # Project-local config
+    project_config_path = Path(project_path) / ".stravinsky" / "routing.json"
+    if project_config_path.exists():
+        try:
+            data = json.loads(project_config_path.read_text())
+            config = RoutingConfig.from_dict(data, source=str(project_config_path))
+            logger.info(f"[RoutingConfig] Loaded project-local config from {project_config_path}")
+            return config
+        except Exception as e:
+            logger.warning(f"[RoutingConfig] Failed to load {project_config_path}: {e}")
+
+    # User-global fallback
+    global_config_path = Path.home() / ".stravinsky" / "routing.json"
+    if global_config_path.exists():
+        try:
+            data = json.loads(global_config_path.read_text())
+            config = RoutingConfig.from_dict(data, source=str(global_config_path))
+            logger.info(f"[RoutingConfig] Loaded user-global config from {global_config_path}")
+            return config
+        except Exception as e:
+            logger.warning(f"[RoutingConfig] Failed to load {global_config_path}: {e}")
+
+    # Built-in defaults
+    logger.info("[RoutingConfig] Using built-in defaults")
+    return RoutingConfig.from_dict(DEFAULT_ROUTING_CONFIG, source="default")
+
+
+def init_routing_config(project_path: str = ".") -> Path:
+    """
+    Initialize a project-local routing config file.
+
+    Creates .stravinsky/routing.json with default configuration.
+
+    Args:
+        project_path: Path to the project root
+
+    Returns:
+        Path to the created config file
+    """
+    config_dir = Path(project_path) / ".stravinsky"
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    config_path = config_dir / "routing.json"
+
+    if config_path.exists():
+        logger.warning(f"[RoutingConfig] Config already exists at {config_path}")
+        return config_path
+
+    config_path.write_text(json.dumps(DEFAULT_ROUTING_CONFIG, indent=2))
+    logger.info(f"[RoutingConfig] Created config at {config_path}")
+
+    return config_path
+
+
+def get_config_source(project_path: str = ".") -> str:
+    """
+    Get the source of the active routing config.
+
+    Returns:
+        Path to the config file being used, or "default" for built-in
+    """
+    project_config = Path(project_path) / ".stravinsky" / "routing.json"
+    if project_config.exists():
+        return str(project_config)
+
+    global_config = Path.home() / ".stravinsky" / "routing.json"
+    if global_config.exists():
+        return str(global_config)
+
+    return "default"