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

foundry_mcp/core/discovery.py

@@ -385,7 +385,7 @@ class ServerCapabilities:
     max_batch_size: int = 100
     rate_limit_headers: bool = True
     supported_formats: List[str] = field(default_factory=lambda: ["json"])
-    feature_flags_enabled: bool = True
+    feature_flags_enabled: bool = False
 
     def to_dict(self) -> Dict[str, Any]:
         """

foundry_mcp/core/llm_config.py

@@ -163,6 +163,14 @@ class ProviderSpec:
             "[api]provider/model or [cli]transport[:backend/model|:model]"
         )
 
+    @classmethod
+    def parse_flexible(cls, spec: str) -> "ProviderSpec":
+        """Parse with fallback for simple provider IDs."""
+        spec = spec.strip()
+        if spec.startswith("["):
+            return cls.parse(spec)
+        return cls(type="cli", provider=spec.lower(), raw=spec)
+
     def validate(self) -> List[str]:
         """Validate the provider specification.
 

foundry_mcp/core/naming.py

@@ -4,17 +4,34 @@ from __future__ import annotations
 
 import asyncio
 import functools
+import json
 import logging
 import time
 from typing import Any, Callable
 
 from mcp.server.fastmcp import FastMCP
+from mcp.types import TextContent
 
 from foundry_mcp.core.observability import mcp_tool
 
 logger = logging.getLogger(__name__)
 
 
