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

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"

mcp_bridge/routing/model_tiers.py

@@ -0,0 +1,135 @@
+"""Model tier definitions and cross-provider fallback planning.
+
+This module centralizes a simple, two-tier model architecture and provides
+a deterministic fallback chain when an OAuth call fails or is unavailable.
+
+The fallback chain is ordered to prefer:
+1) Same-tier OAuth models on *other* providers
+2) Lower-tier OAuth models (if available)
+3) Same-tier models via API key auth
+
+The boolean in the returned tuples indicates whether OAuth should be used.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Final
+
+
+class ModelTier(str, Enum):
+    PREMIUM = "premium"
+    STANDARD = "standard"
+
+
+@dataclass(frozen=True)
+class TierModel:
+    model: str
+    thinking: bool
+
+
+KNOWN_PROVIDERS: Final[tuple[str, ...]] = ("claude", "openai", "gemini")
+
+# Provider preference order mirrors existing routing fallback chains.
+PROVIDER_FALLBACK_ORDER: Final[dict[str, list[str]]] = {
+    "claude": ["openai", "gemini"],
+    "openai": ["gemini", "claude"],
+    "gemini": ["openai", "claude"],
+}
+
+# Ordered best -> worst.
+TIER_ORDER: Final[tuple[ModelTier, ...]] = (ModelTier.PREMIUM, ModelTier.STANDARD)
+
+MODEL_TIERS: Final[dict[ModelTier, dict[str, TierModel]]] = {
+    ModelTier.PREMIUM: {
+        "claude": TierModel(model="claude-4.5-opus", thinking=True),
+        "openai": TierModel(model="gpt-5.2-codex", thinking=False),
+        "gemini": TierModel(model="gemini-3-pro", thinking=False),
+    },
+    ModelTier.STANDARD: {
+        "claude": TierModel(model="claude-4.5-sonnet", thinking=False),
+        "openai": TierModel(model="gpt-5.2", thinking=False),
+        "gemini": TierModel(model="gemini-3-flash-preview", thinking=False),
+    },
+}
+
+
+def _require_known_provider(provider: str) -> None:
+    if provider not in KNOWN_PROVIDERS:
+        raise ValueError(f"Unknown provider: {provider!r}. Expected one of {KNOWN_PROVIDERS!r}.")
+
+
+def _tier_for(provider: str, model: str) -> ModelTier:
+    _require_known_provider(provider)
+
+    for tier, tier_models in MODEL_TIERS.items():
+        spec = tier_models.get(provider)
+        if spec and spec.model == model:
+            return tier
+
+    raise ValueError(
+        f"Unknown model for provider {provider!r}: {model!r}. "
+        "Expected a model present in MODEL_TIERS."
+    )
+
+
+def _providers_other_first(provider: str) -> list[str]:
+    _require_known_provider(provider)
+    preferred = PROVIDER_FALLBACK_ORDER.get(provider)
+    if preferred is not None:
+        return [p for p in preferred if p != provider]
+    return [p for p in KNOWN_PROVIDERS if p != provider]
+
+
+def _lower_tiers(tier: ModelTier) -> list[ModelTier]:
+    try:
+        idx = TIER_ORDER.index(tier)
+    except ValueError:
+        return []
+    return list(TIER_ORDER[idx + 1 :])
+
+
+def get_oauth_fallback_chain(provider: str, model: str) -> list[tuple[str, str, bool]]:
+    """Return ordered (provider, model, use_oauth) fallbacks.
+
+    Args:
+        provider: Current provider (e.g. "openai")
+        model: Current model identifier within that provider
+
+    Returns:
+        A list of candidate (provider, model, use_oauth) tuples.
+
+    Ordering rules:
+        - Same-tier models on OTHER providers first (OAuth)
+        - Then lower-tier models (OAuth)
+        - Then same-tier models via API key (non-OAuth)
+    """
+
+    tier = _tier_for(provider, model)
+    other_providers = _providers_other_first(provider)
+
+    chain: list[tuple[str, str, bool]] = []
+    seen: set[tuple[str, str, bool]] = set()
+
+    def add(p: str, m: str, use_oauth: bool) -> None:
+        item = (p, m, use_oauth)
+        if item in seen:
+            return
+        seen.add(item)
+        chain.append(item)
+
+    # 1) Same tier, other providers, OAuth first.
+    for p in other_providers:
+        add(p, MODEL_TIERS[tier][p].model, True)
+
+    # 2) Lower tiers, OAuth.
+    for lower in _lower_tiers(tier):
+        for p in [*other_providers, provider]:
+            add(p, MODEL_TIERS[lower][p].model, True)
+
+    # 3) Same tier, API key (non-OAuth).
+    for p in [provider, *other_providers]:
+        add(p, MODEL_TIERS[tier][p].model, False)
+
+    return chain