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

foundry_mcp/core/providers/opencode.py

@@ -19,7 +19,6 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Protocol, Sequence
 
 from .base import (
-    ModelDescriptor,
     ProviderCapability,
     ProviderContext,
     ProviderExecutionError,
@@ -122,52 +121,10 @@ def _default_runner(
     )
 
 
-OPENCODE_MODELS: List[ModelDescriptor] = [
-    ModelDescriptor(
-        id="openai/gpt-5.2",
-        display_name="OpenAI GPT-5.2 (via OpenCode)",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-        },
-        routing_hints={
-            "configurable": True,
-            "source": "opencode config",
-            "note": "Accepts any model ID - validated by opencode CLI",
-        },
-    ),
-    ModelDescriptor(
-        id="openai/gpt-5.2-codex",
-        display_name="OpenAI GPT-5.2 Codex (via OpenCode)",
-        capabilities={
-            ProviderCapability.TEXT,
-            ProviderCapability.STREAMING,
-        },
-        routing_hints={
-            "configurable": True,
-            "source": "opencode config",
-            "note": "Accepts any model ID - validated by opencode CLI",
-        },
-    ),
-    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},
@@ -206,9 +163,16 @@ 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()
-        )
+
+        # 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
 
@@ -256,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.
@@ -297,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:
@@ -437,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:
@@ -449,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)
@@ -497,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/memory.py

@@ -15,6 +15,7 @@ from filelock import FileLock
 from foundry_mcp.core.research.models import (
     ConsensusState,
     ConversationThread,
+    DeepResearchState,
     IdeationState,
     ThinkDeepState,
     ThreadStatus,
@@ -222,6 +223,11 @@ class ResearchMemory:
             model_class=ConsensusState,
             ttl_hours=ttl_hours,
         )
+        self._deep_research = FileStorageBackend(
+            storage_path=base_path / "deep_research",
+            model_class=DeepResearchState,
+            ttl_hours=ttl_hours,
+        )
 
     # =========================================================================
     # Thread operations (CHAT workflow)
@@ -394,6 +400,65 @@ class ResearchMemory:
 
         return states
 
+    # =========================================================================
+    # Deep research operations (DEEP_RESEARCH workflow)
+    # =========================================================================
+
+    def save_deep_research(self, deep_research: DeepResearchState) -> None:
+        """Save a deep research state."""
+        self._deep_research.save(deep_research.id, deep_research)
+
+    def load_deep_research(self, deep_research_id: str) -> Optional[DeepResearchState]:
+        """Load a deep research state by ID."""
+        return self._deep_research.load(deep_research_id)
+
+    def delete_deep_research(self, deep_research_id: str) -> bool:
+        """Delete a deep research state."""
+        return self._deep_research.delete(deep_research_id)
+
+    def list_deep_research(
+        self,
+        limit: Optional[int] = None,
+        cursor: Optional[str] = None,
+        completed_only: bool = False,
+    ) -> list[DeepResearchState]:
+        """List deep research states.
+
+        Args:
+            limit: Maximum number of states to return
+            cursor: Pagination cursor (research_id to start after)
+            completed_only: Filter to only completed research
+
+        Returns:
+            List of deep research states
+        """
+        states = []
+        for dr_id in self._deep_research.list_ids():
+            dr = self._deep_research.load(dr_id)
+            if dr is not None:
+                if completed_only and dr.completed_at is None:
+                    continue
+                states.append(dr)
+
+        # Sort by updated_at descending
+        states.sort(key=lambda s: s.updated_at, reverse=True)
+
+        # Apply cursor-based pagination (skip until after cursor ID)
+        if cursor is not None:
+            cursor_found = False
+            filtered_states = []
+            for state in states:
+                if cursor_found:
+                    filtered_states.append(state)
+                elif state.id == cursor:
+                    cursor_found = True
+            states = filtered_states
+
+        if limit is not None:
+            states = states[:limit]
+
+        return states
+
     # =========================================================================
     # Maintenance operations
     # =========================================================================
@@ -409,6 +474,7 @@ class ResearchMemory:
             "investigations": self._investigations.cleanup_expired(),
             "ideations": self._ideations.cleanup_expired(),
             "consensus": self._consensus.cleanup_expired(),
+            "deep_research": self._deep_research.cleanup_expired(),
         }
 
     def get_storage_stats(self) -> dict[str, int]:
@@ -422,4 +488,41 @@ class ResearchMemory:
             "investigations": len(self._investigations.list_ids()),
             "ideations": len(self._ideations.list_ids()),
             "consensus": len(self._consensus.list_ids()),
+            "deep_research": len(self._deep_research.list_ids()),
         }
+
+    # =========================================================================
+    # Universal session lookup
+    # =========================================================================
+
+    def load_session_by_id(
+        self, session_id: str
+    ) -> Optional[
+        ConversationThread
+        | ThinkDeepState
+        | IdeationState
+        | ConsensusState
+        | DeepResearchState
+    ]:
+        """Load any research session by its ID prefix.
+
+        Determines the session type from the ID prefix and loads from
+        the appropriate storage backend.
+
+        Args:
+            session_id: Session ID with type prefix (e.g., "thread-xxx", "consensus-xxx")
+
+        Returns:
+            The session state object, or None if not found
+        """
+        if session_id.startswith("thread-"):
+            return self.load_thread(session_id)
+        elif session_id.startswith("investigation-"):
+            return self.load_investigation(session_id)
+        elif session_id.startswith("ideation-"):
+            return self.load_ideation(session_id)
+        elif session_id.startswith("consensus-"):
+            return self.load_consensus(session_id)
+        elif session_id.startswith("deepres-"):
+            return self.load_deep_research(session_id)
+        return None