+def _minify_response(result: dict[str, Any]) -> TextContent:
+    """Convert dict to TextContent with minified JSON.
+
+    Args:
+        result: Dictionary to serialize
+
+    Returns:
+        TextContent with minified JSON string
+    """
+    return TextContent(
+        type="text",
+        text=json.dumps(result, separators=(",", ":"), default=str),
+    )
+
+
 def canonical_tool(
     mcp: FastMCP,
     *,
@@ -45,7 +62,10 @@ def canonical_tool(
                 """Async wrapper for async underlying functions."""
                 start_time = time.perf_counter()
                 try:
-                    return await func(*args, **kwargs)
+                    result = await func(*args, **kwargs)
+                    if isinstance(result, dict):
+                        return _minify_response(result)
+                    return result
                 except Exception as e:
                     duration_ms = (time.perf_counter() - start_time) * 1000
                     _collect_tool_error(
@@ -64,7 +84,10 @@ def canonical_tool(
                 """Sync wrapper for sync underlying functions."""
                 start_time = time.perf_counter()
                 try:
-                    return func(*args, **kwargs)
+                    result = func(*args, **kwargs)
+                    if isinstance(result, dict):
+                        return _minify_response(result)
+                    return result
                 except Exception as e:
                     duration_ms = (time.perf_counter() - start_time) * 1000
                     _collect_tool_error(

foundry_mcp/core/prometheus.py

@@ -159,7 +159,6 @@ class PrometheusExporter:
         # Manifest/discovery metrics
         self._manifest_tokens: Any = None
         self._manifest_tool_count: Any = None
-        self._feature_flag_state: Any = None
 
         # Health check metrics
         self._health_status: Any = None
@@ -236,11 +235,6 @@ class PrometheusExporter:
                 "Tool count for the advertised tool manifest",
                 ["manifest"],  # unified|legacy
             )
-            self._feature_flag_state = Gauge(
-                f"{ns}_feature_flag_state",
-                "Feature flag state (1=enabled, 0=disabled)",
-                ["flag"],
-            )
 
             # Health check metrics
             self._health_status = Gauge(
@@ -396,13 +390,6 @@ class PrometheusExporter:
         self._manifest_tokens.labels(manifest=manifest_label).set(int(tokens))
         self._manifest_tool_count.labels(manifest=manifest_label).set(int(tool_count))
 
-    def record_feature_flag_state(self, flag: str, enabled: bool) -> None:
-        """Record feature flag enabled/disabled state."""
-        if not self.is_enabled():
-            return
-
-        self._feature_flag_state.labels(flag=flag).set(1 if enabled else 0)
-
     # -------------------------------------------------------------------------
     # Health Check Metrics
     # -------------------------------------------------------------------------

foundry_mcp/core/providers/__init__.py

@@ -56,6 +56,7 @@ from foundry_mcp.core.providers.base import (
     ProviderUnavailableError,
     ProviderExecutionError,
     ProviderTimeoutError,
+    ContextWindowError,
     # ABC
     ProviderContext,
 )
@@ -124,6 +125,11 @@ from foundry_mcp.core.providers.validation import (
     reset_rate_limiters,
     # Execution wrapper
     with_validation_and_resilience,
+    # Context window detection
+    CONTEXT_WINDOW_ERROR_PATTERNS,
+    is_context_window_error,
+    extract_token_counts,
+    create_context_window_guidance,
 )
 
 # ---------------------------------------------------------------------------
@@ -160,6 +166,7 @@ __all__ = [
     "ProviderUnavailableError",
     "ProviderExecutionError",
     "ProviderTimeoutError",
+    "ContextWindowError",
     # ABC
     "ProviderContext",
     # === Detection (detectors.py) ===
@@ -222,4 +229,9 @@ __all__ = [
     "reset_rate_limiters",
     # Execution wrapper
     "with_validation_and_resilience",
+    # Context window detection
+    "CONTEXT_WINDOW_ERROR_PATTERNS",
+    "is_context_window_error",
+    "extract_token_counts",
+    "create_context_window_guidance",
 ]

foundry_mcp/core/providers/base.py

@@ -277,6 +277,44 @@ class ProviderTimeoutError(ProviderError):
     """Raised when a provider exceeds its allotted execution time."""
 
 
+class ContextWindowError(ProviderExecutionError):
+    """Raised when prompt exceeds the model's context window limit.
+
+    This error indicates the prompt/context size exceeded what the model
+    can process. It includes token counts to help with debugging and
+    provides actionable guidance for resolution.
+
+    Attributes:
+        prompt_tokens: Estimated tokens in the prompt (if known)
+        max_tokens: Maximum context window size (if known)
+        provider: Provider that raised the error
+        truncation_needed: How many tokens need to be removed
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        provider: Optional[str] = None,
+        prompt_tokens: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+    ):
+        """Initialize context window error.
+
+        Args:
+            message: Error message describing the issue
+            provider: Provider ID that raised the error
+            prompt_tokens: Number of tokens in the prompt (if known)
+            max_tokens: Maximum tokens allowed (if known)
+        """
+        super().__init__(message, provider=provider)
+        self.prompt_tokens = prompt_tokens
+        self.max_tokens = max_tokens
+        self.truncation_needed = (
+            (prompt_tokens - max_tokens) if prompt_tokens and max_tokens else None
+        )
+
+
 # =============================================================================
 # Lifecycle Hooks
 # =============================================================================
@@ -471,6 +509,7 @@ __all__ = [
     "ProviderUnavailableError",
     "ProviderExecutionError",
     "ProviderTimeoutError",
+    "ContextWindowError",
     # ABC
     "ProviderContext",
 ]

foundry_mcp/core/providers/claude.py

@@ -314,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 str(model_override)
+        # 3. Fallback to instance default
         return self._model
 
     def _emit_stream_if_requested(self, content: str, *, stream: bool) -> None:
@@ -324,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)
@@ -334,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

@@ -332,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:
@@ -478,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)
+        # Resolve model: request.model takes precedence, then metadata, then instance default
         model = (
-            str(request.metadata.get("model")) if request.metadata and "model" in request.metadata else self._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)
@@ -492,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

@@ -437,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,
         )
 
@@ -492,8 +508,11 @@ class CursorAgentProvider(ProviderContext):
                 provider=self.metadata.provider_id,
             )
 
+        # Resolve model: request.model takes precedence, then metadata, then instance default
         model = (
-            str(request.metadata.get("model")) if request.metadata and "model" in request.metadata else self._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()
 
 

foundry_mcp/core/providers/gemini.py

@@ -252,9 +252,14 @@ class GeminiProvider(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 str(model_override)
+        # 3. Fallback to instance default
         return self._model
 
     def _emit_stream_if_requested(self, content: str, *, stream: bool) -> None:
@@ -262,6 +267,54 @@ class GeminiProvider(ProviderContext):
             return
         self._emit_stream_chunk(StreamChunk(content=content, index=0))
 
+    def _extract_error_from_output(self, stdout: str) -> Optional[str]:
+        """
+        Extract error message from Gemini CLI output.
+
+        Gemini CLI outputs errors as text lines followed by JSON. Example:
+        'Error when talking to Gemini API Full report available at: /tmp/...
+        {"error": {"type": "Error", "message": "[object Object]", "code": 1}}'
+
+        The JSON message field is often unhelpful ("[object Object]"), so we
+        prefer the text prefix which contains the actual error description.
+        """
+        if not stdout:
+            return None
+
+        lines = stdout.strip().split("\n")
+        error_parts: List[str] = []
+
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+
+            # Skip "Loaded cached credentials" info line
+            if line.startswith("Loaded cached"):
+                continue
+
+            # Try to parse as JSON
+            if line.startswith("{"):
+                try:
+                    payload = json.loads(line)
+                    error = payload.get("error", {})
+                    if isinstance(error, dict):
+                        msg = error.get("message", "")
+                        # Skip unhelpful "[object Object]" message
+                        if msg and msg != "[object Object]":
+                            error_parts.append(msg)
+                except json.JSONDecodeError:
+                    pass
+            else:
+                # Text line - likely contains the actual error message
+                # Extract the part before "Full report available at:"
+                if "Full report available at:" in line:
+                    line = line.split("Full report available at:")[0].strip()
+                if line:
+                    error_parts.append(line)
+
+        return "; ".join(error_parts) if error_parts else None
+
     def _execute(self, request: ProviderRequest) -> ProviderResult:
         self._validate_request(request)
         model = self._resolve_model(request)
@@ -273,8 +326,17 @@ class GeminiProvider(ProviderContext):
         if completed.returncode != 0:
             stderr = (completed.stderr or "").strip()
             logger.debug(f"Gemini CLI stderr: {stderr or 'no stderr'}")
+
+            # Extract error from stdout (Gemini outputs errors as text + JSON)
+            stdout_error = self._extract_error_from_output(completed.stdout)
+
+            error_msg = f"Gemini CLI exited with code {completed.returncode}"
+            if stdout_error:
+                error_msg += f": {stdout_error[:500]}"
+            elif stderr:
+                error_msg += f": {stderr[:500]}"
             raise ProviderExecutionError(
-                f"Gemini CLI exited with code {completed.returncode}",
+                error_msg,
                 provider=self.metadata.provider_id,
             )