pantheon-opencode 1.5.2 → 1.6.0-beta.10

package/src/mcp/{pantheon_vision_server.py → pantheon_vision.py}

@@ -15,6 +15,8 @@ import json
 import logging
 import mimetypes
 import os
+import re
+import sqlite3
 import struct
 import sys
 from dataclasses import dataclass
@@ -23,7 +25,7 @@ from typing import Any
 from urllib.parse import unquote, urlparse
 
 import httpx
-from mcp.server.fastmcp import FastMCP
+from fastmcp import FastMCP
 
 mcp = FastMCP("pantheon-vision")
 
@@ -58,9 +60,24 @@ if not _logger.handlers:
 MAX_IMAGE_BYTES = 25 * 1024 * 1024
 REQUEST_TIMEOUT_SECONDS = 20.0
 HTTP_ERROR_STATUS = 400
+HTTP_BAD_REQUEST = 400
+HTTP_UNAUTHORIZED = 401
+HTTP_FORBIDDEN = 403
 DEFAULT_MODEL = "opencode-go/mimo-v2.5"
 GO_ENDPOINT = "https://opencode.ai/zen/go/v1/chat/completions"
 OPENCODE_ENDPOINT = "https://opencode.ai/zen/v1/chat/completions"
+# The Zen gateway rejects a sessionless request with HTTP 400 MissingSessionID.
+# Only Zen endpoints accept (and require) this header; it is never sent
+# elsewhere.
+SESSION_HEADER = "x-opencode-session"
+_ZEN_ENDPOINT_PREFIX = "https://opencode.ai/zen/"
+# A session id is an opaque OpenCode token. Only the characters real ids use
+# (`ses_...`) plus the separators existing callers already pass are accepted;
+# the length is bounded. Anything else — empty, whitespace, control characters,
+# quotes, CR/LF — is rejected instead of being copied into the header, where a
+# CRLF would split it and let a caller inject extra headers/requests.
+_SESSION_ID_MAX_LENGTH = 128
+_SESSION_ID_PATTERN = re.compile(r"[A-Za-z0-9._:-]+")
 _ALLOWED_MIME_TYPES = {"image/png", "image/jpeg", "image/webp", "image/gif"}
 _EXTENSION_MIME_TYPES = {
     ".png": "image/png",
@@ -220,7 +237,9 @@ async def _prepare_input(value: str) -> ImageInput:
             raise VisionError("Invalid image URL.")
         mime = _mime_from_path(Path(parsed.path))
         if mime is None and Path(parsed.path).suffix:
-            raise VisionError("Unsupported image MIME type. Use PNG, JPEG, WebP, or GIF.")
+            raise VisionError(
+                "Unsupported image MIME type. Use PNG, JPEG, WebP, or GIF."
+            )
         # The remote server owns the bytes.  The gateway receives the URL and
         # enforces its own fetch limits; unknown extensions remain possible.
         return ImageInput(value, mime or "image/jpeg", None, None, None)
@@ -238,9 +257,7 @@ async def _prepare_input(value: str) -> ImageInput:
         raise VisionError("Unsupported image MIME type. Use PNG, JPEG, WebP, or GIF.")
     encoded = base64.b64encode(data).decode("ascii")
     width, height = _dimensions(data, mime)
-    return ImageInput(
-        f"data:{mime};base64,{encoded}", mime, len(data), width, height
-    )
+    return ImageInput(f"data:{mime};base64,{encoded}", mime, len(data), width, height)
 
 
 def _extract_key(value: Any) -> str | None:
@@ -268,6 +285,36 @@ def _endpoint_for_model(model: str) -> str:
     return OPENCODE_ENDPOINT if model.startswith("opencode/") else GO_ENDPOINT
 
 
+def _is_zen_endpoint(endpoint: str) -> bool:
+    """Return whether ``endpoint`` is an OpenCode Zen gateway URL.
+
+    The destination host is the security boundary for the
+    ``x-opencode-session`` header: the session identity must reach a Zen
+    endpoint and nothing else. This is a prefix check (not equality) so a
+    self-hosted Zen path still qualifies while a non-Zen URL never does.
+    """
+    return endpoint.startswith(_ZEN_ENDPOINT_PREFIX)
+
+
+def _validated_session_id(value: object) -> str | None:
+    """Return a session id safe to send in the Zen header, or None.
+
+    The value arrives from a tool parameter the plugin forwards (a local MCP
+    process is not handed a session id by the host), so it is untrusted input:
+    only a trimmed, bounded, token-shaped value is accepted. An empty or
+    whitespace-only string, a control character, a quote, or an embedded
+    CR/LF yields None so the header is simply omitted — never copied verbatim.
+    """
+    if not isinstance(value, str):
+        return None
+    candidate = value.strip()
+    if not candidate or len(candidate) > _SESSION_ID_MAX_LENGTH:
+        return None
+    if _SESSION_ID_PATTERN.fullmatch(candidate) is None:
+        return None
+    return candidate
+
+
 def _strip_provider_prefix(model: str) -> str:
     """Return the model ID without its provider prefix.
 
@@ -281,23 +328,119 @@ def _strip_provider_prefix(model: str) -> str:
     return model_name if separator else model
 
 
+def _opencode_data_dir() -> Path:
+    """Locate the OpenCode data directory on either V1 or V2 hosts.
+
+    Honors ``XDG_DATA_HOME`` (``$XDG_DATA_HOME/opencode`` when set, else
+    ``~/.local/share/opencode``) so a relocated data root resolves the same
+    stores as the plugin. ``OPENCODE_DB`` still names the exact credential db.
+    """
+    data_home = os.getenv("XDG_DATA_HOME", "").strip()
+    base = Path(data_home) if data_home else Path.home() / ".local" / "share"
+    return base / "opencode"
+
+
+def _credential_db_path() -> Path:
+    """Path to the OpenCode V2 credential database.
+
+    ``OPENCODE_DB`` names the exact file when the host relocated it (e.g. a
+    sandbox with its own db); otherwise the default ``<data dir>/opencode.db``
+    sibling of the V1 ``auth.json`` is used.
+    """
+    override = os.getenv("OPENCODE_DB", "").strip()
+    if override:
+        return Path(override)
+    return _opencode_data_dir() / "opencode.db"
+
+
+def _key_from_credential_db(provider: str) -> str | None:
+    """Read a provider key from the V2 SQLite credential store.
+
+    OpenCode V2 moved credentials out of ``<data dir>/auth.json`` and into a
+    ``credential`` table in the OpenCode database (``OPENCODE_DB``, else
+    ``<data dir>/opencode.db``); the V1 JSON file no longer exists on a V2
+    host, so reading it alone left auth silently unresolvable. The value is
+    plaintext JSON of the form ``{"type": "key", "key": "..."}``, so the
+    stdlib is sufficient — no new dependency.
+
+    The database is opened read-only via a URI so a missing or locked file
+    cannot be created or mutated by a health check.
+
+    Args:
+        provider: Integration id to look up, e.g. ``"opencode-go"``.
+
+    Returns:
+        The stored key, or None when the store, table, row, or key is absent.
+    """
+    db_path = _credential_db_path()
+    if not db_path.is_file():
+        return None
+    uri = f"file:{db_path}?mode=ro"
+    conn = None
+    try:
+        conn = sqlite3.connect(uri, uri=True, timeout=5.0)
+        row = conn.execute(
+            "SELECT value FROM credential "
+            "WHERE integration_id = ? AND active = 1 LIMIT 1",
+            (provider,),
+        ).fetchone()
+    except (sqlite3.Error, ValueError):
+        _logger.warning("Could not read the OpenCode credential store at %s", db_path)
+        return None
+    finally:
+        if conn is not None:
+            conn.close()
+    if row is None:
+        return None
+    try:
+        return _extract_key(json.loads(row[0]))
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
 def _resolve_auth() -> tuple[str | None, str]:
-    """Resolve auth in env-first, then OpenCode auth-store order."""
+    """Resolve auth in env-first, then OpenCode credential-store order.
+
+    Precedence, highest first:
+
+    1. ``PANTHEON_OPENCODE_API_KEY``
+    2. ``OPENCODE_API_KEY``
+    3. the V2 SQLite ``credential`` table (``opencode-go``, then ``opencode``)
+    4. a legacy V1 ``<data dir>/auth.json`` file, for hosts that still have one
+
+    The V1 file is checked last and only when it exists; it is absent on a V2
+    host. When no source yields a key this returns ``None`` silently: the
+    graceful callers (``vision_describe`` / ``vision_ocr``) degrade to local
+    extraction, and only the fatal gateway path logs the paths/env vars tried.
+    """
     model = os.getenv("PANTHEON_VISION_MODEL") or DEFAULT_MODEL
     env_key = os.getenv("PANTHEON_OPENCODE_API_KEY") or os.getenv("OPENCODE_API_KEY")
     if env_key:
         return env_key, _endpoint_for_model(model)
 
-    auth_path = Path.home() / ".local" / "share" / "opencode" / "auth.json"
-    try:
-        auth = json.loads(auth_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError, TypeError):
-        auth = {}
-    if isinstance(auth, dict):
-        for provider, endpoint in (("opencode-go", GO_ENDPOINT), ("opencode", OPENCODE_ENDPOINT)):
-            key = _extract_key(auth.get(provider))
-            if key:
-                return key, endpoint
+    for provider, endpoint in (
+        ("opencode-go", GO_ENDPOINT),
+        ("opencode", OPENCODE_ENDPOINT),
+    ):
+        key = _key_from_credential_db(provider)
+        if key:
+            return key, endpoint
+
+    auth_path = _opencode_data_dir() / "auth.json"
+    if auth_path.is_file():
+        try:
+            auth = json.loads(auth_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, TypeError):
+            auth = {}
+        if isinstance(auth, dict):
+            for provider, endpoint in (
+                ("opencode-go", GO_ENDPOINT),
+                ("opencode", OPENCODE_ENDPOINT),
+            ):
+                key = _extract_key(auth.get(provider))
+                if key:
+                    return key, endpoint
+
     return None, _endpoint_for_model(model)
 
 
@@ -320,6 +463,86 @@ def _metadata(image: ImageInput) -> dict[str, Any]:
     }
 
 
+def _local_fallback_note() -> str:
+    """Local-fallback guidance naming the EFFECTIVE credential database path.
+
+    Built at call time (not a module constant) so a relocated host — via
+    ``OPENCODE_DB`` or ``XDG_DATA_HOME`` — points the operator at the file the
+    resolver actually reads, matching the ``_gateway`` diagnostics.
+    """
+    return (
+        "Gateway de visão indisponível (sem credencial). Usando extração local "
+        "(metadados + best-effort), sem conteúdo inventado. Rode `opencode auth "
+        "login`, configure PANTHEON_OPENCODE_API_KEY ou OPENCODE_API_KEY, ou "
+        f"guarde uma chave para 'opencode-go' em {_credential_db_path()}."
+    )
+
+
+def _image_bytes(image: ImageInput) -> bytes | None:
+    """Return the decoded bytes of an in-memory image source, else None.
+
+    Only data URIs carry bytes locally. Remote URLs are intentionally not
+    fetched here: the local fallback must stay offline and deterministic.
+    """
+    if not image.source.startswith("data:"):
+        return None
+    _header, separator, encoded = image.source.partition(",")
+    if not separator:
+        return None
+    try:
+        return base64.b64decode(encoded, validate=True)
+    except (ValueError, binascii.Error):
+        return None
+
+
+def _ocr_bytes(data: bytes) -> str | None:
+    """Best-effort OCR via pytesseract when it is installed.
+
+    The optional dependency is import-guarded: no pytesseract/Pillow is required
+    (neither is added to requirements-vision.txt). Any failure yields None so
+    the caller degrades to metadata-only instead of inventing text.
+    """
+    try:
+        import io  # noqa: PLC0415
+
+        import pytesseract  # noqa: PLC0415
+        from PIL import Image as PILImage  # noqa: PLC0415
+    except ImportError:
+        return None
+    try:
+        with PILImage.open(io.BytesIO(data)) as opened:
+            text = pytesseract.image_to_string(opened)
+    except Exception:
+        return None
+    stripped = text.strip() if isinstance(text, str) else ""
+    return stripped or None
+
+
+def _local_vision_text(image: ImageInput) -> str:
+    """Deterministic local fallback: metadata, plus OCR when available.
+
+    Never fabricates a description; when pytesseract is absent it states so.
+    """
+    metadata = _metadata(image)
+    dims = (
+        f"{metadata['width']}x{metadata['height']}"
+        if metadata["dimensions"]
+        else "dimensões desconhecidas"
+    )
+    size = metadata["size"]
+    size_text = f"{size} bytes" if isinstance(size, int) else "tamanho desconhecido"
+    data = _image_bytes(image)
+    ocr_text = _ocr_bytes(data) if data is not None else None
+    lines = [
+        f"Imagem local: {dims} {metadata['mime']}, {size_text}.",
+        f"Texto OCR: {ocr_text}"
+        if ocr_text
+        else "Texto OCR: indisponível (tesseract/pytesseract não instalado).",
+        _local_fallback_note(),
+    ]
+    return "\n".join(lines)
+
+
 def _content_text(value: Any) -> str:
     """Extract text from OpenAI-compatible message content."""
     if isinstance(value, str):
@@ -343,7 +566,9 @@ def _scrub(value: str, key: str | None) -> str:
 def _sanitized_gateway_body(body: dict[str, Any]) -> dict[str, Any]:
     """Non-sensitive summary of a gateway request body (no keys, no image bytes)."""
     messages = body.get("messages")
-    content = messages[0].get("content") if isinstance(messages, list) and messages else None
+    content = (
+        messages[0].get("content") if isinstance(messages, list) and messages else None
+    )
     chunks = content if isinstance(content, list) else [content]
     parts: list[dict[str, Any]] = []
     for chunk in chunks:
@@ -353,7 +578,9 @@ def _sanitized_gateway_body(body: dict[str, Any]) -> dict[str, Any]:
             parts.append({"type": "image_url"})
         else:
             text = chunk.get("text")
-            parts.append({"type": "text", "chars": len(text) if isinstance(text, str) else 0})
+            parts.append(
+                {"type": "text", "chars": len(text) if isinstance(text, str) else 0}
+            )
     return {
         "model": body.get("model"),
         "response_format": body.get("response_format"),
@@ -376,11 +603,68 @@ def _parse_json_object(value: str) -> dict[str, Any] | None:
     return None
 
 
-async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False) -> str:
-    """Send one multimodal request to the selected OpenCode gateway."""
+def _gateway_http_error(status: int) -> str:
+    """Actionable, non-sensitive VisionError text for a gateway HTTP failure.
+
+    Maps the known Zen failures: 400 ``MissingSessionID`` (session header
+    absent), 401 (credential/model), 403 (free-tier model usable only from
+    inside OpenCode, or no paid access). Never includes the credential, image
+    payload, or session id.
+    """
+    if status == HTTP_BAD_REQUEST:
+        return (
+            "Vision gateway rejected the request (HTTP 400 MissingSessionID): "
+            "the x-opencode-session header is missing — call the tool from an "
+            "OpenCode session so the session id can be forwarded."
+        )
+    if status == HTTP_UNAUTHORIZED:
+        return "Vision gateway rejected the credential (HTTP 401)."
+    if status == HTTP_FORBIDDEN:
+        return (
+            "Vision gateway denied access (HTTP 403): the model may be "
+            "free-tier (usable only from inside OpenCode) or this account has "
+            "no paid access to it."
+        )
+    return "Vision gateway returned an HTTP error."
+
+
+async def _gateway(
+    image: ImageInput,
+    prompt: str,
+    *,
+    structured: bool = False,
+    session_id: str | None = None,
+) -> str:
+    """Send one multimodal request to the selected OpenCode gateway.
+
+    ``session_id`` (when present and valid — see ``_validated_session_id``) is
+    sent as the ``x-opencode-session`` header — and ONLY for a Zen endpoint,
+    which rejects the request with HTTP 400 ``MissingSessionID`` otherwise. An
+    unusable value (empty, whitespace, control characters, CR/LF, quotes) is
+    dropped rather than copied into the header. It is never logged and never
+    sent to a non-Zen host.
+    """
     key, endpoint = _resolve_auth()
     if not key:
-        raise VisionError("OpenCode API key not configured.")
+        # Missing credential is FATAL here (unlike the graceful describe/ocr
+        # local fallback), so this is the one place that logs the sources tried.
+        db_path = _credential_db_path()
+        auth_path = _opencode_data_dir() / "auth.json"
+        _logger.error(
+            "No OpenCode credential found. Run `opencode auth login`, set "
+            "PANTHEON_OPENCODE_API_KEY (or OPENCODE_API_KEY), or store a key "
+            "for 'opencode-go' in %s (tried: env, the credential table in %s, "
+            "and the legacy %s).",
+            db_path,
+            db_path,
+            auth_path,
+        )
+        raise VisionError(
+            "OpenCode credential not configured. Run `opencode auth login`, "
+            "set PANTHEON_OPENCODE_API_KEY or OPENCODE_API_KEY, or store a key "
+            f"for 'opencode-go' in the OpenCode credential database ({db_path}). "
+            "See the pantheon.vision error log for the paths tried."
+        )
     safe_prompt = prompt.replace(key, "[redacted]")
     content: list[dict[str, Any]] = [
         {"type": "text", "text": safe_prompt},
@@ -392,18 +676,25 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
     }
     if structured:
         body["response_format"] = {"type": "json_object"}
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": "application/json",
+    }
+    safe_session_id = _validated_session_id(session_id)
+    if safe_session_id is not None and _is_zen_endpoint(endpoint):
+        headers[SESSION_HEADER] = safe_session_id
     try:
         async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT_SECONDS) as client:
             response = await client.post(
                 endpoint,
-                headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+                headers=headers,
                 json=body,
             )
         if response.status_code >= HTTP_ERROR_STATUS:
             # Sanitized diagnostic: status, endpoint, bare model, truncated
             # gateway detail (scrubbed), and a body summary with no keys or
             # image bytes. Logged to stderr so the MCP stdio protocol is
-            # never corrupted.
+            # never corrupted. The session id is NEVER logged.
             detail = _scrub(str(getattr(response, "text", "")), key)
             _logger.warning(
                 "vision gateway error status=%s endpoint=%s model=%s detail=%s body=%s",
@@ -413,19 +704,42 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
                 detail[:200] or "no detail",
                 json.dumps(_sanitized_gateway_body(body)),
             )
-            raise VisionError("Vision gateway returned an HTTP error.")
+            raise VisionError(_gateway_http_error(response.status_code))
         payload = response.json()
         choices = payload.get("choices") if isinstance(payload, dict) else None
-        message = choices[0].get("message") if choices else None
-        text = _content_text(message.get("content") if isinstance(message, dict) else "")
+        first_choice = choices[0] if isinstance(choices, list) and choices else None
+        message = (
+            first_choice.get("message") if isinstance(first_choice, dict) else None
+        )
+        text = _content_text(
+            message.get("content") if isinstance(message, dict) else ""
+        )
         if not text:
-            raise VisionError("Vision gateway returned an empty response.")
+            # Surface finish_reason (e.g. `length`) so a reasoning model cut off
+            # by max_tokens yields an actionable message, not a bare "empty".
+            finish = (
+                first_choice.get("finish_reason")
+                if isinstance(first_choice, dict)
+                else None
+            )
+            suffix = (
+                f" (finish_reason: {finish})"
+                if isinstance(finish, str) and finish
+                else ""
+            )
+            raise VisionError(f"Vision gateway returned an empty response{suffix}.")
         return _scrub(text, key)
     except VisionError:
         raise
     except (httpx.TimeoutException, TimeoutError) as exc:
         raise VisionError("Vision gateway request timed out.") from exc
-    except (httpx.HTTPError, json.JSONDecodeError, KeyError, IndexError, TypeError) as exc:
+    except (
+        httpx.HTTPError,
+        json.JSONDecodeError,
+        KeyError,
+        IndexError,
+        TypeError,
+    ) as exc:
         raise VisionError("Could not read the vision gateway response.") from exc
     except Exception as exc:
         raise VisionError("Vision gateway request failed.") from exc
@@ -433,7 +747,11 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
 
 def _error_message(exc: Exception) -> str:
     """Return a stable, non-sensitive tool error."""
-    return f"Error: {exc}" if isinstance(exc, VisionError) else "Error: Vision request failed."
+    return (
+        f"Error: {exc}"
+        if isinstance(exc, VisionError)
+        else "Error: Vision request failed."
+    )
 
 
 _DESCRIBE_PROMPT = (
@@ -442,7 +760,8 @@ _DESCRIBE_PROMPT = (
 )
 _OCR_PROMPT = (
     "Perform OCR on this image. Transcribe all visible text exactly, preserving "
-    "lines, spacing, punctuation, and formatting (formatação) where possible. If there is no "
+    "lines, spacing, punctuation, and formatting (formatação) where possible. "
+    "If there is no "
     "text, say clearly that no text was found. Do not describe the image."
 )
 _ANALYZE_PROMPT = (
@@ -453,31 +772,68 @@ _ANALYZE_PROMPT = (
 
 
 @mcp.tool(description="Describe an image faithfully using the Pantheon vision gateway.")
-async def vision_describe(path: str, prompt: str | None = None) -> str:
-    """Describe image content, text, layout, objects, and uncertainty."""
+async def vision_describe(
+    path: str, prompt: str | None = None, session_id: str | None = None
+) -> str:
+    """Describe image content, text, layout, objects, and uncertainty.
+
+    When no gateway credential is available the tool degrades to a
+    deterministic local extraction (metadata + best-effort OCR) instead of
+    failing outright; it never returns an invented description.
+
+    ``session_id`` is the caller's OpenCode session id. The Zen gateway rejects
+    a sessionless request (HTTP 400 MissingSessionID); the plugin forwards it
+    through the tool call because a local MCP process is not handed one by the
+    host. It is sent only to a Zen endpoint and never logged.
+    """
     try:
         image = await _prepare_input(path)
-        return await _gateway(image, prompt or _DESCRIBE_PROMPT)
+    except Exception as exc:
+        return _error_message(exc)
+    key, _endpoint = _resolve_auth()
+    if not key:
+        return _local_vision_text(image)
+    try:
+        return await _gateway(image, prompt or _DESCRIBE_PROMPT, session_id=session_id)
     except Exception as exc:
         return _error_message(exc)
 
 
 @mcp.tool(description="Extract visible text from an image with OCR.")
-async def vision_ocr(path: str) -> str:
-    """Transcribe visible image text while preserving line formatting."""
+async def vision_ocr(path: str, session_id: str | None = None) -> str:
+    """Transcribe visible image text while preserving line formatting.
+
+    Falls back to local, best-effort OCR (metadata + pytesseract when installed)
+    when no gateway credential is configured. ``session_id`` reaches the Zen
+    gateway as the ``x-opencode-session`` header (see ``vision_describe``).
+    """
     try:
         image = await _prepare_input(path)
-        return await _gateway(image, _OCR_PROMPT)
+    except Exception as exc:
+        return _error_message(exc)
+    key, _endpoint = _resolve_auth()
+    if not key:
+        return _local_vision_text(image)
+    try:
+        return await _gateway(image, _OCR_PROMPT, session_id=session_id)
     except Exception as exc:
         return _error_message(exc)
 
 
-@mcp.tool(description="Analyze an image and return metadata, description, and OCR as JSON.")
-async def vision_analyze(path: str) -> str:
-    """Return local metadata plus one structured description/OCR gateway call."""
+@mcp.tool(
+    description="Analyze an image and return metadata, description, and OCR as JSON."
+)
+async def vision_analyze(path: str, session_id: str | None = None) -> str:
+    """Return local metadata plus one structured description/OCR gateway call.
+
+    ``session_id`` reaches the Zen gateway as the ``x-opencode-session`` header
+    (see ``vision_describe``).
+    """
     try:
         image = await _prepare_input(path)
-        content = await _gateway(image, _ANALYZE_PROMPT, structured=True)
+        content = await _gateway(
+            image, _ANALYZE_PROMPT, structured=True, session_id=session_id
+        )
         parsed = _parse_json_object(content)
         if parsed is None:
             parsed = {"description": content, "ocr": "No structured OCR was returned."}

package/src/mcp/requirements-mcp.txt

@@ -1,8 +1,12 @@
 # Pantheon MCP runtime dependencies — EXACT pins (issue #21)
-# Pinned to the versions validated in the sandbox venv (2026-08-05).
-# Update deliberately via: pip install -U <pkg> && pip freeze | grep -iE '^(mcp|fastmcp|pyyaml|sqlite-vec|fastembed)'
-mcp==1.29.0
-fastmcp==3.4.6
+# Coordinated MCP SDK/FastMCP major migration (Dependabot PRs #140 and #188).
+# Update deliberately via: pip install -U <pkg> && pip freeze | grep -iE '^(mcp|fastmcp|pyyaml|httpx)=='
+# Memory search is FTS5 (SQLite stdlib): sqlite-vec and fastembed were removed
+# with the vector pipeline — the server no longer imports either.
+mcp==2.2.0
+fastmcp==4.0.10
+pydantic==2.12.5
+pydantic-settings==2.14.2
 pyyaml==6.0.3
-sqlite-vec==0.1.9
-fastembed==0.8.0
+# Vision imports httpx; MCP 2.2.0 provides httpx2, a different package.
+httpx==0.28.1

package/src/mcp/requirements-vision.txt

@@ -1,3 +1,5 @@
-mcp==1.29.0
-fastmcp==3.4.6
+mcp==2.2.0
+fastmcp==4.0.10
+pydantic==2.12.5
+pydantic-settings==2.14.2
 httpx==0.28.1