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

foundry_mcp/core/providers/gemini.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 = "gemini"
 DEFAULT_TIMEOUT_SECONDS = 360
 AVAILABILITY_OVERRIDE_ENV = "GEMINI_CLI_AVAILABLE_OVERRIDE"
@@ -137,44 +136,11 @@ def _default_runner(
     )
 
 
-GEMINI_MODELS: List[ModelDescriptor] = [
-    ModelDescriptor(
-        id="pro",
-        display_name="Gemini 3.0 Pro",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.VISION,
-        },
-        routing_hints={"tier": "pro", "context_window": "1M"},
-    ),
-    ModelDescriptor(
-        id="gemini-2.5-pro",
-        display_name="Gemini 2.5 Pro",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.VISION,
-        },
-        routing_hints={"tier": "pro", "context_window": "1M"},
-    ),
-    ModelDescriptor(
-        id="gemini-2.5-flash",
-        display_name="Gemini 2.5 Flash",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-            ProviderCapability.VISION,
-        },
-        routing_hints={"tier": "flash"},
-    ),
-]
-
 GEMINI_METADATA = ProviderMetadata(
     provider_id="gemini",
     display_name="Google Gemini CLI",
-    models=GEMINI_MODELS,
-    default_model="gemini-2.5-flash",
+    models=[],  # Model validation delegated to CLI
+    default_model="pro",
     capabilities={ProviderCapability.TEXT, ProviderCapability.STREAMING, ProviderCapability.VISION},
     security_flags={"writes_allowed": False},
     extra={"cli": "gemini", "output_format": "json"},
@@ -200,24 +166,7 @@ class GeminiProvider(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(
-                "Gemini 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 Gemini model '{candidate}'. Available: {', '.join(sorted(available))}",
-                provider=self.metadata.provider_id,
-            )
-        return candidate
+        self._model = model or metadata.default_model or "pro"
 
     def _validate_request(self, request: ProviderRequest) -> None:
         """Validate and normalize request, ignoring unsupported parameters."""
@@ -303,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 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:
@@ -313,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)
@@ -324,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,
             )
 

foundry_mcp/core/providers/opencode.py

@@ -18,10 +18,7 @@ import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Protocol, Sequence
 
