foundry-mcp 0.3.3__py3-none-any.whl → 0.8.10__py3-none-any.whl

foundry_mcp/core/providers/claude.py

@@ -14,10 +14,7 @@ import os
 import subprocess
 from typing import Any, Dict, List, Optional, Protocol, Sequence
 
-logger = logging.getLogger(__name__)
-
 from .base import (
-    ModelDescriptor,
     ProviderCapability,
     ProviderContext,
     ProviderExecutionError,
@@ -34,6 +31,8 @@ from .base import (
 from .detectors import detect_provider_availability
 from .registry import register_provider
 
+logger = logging.getLogger(__name__)
+
 DEFAULT_BINARY = "claude"
 DEFAULT_TIMEOUT_SECONDS = 360
 AVAILABILITY_OVERRIDE_ENV = "CLAUDE_CLI_AVAILABLE_OVERRIDE"
@@ -181,34 +180,11 @@ def _default_runner(
     )
 
 
-CLAUDE_MODELS: List[ModelDescriptor] = [
-    ModelDescriptor(
-        id="sonnet",
-        display_name="Sonnet 4.5",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.VISION,
-            ProviderCapability.THINKING,
-        },
-        routing_hints={"tier": "default", "description": "Smartest model for daily use"},
-    ),
-    ModelDescriptor(
-        id="haiku",
-        display_name="Haiku 4.5",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-        },
-        routing_hints={"tier": "fast", "description": "Fastest model for simple tasks"},
-    ),
-]
-
 CLAUDE_METADATA = ProviderMetadata(
     provider_id="claude",
     display_name="Anthropic Claude CLI",
-    models=CLAUDE_MODELS,
-    default_model="sonnet",
+    models=[],  # Model validation delegated to CLI
+    default_model="opus",
     capabilities={
         ProviderCapability.TEXT,
         ProviderCapability.STREAMING,
@@ -239,24 +215,7 @@ class ClaudeProvider(ProviderContext):
         self._binary = binary or os.environ.get(CUSTOM_BINARY_ENV, DEFAULT_BINARY)
         self._env = env
         self._timeout = timeout or DEFAULT_TIMEOUT_SECONDS
-        self._model = self._ensure_model(model or metadata.default_model or self._first_model_id())
-
-    def _first_model_id(self) -> str:
-        if not self.metadata.models:
-            raise ProviderUnavailableError(
-                "Claude provider metadata is missing model descriptors.",
-                provider=self.metadata.provider_id,
-            )
-        return self.metadata.models[0].id
-
-    def _ensure_model(self, candidate: str) -> str:
-        available = {descriptor.id for descriptor in self.metadata.models}
-        if candidate not in available:
-            raise ProviderExecutionError(
-                f"Unsupported Claude model '{candidate}'. Available: {', '.join(sorted(available))}",
-                provider=self.metadata.provider_id,
-            )
-        return candidate
+        self._model = model or metadata.default_model or "opus"
 
     def _validate_request(self, request: ProviderRequest) -> None:
         """Validate and normalize request, ignoring unsupported parameters."""
@@ -355,9 +314,14 @@ class ClaudeProvider(ProviderContext):
         )
 
     def _resolve_model(self, request: ProviderRequest) -> str:
+        # 1. Check request.model first (from ProviderRequest constructor)
+        if request.model:
+            return str(request.model)
+        # 2. Fallback to metadata override (legacy/alternative path)
         model_override = request.metadata.get("model") if request.metadata else None
         if model_override:
-            return self._ensure_model(str(model_override))
+            return str(model_override)
+        # 3. Fallback to instance default
         return self._model
 
     def _emit_stream_if_requested(self, content: str, *, stream: bool) -> None:
@@ -365,6 +329,36 @@ class ClaudeProvider(ProviderContext):
             return
         self._emit_stream_chunk(StreamChunk(content=content, index=0))
 
+    def _extract_error_from_json(self, stdout: str) -> Optional[str]:
+        """
+        Extract error message from Claude CLI JSON output.
+
+        Claude CLI outputs errors as JSON with is_error: true and error in 'result' field.
+        Example: {"type":"result","is_error":true,"result":"API Error: 404 {...}"}
+        """
+        if not stdout:
+            return None
+
+        try:
+            payload = json.loads(stdout.strip())
+        except json.JSONDecodeError:
+            return None
+
+        # Check for error indicator
+        if payload.get("is_error"):
+            result = payload.get("result", "")
+            if result:
+                return str(result)
+
+        # Also check for explicit error field
+        error = payload.get("error")
+        if error:
+            if isinstance(error, dict):
+                return error.get("message") or str(error)
+            return str(error)
+
+        return None
+
     def _execute(self, request: ProviderRequest) -> ProviderResult:
         self._validate_request(request)
         model = self._resolve_model(request)
@@ -375,8 +369,17 @@ class ClaudeProvider(ProviderContext):
         if completed.returncode != 0:
             stderr = (completed.stderr or "").strip()
             logger.debug(f"Claude CLI stderr: {stderr or 'no stderr'}")
+
+            # Extract error from JSON stdout (Claude outputs errors there with is_error: true)
+            json_error = self._extract_error_from_json(completed.stdout)
+
+            error_msg = f"Claude CLI exited with code {completed.returncode}"
+            if json_error:
+                error_msg += f": {json_error[:500]}"
+            elif stderr:
+                error_msg += f": {stderr[:500]}"
             raise ProviderExecutionError(
-                f"Claude CLI exited with code {completed.returncode}",
+                error_msg,
                 provider=self.metadata.provider_id,
             )
 

foundry_mcp/core/providers/codex.py

@@ -15,10 +15,7 @@ import os
 import subprocess
 from typing import Any, Dict, List, Optional, Protocol, Sequence, Tuple
 
-logger = logging.getLogger(__name__)
-
 from .base import (
-    ModelDescriptor,
     ProviderCapability,
     ProviderContext,
     ProviderExecutionError,
@@ -35,6 +32,8 @@ from .base import (
 from .detectors import detect_provider_availability
 from .registry import register_provider
 
+logger = logging.getLogger(__name__)
+
 DEFAULT_BINARY = "codex"
 DEFAULT_TIMEOUT_SECONDS = 360
 AVAILABILITY_OVERRIDE_ENV = "CODEX_CLI_AVAILABLE_OVERRIDE"
@@ -228,44 +227,11 @@ def _default_runner(
     )
 
 
-CODEX_MODELS: List[ModelDescriptor] = [
-    ModelDescriptor(
-        id="gpt-5.1-codex",
-        display_name="GPT-5.1 Codex",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.FUNCTION_CALLING,
-        },
-        routing_hints={"tier": "primary", "optimized_for": "codex"},
-    ),
-    ModelDescriptor(
-        id="gpt-5.1-codex-mini",
-        display_name="GPT-5.1 Codex Mini",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.FUNCTION_CALLING,
-        },
-        routing_hints={"tier": "fast", "optimized_for": "codex"},
-    ),
-    ModelDescriptor(
-        id="gpt-5.1",
-        display_name="GPT-5.1",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.FUNCTION_CALLING,
-        },
-        routing_hints={"tier": "general"},
-    ),
-]
-
 CODEX_METADATA = ProviderMetadata(
     provider_id="codex",
     display_name="OpenAI Codex CLI",
-    models=CODEX_MODELS,
-    default_model="gpt-5.1-codex",
+    models=[],  # Model validation delegated to CLI
+    default_model="gpt-5.2",
     capabilities={ProviderCapability.TEXT, ProviderCapability.STREAMING, ProviderCapability.FUNCTION_CALLING},
     security_flags={"writes_allowed": False, "read_only": True, "sandbox": "read-only"},
     extra={
@@ -301,7 +267,7 @@ class CodexProvider(ProviderContext):
         self._binary = binary or os.environ.get(CUSTOM_BINARY_ENV, DEFAULT_BINARY)
         self._env = self._prepare_subprocess_env(env)
         self._timeout = timeout or DEFAULT_TIMEOUT_SECONDS
-        self._model = self._ensure_model(model or metadata.default_model or self._first_model_id())
+        self._model = model or metadata.default_model or "gpt-5.2"
 
     def _prepare_subprocess_env(self, custom_env: Optional[Dict[str, str]]) -> Dict[str, str]:
         """
@@ -323,23 +289,6 @@ class CodexProvider(ProviderContext):
 
         return subprocess_env
 
-    def _first_model_id(self) -> str:
-        if not self.metadata.models:
-            raise ProviderUnavailableError(
-                "Codex provider metadata is missing model descriptors.",
-                provider=self.metadata.provider_id,
-            )
-        return self.metadata.models[0].id
-
-    def _ensure_model(self, candidate: str) -> str:
-        available = {descriptor.id for descriptor in self.metadata.models}
-        if candidate not in available:
-            raise ProviderExecutionError(
-                f"Unsupported Codex model '{candidate}'. Available: {', '.join(sorted(available))}",
-                provider=self.metadata.provider_id,
-            )
-        return candidate
-
     def _validate_request(self, request: ProviderRequest) -> None:
         """Validate and normalize request, ignoring unsupported parameters."""
         unsupported: List[str] = []
@@ -383,7 +332,8 @@ class CodexProvider(ProviderContext):
 
     def _build_command(self, model: str, prompt: str, attachments: List[str]) -> List[str]:
         # Note: codex CLI requires --json flag for JSONL output (non-interactive mode)
-        command = [self._binary, "exec", "--sandbox", "read-only", "--json"]
+        # --skip-git-repo-check allows running outside trusted git directories
+        command = [self._binary, "exec", "--sandbox", "read-only", "--skip-git-repo-check", "--json"]
         if model:
             command.extend(["-m", model])
         for path in attachments:
@@ -529,10 +479,61 @@ class CodexProvider(ProviderContext):
 
         return final_content, usage, metadata, reported_model
 
+    def _extract_error_from_jsonl(self, stdout: str) -> Optional[str]:
+        """
+        Extract error message from Codex JSONL output.
+
+        Codex CLI outputs errors as JSONL events to stdout, not stderr.
+        Look for {"type":"error"} or {"type":"turn.failed"} events.
+        """
+        if not stdout:
+            return None
+
+        errors: List[str] = []
+        for line in stdout.strip().splitlines():
+            if not line.strip():
+                continue
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            event_type = str(event.get("type", "")).lower()
+
+            # Extract from {"type":"error","message":"..."}
+            if event_type == "error":
+                msg = event.get("message", "")
+                # Skip reconnection messages, get the final error
+                if msg and not msg.startswith("Reconnecting"):
+                    errors.append(msg)
+
+            # Extract from {"type":"turn.failed","error":{"message":"..."}}
+            elif event_type == "turn.failed":
+                error_obj = event.get("error", {})
+                if isinstance(error_obj, dict):
+                    msg = error_obj.get("message", "")
+                    if msg:
+                        errors.append(msg)
+
+        # Return the last (most specific) error, or join if multiple
+        if errors:
+            # Deduplicate while preserving order
+            seen = set()
+            unique_errors = []
+            for e in errors:
+                if e not in seen:
+                    seen.add(e)
+                    unique_errors.append(e)
+            return "; ".join(unique_errors)
+        return None
+
     def _execute(self, request: ProviderRequest) -> ProviderResult:
         self._validate_request(request)
-        model = self._ensure_model(
-            str(request.metadata.get("model")) if request.metadata and "model" in request.metadata else self._model
+        # Resolve model: request.model takes precedence, then metadata, then instance default
+        model = (
+            request.model
+            or (str(request.metadata.get("model")) if request.metadata and "model" in request.metadata else None)
+            or self._model
         )
         prompt = self._build_prompt(request)
         attachments = self._normalize_attachment_paths(request)
@@ -543,8 +544,17 @@ class CodexProvider(ProviderContext):
         if completed.returncode != 0:
             stderr = (completed.stderr or "").strip()
             logger.debug(f"Codex CLI stderr: {stderr or 'no stderr'}")
+
+            # Extract error message from JSONL stdout (Codex outputs errors there, not stderr)
+            jsonl_error = self._extract_error_from_jsonl(completed.stdout)
+
+            error_msg = f"Codex CLI exited with code {completed.returncode}"
+            if jsonl_error:
+                error_msg += f": {jsonl_error[:500]}"
+            elif stderr:
+                error_msg += f": {stderr[:500]}"
             raise ProviderExecutionError(
-                f"Codex CLI exited with code {completed.returncode}",
+                error_msg,
                 provider=self.metadata.provider_id,
             )
 

foundry_mcp/core/providers/cursor_agent.py

@@ -20,7 +20,6 @@ from typing import Any, Dict, List, Optional, Protocol, Sequence, Tuple
 logger = logging.getLogger(__name__)
 
 from .base import (
-    ModelDescriptor,
     ProviderCapability,
     ProviderContext,
     ProviderExecutionError,
@@ -188,33 +187,10 @@ def _default_runner(
     )
 
 
-CURSOR_MODELS: List[ModelDescriptor] = [
-    ModelDescriptor(
-        id="composer-1",
-        display_name="Composer-1",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.FUNCTION_CALLING,
-            ProviderCapability.STREAMING,
-        },
-        routing_hints={"tier": "default"},
-    ),
-    ModelDescriptor(
-        id="gpt-5.1-codex",
-        display_name="GPT-5.1 Codex",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.FUNCTION_CALLING,
-            ProviderCapability.STREAMING,
-        },
-        routing_hints={"tier": "codex"},
-    ),
-]
-
 CURSOR_METADATA = ProviderMetadata(
     provider_id="cursor-agent",
     display_name="Cursor Agent CLI",
-    models=CURSOR_MODELS,
+    models=[],  # Model validation delegated to CLI
     default_model="composer-1",
     capabilities={ProviderCapability.TEXT, ProviderCapability.FUNCTION_CALLING, ProviderCapability.STREAMING},
     security_flags={"writes_allowed": False, "read_only": True},
@@ -246,7 +222,7 @@ class CursorAgentProvider(ProviderContext):
         self._binary = binary or os.environ.get(CUSTOM_BINARY_ENV, DEFAULT_BINARY)
         self._env = env
         self._timeout = timeout or DEFAULT_TIMEOUT_SECONDS
-        self._model = self._ensure_model(model or metadata.default_model or self._first_model_id())
+        self._model = model or metadata.default_model or "composer-1"
         self._config_backup_path: Optional[Path] = None
         self._original_config_existed: bool = False
         self._cleanup_done: bool = False
@@ -255,23 +231,6 @@ class CursorAgentProvider(ProviderContext):
         """Clean up temporary config directory on provider destruction."""
         self._cleanup_config_file()
 
-    def _first_model_id(self) -> str:
-        if not self.metadata.models:
-            raise ProviderUnavailableError(
-                "Cursor Agent metadata is missing model descriptors.",
-                provider=self.metadata.provider_id,
-            )
-        return self.metadata.models[0].id
-
-    def _ensure_model(self, candidate: str) -> str:
-        available = {descriptor.id for descriptor in self.metadata.models}
-        if candidate not in available:
-            raise ProviderExecutionError(
-                f"Unsupported Cursor Agent model '{candidate}'. Available: {', '.join(sorted(available))}",
-                provider=self.metadata.provider_id,
-            )
-        return candidate
-
     def _create_readonly_config(self) -> Path:
         """
         Backup and replace ~/.cursor/cli-config.json with read-only permissions.
@@ -478,16 +437,32 @@ class CursorAgentProvider(ProviderContext):
                 return retry_process, False
 
             stderr_text = (retry_process.stderr or stderr_text).strip()
+            # Cursor Agent outputs errors to stdout as plain text, not stderr
+            stdout_text = (retry_process.stdout or "").strip()
             logger.debug(f"Cursor Agent CLI stderr (retry): {stderr_text or 'no stderr'}")
+            error_msg = f"Cursor Agent CLI exited with code {retry_process.returncode}"
+            if stdout_text and not stdout_text.startswith("{"):
+                # Plain text error in stdout (not JSON response)
+                error_msg += f": {stdout_text[:500]}"
+            elif stderr_text:
+                error_msg += f": {stderr_text[:500]}"
             raise ProviderExecutionError(
-                f"Cursor Agent CLI exited with code {retry_process.returncode}",
+                error_msg,
                 provider=self.metadata.provider_id,
             )
 
         stderr_text = (completed.stderr or "").strip()
+        # Cursor Agent outputs errors to stdout as plain text, not stderr
+        stdout_text = (completed.stdout or "").strip()
         logger.debug(f"Cursor Agent CLI stderr: {stderr_text or 'no stderr'}")
+        error_msg = f"Cursor Agent CLI exited with code {completed.returncode}"
+        if stdout_text and not stdout_text.startswith("{"):
+            # Plain text error in stdout (not JSON response)
+            error_msg += f": {stdout_text[:500]}"
+        elif stderr_text:
+            error_msg += f": {stderr_text[:500]}"
         raise ProviderExecutionError(
-            f"Cursor Agent CLI exited with code {completed.returncode}",
+            error_msg,
             provider=self.metadata.provider_id,
         )
 
@@ -533,8 +508,11 @@ class CursorAgentProvider(ProviderContext):
                 provider=self.metadata.provider_id,
             )
 
-        model = self._ensure_model(
-            str(request.metadata.get("model")) if request.metadata and "model" in request.metadata else self._model
+        # Resolve model: request.model takes precedence, then metadata, then instance default
+        model = (
+            request.model
+            or (str(request.metadata.get("model")) if request.metadata and "model" in request.metadata else None)
+            or self._model
         )
 
         # Backup and replace HOME config with read-only version

foundry_mcp/core/providers/detectors.py

@@ -31,11 +31,23 @@ import logging
 import os
 import shutil
 import subprocess
+import time
 from dataclasses import dataclass, field
-from typing import Dict, Iterable, Optional, Sequence
+from typing import Dict, Iterable, Optional, Sequence, Tuple
 
 logger = logging.getLogger(__name__)
 
+# Cache for provider availability: {provider_id: (is_available, timestamp)}
+_AVAILABILITY_CACHE: Dict[str, Tuple[bool, float]] = {}
+
+def _get_cache_ttl() -> float:
+    """Get cache TTL from config or default to 3600s."""
+    try:
+        from foundry_mcp.config import get_config
+        return float(get_config().providers.get("availability_cache_ttl", 3600))
+    except Exception:
+        return 3600.0
+
 # Environment variable for test mode (bypasses real CLI probes)
 _TEST_MODE_ENV = "FOUNDRY_PROVIDER_TEST_MODE"
 
@@ -173,13 +185,14 @@ class ProviderDetector:
 
     def is_available(self, *, use_probe: bool = True) -> bool:
         """
-        Check whether this provider is available.
+        Check whether this provider is available (with caching).
 
         Resolution order:
-        1. Check override_env (if set, returns its boolean value)
+        1. Check override_env (if set, returns its boolean value - takes precedence)
         2. In test mode, return False (no real CLI available)
-        3. Resolve binary via PATH
-        4. Optionally run health probe
+        3. Check cache (if valid)
+        4. Resolve binary via PATH
+        5. Optionally run health probe
 
         Args:
             use_probe: When True, run health probe after finding binary.
@@ -188,7 +201,7 @@ class ProviderDetector:
         Returns:
             True if provider is available, False otherwise
         """
-        # Check environment override first
+        # Check environment override first (takes precedence over cache)
         if self.override_env:
             override = _coerce_bool(os.environ.get(self.override_env))
             if override is not None:
@@ -207,6 +220,14 @@ class ProviderDetector:
             )
             return False
 
+        # Check cache (only for non-overridden, non-test-mode cases)
+        cache_key = f"{self.provider_id}:{use_probe}"
+        cached = _AVAILABILITY_CACHE.get(cache_key)
+        if cached is not None:
+            is_avail, cached_time = cached
+            if time.time() - cached_time < _get_cache_ttl():
+                return is_avail
+
         # Resolve binary path
         executable = self.resolve_binary()
         if not executable:
@@ -214,14 +235,18 @@ class ProviderDetector:
                 "Provider '%s' unavailable (binary not found in PATH)",
                 self.provider_id,
             )
+            _AVAILABILITY_CACHE[cache_key] = (False, time.time())
             return False
 
         # Skip probe if not requested
         if not use_probe:
+            _AVAILABILITY_CACHE[cache_key] = (True, time.time())
             return True
 
         # Run health probe
-        return self._run_probe(executable)
+        result = self._run_probe(executable)
+        _AVAILABILITY_CACHE[cache_key] = (result, time.time())
+        return result
 
     def get_unavailability_reason(self, *, use_probe: bool = True) -> Optional[str]:
         """
@@ -468,7 +493,9 @@ def reset_detectors() -> None:
     Reset detectors to the default set.
 
     Primarily used by tests to restore a clean state.
+    Also clears the availability cache to ensure fresh detection.
     """
+    _AVAILABILITY_CACHE.clear()
     _reset_default_detectors()