-logger = logging.getLogger(__name__)
-
 from .base import (
-    ModelDescriptor,
     ProviderCapability,
     ProviderContext,
     ProviderExecutionError,
@@ -38,6 +35,8 @@ from .base import (
 from .detectors import detect_provider_availability
 from .registry import register_provider
 
+logger = logging.getLogger(__name__)
+
 DEFAULT_BINARY = "node"
 DEFAULT_WRAPPER_SCRIPT = Path(__file__).parent / "opencode_wrapper.js"
 DEFAULT_TIMEOUT_SECONDS = 360
@@ -122,26 +121,10 @@ def _default_runner(
     )
 
 
-OPENCODE_MODELS: List[ModelDescriptor] = [
-    ModelDescriptor(
-        id="openai/gpt-5.1-codex-mini",
-        display_name="OpenAI GPT-5.1 Codex Mini (via OpenCode)",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-        },
-        routing_hints={
-            "configurable": True,
-            "source": "opencode config",
-            "note": "Accepts any model ID - validated by opencode CLI",
-        },
-    ),
-]
-
 OPENCODE_METADATA = ProviderMetadata(
     provider_id="opencode",
     display_name="OpenCode AI SDK",
-    models=OPENCODE_MODELS,
+    models=[],  # Model validation delegated to CLI
     default_model="openai/gpt-5.1-codex-mini",
     capabilities={ProviderCapability.TEXT, ProviderCapability.STREAMING},
     security_flags={"writes_allowed": False, "read_only": True},
@@ -180,8 +163,17 @@ class OpenCodeProvider(ProviderContext):
         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._server_process: Optional[subprocess.Popen[str]] = None
+
+        # Validate model - reject empty or whitespace-only strings
+        effective_model = model or metadata.default_model or "openai/gpt-5.1-codex-mini"
+        if not effective_model or not effective_model.strip():
+            raise ProviderExecutionError(
+                "Model identifier cannot be empty",
+                provider="opencode",
+            )
+        self._model = effective_model
+
+        self._server_process: Optional[subprocess.Popen[bytes]] = None
         self._config_file_path: Optional[Path] = None
 
     def __del__(self) -> None:
@@ -205,7 +197,9 @@ class OpenCodeProvider(ProviderContext):
         # Clean up config file
         self._cleanup_config_file()
 
-    def _prepare_subprocess_env(self, custom_env: Optional[Dict[str, str]]) -> Dict[str, str]:
+    def _prepare_subprocess_env(
+        self, custom_env: Optional[Dict[str, str]]
+    ) -> Dict[str, str]:
         """
         Prepare environment variables for subprocess execution.
 
@@ -226,8 +220,51 @@ class OpenCodeProvider(ProviderContext):
         # Note: OPENCODE_API_KEY should be provided via environment or custom_env
         # We don't set a default value for security reasons
 
+        # Add global npm modules to NODE_PATH so wrapper can find @opencode-ai/sdk
+        # This allows the SDK to be installed globally rather than bundled
+        self._ensure_node_path(subprocess_env)
+
         return subprocess_env
 
+    def _ensure_node_path(self, env: Dict[str, str]) -> None:
+        """
+        Ensure NODE_PATH includes global npm modules and local node_modules.
+
+        This allows the wrapper script to import @opencode-ai/sdk whether it's
+        installed globally (npm install -g @opencode-ai/sdk) or locally in the
+        providers directory.
+        """
+        node_paths: List[str] = []
+
+        # Add existing NODE_PATH entries
+        if env.get("NODE_PATH"):
+            node_paths.extend(env["NODE_PATH"].split(os.pathsep))
+
+        # Add local node_modules (alongside wrapper script)
+        local_node_modules = self._wrapper_path.parent / "node_modules"
+        if local_node_modules.exists():
+            node_paths.append(str(local_node_modules))
+
+        # Detect and add global npm root
+        try:
+            result = subprocess.run(
+                ["npm", "root", "-g"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                global_root = result.stdout.strip()
+                if global_root not in node_paths:
+                    node_paths.append(global_root)
+        except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+            # npm not available or timed out - skip global path
+            pass
+
+        if node_paths:
+            env["NODE_PATH"] = os.pathsep.join(node_paths)
+
     def _create_readonly_config(self) -> Path:
         """
         Create temporary opencode.json with read-only tool restrictions.
@@ -267,27 +304,6 @@ class OpenCodeProvider(ProviderContext):
             finally:
                 self._config_file_path = None
 
-    def _first_model_id(self) -> str:
-        if not self.metadata.models:
-            raise ProviderUnavailableError(
-                "OpenCode provider metadata is missing model descriptors.",
-                provider=self.metadata.provider_id,
-            )
-        return self.metadata.models[0].id
-
-    def _ensure_model(self, candidate: str) -> str:
-        # Validate that the model is not empty
-        if not candidate or not candidate.strip():
-            raise ProviderExecutionError(
-                "Model identifier cannot be empty",
-                provider=self.metadata.provider_id,
-            )
-
-        # For opencode, we accept any model ID and let opencode CLI validate it
-        # This avoids maintaining a hardcoded list that would become stale
-        # opencode CLI supports many models across providers (OpenAI, Anthropic, etc.)
-        return candidate
-
     def _is_port_open(self, port: int, host: str = "localhost") -> bool:
         """Check if a TCP port is open and accepting connections."""
         try:
@@ -407,10 +423,15 @@ class OpenCodeProvider(ProviderContext):
         return request.prompt
 
     def _resolve_model(self, request: ProviderRequest) -> str:
-        """Resolve model from request metadata or use default."""
+        """Resolve model from request or use default."""
+        # 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:
@@ -419,6 +440,30 @@ class OpenCodeProvider(ProviderContext):
             return
         self._emit_stream_chunk(StreamChunk(content=content, index=0))
 
+    def _extract_error_from_jsonl(self, stdout: str) -> Optional[str]:
+        """
+        Extract error message from OpenCode wrapper JSONL output.
+
+        The wrapper outputs errors as {"type":"error","code":"...","message":"..."}.
+        """
+        if not stdout:
+            return None
+
+        for line in stdout.strip().split("\n"):
+            if not line.strip():
+                continue
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if event.get("type") == "error":
+                msg = event.get("message", "")
+                if msg:
+                    return msg
+
+        return None
+
     def _execute(self, request: ProviderRequest) -> ProviderResult:
         """Execute generation request via OpenCode wrapper."""
         self._validate_request(request)
@@ -467,8 +512,17 @@ class OpenCodeProvider(ProviderContext):
         if completed.returncode != 0:
             stderr = (completed.stderr or "").strip()
             logger.debug(f"OpenCode wrapper stderr: {stderr or 'no stderr'}")
+
+            # Extract error from JSONL stdout (wrapper outputs {"type":"error","message":"..."})
+            jsonl_error = self._extract_error_from_jsonl(completed.stdout)
+
+            error_msg = f"OpenCode wrapper exited with code {completed.returncode}"
+            if jsonl_error:
+                error_msg += f": {jsonl_error[:500]}"
+            elif stderr:
+                error_msg += f": {stderr[:500]}"
             raise ProviderExecutionError(
-                f"OpenCode wrapper exited with code {completed.returncode}",
+                error_msg,
                 provider=self.metadata.provider_id,
             )
 

foundry_mcp/core/providers/package-lock.json

@@ -9,16 +9,16 @@
       "version": "0.1.0",
       "license": "MIT",
       "dependencies": {
-        "@opencode-ai/sdk": "^1.0.0"
+        "@opencode-ai/sdk": "^1.0.218"
       },
       "engines": {
         "node": ">=18.0.0"
       }
     },
     "node_modules/@opencode-ai/sdk": {
-      "version": "1.0.164",
-      "resolved": "https://registry.npmjs.org/@opencode-ai/sdk/-/sdk-1.0.164.tgz",
-      "integrity": "sha512-TG+bpgL3O4tU/vCOT0THaSL5wJoXc15ErS79NLrEzFj1Igq1a9Mhef3oYZae0zZOI/ZTl/VNswguUeqkBm41pg=="
+      "version": "1.0.218",
+      "resolved": "https://registry.npmjs.org/@opencode-ai/sdk/-/sdk-1.0.218.tgz",
+      "integrity": "sha512-c6ss6UPAMskSVQUecuhNvPLFngyVh2Os9o0kpVjoqJJ16HXhzjVSk5axgh3ueQrfP5aZfg5o6l6srmjuCTPNnQ=="
     }
   }
 }

foundry_mcp/core/providers/package.json

@@ -17,7 +17,7 @@
   "author": "Foundry MCP",
   "license": "MIT",
   "dependencies": {
-    "@opencode-ai/sdk": "^1.0.0"
+    "@opencode-ai/sdk": "^1.0.218"
   },
   "engines": {
     "node": ">=18.0.0"

foundry_mcp/core/providers/validation.py

@@ -696,6 +696,129 @@ def with_validation_and_resilience(
     return decorator
 
 
+# ---------------------------------------------------------------------------
+# Context Window Error Detection
+# ---------------------------------------------------------------------------
+
+# Common error patterns indicating context window/token limit exceeded
+CONTEXT_WINDOW_ERROR_PATTERNS: Set[str] = {
+    # OpenAI patterns
+    "context_length_exceeded",
+    "maximum context length",
+    "max_tokens",
+    "token limit",
+    "tokens exceeds",
+    "prompt is too long",
+    "input too long",
+    # Anthropic patterns
+    "prompt is too large",
+    "context window",
+    "exceeds the maximum",
+    "too many tokens",
+    # Google/Gemini patterns
+    "max input tokens",
+    "input token limit",
+    "content is too long",
+    "request payload size exceeds",
+    # Generic patterns
+    "length exceeded",
+    "limit exceeded",
+    "too long for model",
+    "input exceeds",
+    "context limit",
+}
+
+
+def is_context_window_error(error: Exception) -> bool:
+    """Check if an exception indicates a context window/token limit error.
+
+    Examines the error message for common patterns indicating the prompt
+    exceeded the model's context window or token limit.
+
+    Args:
+        error: Exception to check
+
+    Returns:
+        True if the error appears to be a context window error
+    """
+    error_str = str(error).lower()
+
+    for pattern in CONTEXT_WINDOW_ERROR_PATTERNS:
+        if pattern in error_str:
+            return True
+
+    return False
+
+
+def extract_token_counts(error_str: str) -> tuple[Optional[int], Optional[int]]:
+    """Extract token counts from error message if present.
+
+    Attempts to parse prompt_tokens and max_tokens from common error formats.
+
+    Args:
+        error_str: Error message string
+
+    Returns:
+        Tuple of (prompt_tokens, max_tokens), either may be None if not found
+    """
+    import re
+
+    prompt_tokens = None
+    max_tokens = None
+
+    # Pattern: "X tokens exceeds Y limit" or "X exceeds Y"
+    match = re.search(r"(\d{1,7})\s*tokens?\s*exceeds?\s*(?:the\s*)?(\d{1,7})", error_str.lower())
+    if match:
+        prompt_tokens = int(match.group(1))
+        max_tokens = int(match.group(2))
+        return prompt_tokens, max_tokens
+
+    # Pattern: "maximum context length is X tokens" with "Y tokens" input
+    max_match = re.search(r"maximum\s+(?:context\s+)?length\s+(?:is\s+)?(\d{1,7})", error_str.lower())
+    if max_match:
+        max_tokens = int(max_match.group(1))
+
+    # Pattern: "requested X tokens" or "contains X tokens"
+    prompt_match = re.search(r"(?:requested|contains|have|with)\s+(\d{1,7})\s*tokens?", error_str.lower())
+    if prompt_match:
+        prompt_tokens = int(prompt_match.group(1))
+
+    return prompt_tokens, max_tokens
+
+
+def create_context_window_guidance(
+    prompt_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    provider_id: Optional[str] = None,
+) -> str:
+    """Generate actionable guidance for resolving context window errors.
+
+    Args:
+        prompt_tokens: Number of tokens in the prompt (if known)
+        max_tokens: Maximum tokens allowed (if known)
+        provider_id: Provider that raised the error
+
+    Returns:
+        Human-readable guidance string
+    """
+    parts = ["Context window limit exceeded."]
+
+    if prompt_tokens and max_tokens:
+        overflow = prompt_tokens - max_tokens
+        parts.append(f"Prompt ({prompt_tokens:,} tokens) exceeds limit ({max_tokens:,} tokens) by {overflow:,} tokens.")
+    elif prompt_tokens:
+        parts.append(f"Prompt contains approximately {prompt_tokens:,} tokens.")
+    elif max_tokens:
+        parts.append(f"Maximum context window is {max_tokens:,} tokens.")
+
+    parts.append("To resolve: (1) Reduce input size by excluding large content, "
+                 "(2) Summarize or truncate long sections, "
+                 "(3) Use a model with larger context window, "
+                 "(4) Process content in smaller batches.")
+
+    return " ".join(parts)
+
+
 __all__ = [
     # Validation
     "ValidationError",
@@ -726,4 +849,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/research/__init__.py

@@ -0,0 +1,68 @@
+"""Research workflows for multi-model orchestration.
+
+This package provides conversation threading, multi-model consensus,
+hypothesis-driven investigation, and creative brainstorming workflows.
+"""
+
+from foundry_mcp.core.research.models import (
+    ConfidenceLevel,
+    ConsensusConfig,
+    ConsensusState,
+    ConsensusStrategy,
+    ConversationMessage,
+    ConversationThread,
+    Hypothesis,
+    Idea,
+    IdeaCluster,
+    IdeationPhase,
+    IdeationState,
+    InvestigationStep,
+    ModelResponse,
+    ThreadStatus,
+    ThinkDeepState,
+    WorkflowType,
+)
+from foundry_mcp.core.research.memory import (
+    FileStorageBackend,
+    ResearchMemory,
+)
+from foundry_mcp.core.research.workflows import (
+    ChatWorkflow,
+    ConsensusWorkflow,
+    IdeateWorkflow,
+    ResearchWorkflowBase,
+    ThinkDeepWorkflow,
+)
+
+__all__ = [
+    # Enums
+    "WorkflowType",
+    "ConfidenceLevel",
+    "ConsensusStrategy",
+    "ThreadStatus",
+    "IdeationPhase",
+    # Conversation models
+    "ConversationMessage",
+    "ConversationThread",
+    # THINKDEEP models
+    "Hypothesis",
+    "InvestigationStep",
+    "ThinkDeepState",
+    # IDEATE models
+    "Idea",
+    "IdeaCluster",
+    "IdeationState",
+    # CONSENSUS models
+    "ModelResponse",
+    "ConsensusConfig",
+    "ConsensusState",
+    # Storage
+    "FileStorageBackend",
+    "ResearchMemory",
+    # Workflows
+    "ResearchWorkflowBase",
+    "ChatWorkflow",
+    "ConsensusWorkflow",
+    "ThinkDeepWorkflow",
+    "IdeateWorkflow",
+]