@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/mcp_configuration_context.py

@@ -0,0 +1,291 @@
+"""MCP configuration discovery and native-config projection context."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Protocol
+
+from .mcp_config_reader import ClaudeMcpConfigPathPolicy
+from .managed_mcp_discovery import (
+    ManagedMcpDiscoveryPaths,
+    ManagedMcpDiscoveryPorts,
+    ManagedMcpDiscoveryService,
+    NativeMcpConfigWriter,
+    NativeMcpConfigWriterPorts,
+)
+
+
+class JsonArtifactRepository(Protocol):
+    def save(self, data: Any, operation: str) -> None: ...
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationFilePorts:
+    read_items: Callable[..., list[Any]]
+    names_from_mapping: Callable[..., Any]
+    servers_from_mapping: Callable[..., Any]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationPaths:
+    home: Path
+    web_tools: Path
+    proxy: Path
+    native_config: Path
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationRuntimePorts:
+    resolve_executable: Callable[[str], str]
+    parse_bool: Callable[..., bool]
+    artifact_repository: Callable[[Path], JsonArtifactRepository]
+    discover_channel_specs: Callable[..., list[str]]
+    is_channel_tagged: Callable[[str], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationContext:
+    files: McpConfigurationFilePorts
+    paths: McpConfigurationPaths
+    runtime: McpConfigurationRuntimePorts
+    native_channel_names: frozenset[str]
+
+    def read_server_names(self, path: Path, cwd: Path) -> list[str]:
+        return self.files.read_items(
+            path,
+            cwd,
+            self.files.names_from_mapping,
+            str,
+            self.files.log,
+        )
+
+    def read_servers(
+        self, path: Path, cwd: Path
+    ) -> list[tuple[str, dict[str, Any]]]:
+        return self.files.read_items(
+            path,
+            cwd,
+            self.files.servers_from_mapping,
+            lambda item: item[0],
+            self.files.log,
+        )
+
+    def server_is_stdio(self, server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        server_type = str(server.get("type") or "").strip().lower()
+        if server_type and server_type not in ("stdio", "command"):
+            return False
+        command = self.runtime.resolve_executable(
+            str(server.get("command") or "").strip()
+        )
+        if not command:
+            return False
+        raw_args = server.get("args", [])
+        args = (
+            [str(item) for item in raw_args if item is not None]
+            if isinstance(raw_args, list)
+            else []
+        )
+        return "mcp-proxy" not in args
+
+    @staticmethod
+    def server_is_streamable_http(server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        server_type = str(
+            server.get("type") or server.get("transport") or ""
+        ).strip().lower()
+        if server_type not in {"http", "streamable-http"}:
+            return False
+        url = str(server.get("url") or server.get("endpoint") or "").strip()
+        return url.startswith(("http://", "https://"))
+
+    def server_force_proxy(self, server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        return self.runtime.parse_bool(
+            server.get(
+                "ciel_runtime_mcp_proxy",
+                server.get(
+                    "ciel_runtime_force_mcp_proxy",
+                    server.get("force_mcp_proxy", False),
+                ),
+            ),
+            False,
+        )
+
+    def server_disables_proxy_notifications(self, server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        return self.runtime.parse_bool(
+            server.get(
+                "ciel_runtime_disable_notification_stream",
+                server.get("ciel_runtime_disable_mcp_notifications", False),
+            ),
+            False,
+        )
+
+    @staticmethod
+    def safe_proxy_name(name: str) -> str:
+        safe = re.sub(r"[^A-Za-z0-9_.-]+", "_", name.strip())
+        return safe[:80] or "server"
+
+    def config_paths(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> list[Path]:
+        return ClaudeMcpConfigPathPolicy.paths(
+            passthrough or [], cwd or Path.cwd(), home or self.paths.home
+        )
+
+    def existing_config_paths(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> list[Path]:
+        return ClaudeMcpConfigPathPolicy.existing_paths(
+            passthrough or [], cwd or Path.cwd(), home or self.paths.home
+        )
+
+    def discover_user_servers(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        working_directory = cwd or Path.cwd()
+        servers: dict[str, dict[str, Any]] = {}
+        for path in self.existing_config_paths(
+            passthrough, working_directory, home
+        ):
+            for name, server in self.read_servers(path, working_directory):
+                servers.setdefault(name, server)
+        return servers
+
+    def read_generated_servers(
+        self, path: Path, cwd: Path
+    ) -> dict[str, dict[str, Any]]:
+        if not path.exists() or not path.is_file():
+            return {}
+        servers: dict[str, dict[str, Any]] = {}
+        for name, server in self.read_servers(path, cwd):
+            if name.strip().lower() in self.native_channel_names:
+                continue
+            servers.setdefault(name, server)
+        return servers
+
+    def discover_managed_servers(
+        self, cwd: Path | None = None
+    ) -> dict[str, dict[str, Any]]:
+        service = ManagedMcpDiscoveryService(
+            paths=ManagedMcpDiscoveryPaths(
+                web_tools=self.paths.web_tools,
+                proxy=self.paths.proxy,
+            ),
+            ports=ManagedMcpDiscoveryPorts(
+                read_generated=self.read_generated_servers,
+                load_json=lambda path: json.loads(path.read_text(encoding="utf-8")),
+                log=self.files.log,
+            ),
+            native_channel_names=frozenset(
+                name.casefold() for name in self.native_channel_names
+            ),
+        )
+        return service.discover(cwd or Path.cwd())
+
+    def write_native_config(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> Path | None:
+        writer = NativeMcpConfigWriter(
+            self.paths.native_config,
+            NativeMcpConfigWriterPorts(
+                self.discover_user_servers,
+                self.discover_managed_servers,
+                lambda path, data, operation: self.runtime.artifact_repository(
+                    path
+                ).save(data, operation),
+                self.files.log,
+            ),
+        )
+        return writer.write(passthrough, cwd, home)
+
+    def auto_discovered_channel_specs(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> list[str]:
+        working_directory = cwd or Path.cwd()
+        return self.runtime.discover_channel_specs(
+            self.config_paths(passthrough, working_directory, home),
+            working_directory,
+            self.read_server_names,
+            self.runtime.is_channel_tagged,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationCompatibilityApi:
+    context: Callable[[], McpConfigurationContext]
+
+    def read_server_names(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().read_server_names(*args, **kwargs)
+
+    def read_servers(self, *args: Any, **kwargs: Any) -> list[Any]:
+        return self.context().read_servers(*args, **kwargs)
+
+    def server_is_stdio(self, server: dict[str, Any]) -> bool:
+        return self.context().server_is_stdio(server)
+
+    def server_is_streamable_http(self, server: dict[str, Any]) -> bool:
+        return self.context().server_is_streamable_http(server)
+
+    def server_force_proxy(self, server: dict[str, Any]) -> bool:
+        return self.context().server_force_proxy(server)
+
+    def server_disables_proxy_notifications(self, server: dict[str, Any]) -> bool:
+        return self.context().server_disables_proxy_notifications(server)
+
+    def safe_proxy_name(self, name: str) -> str:
+        return self.context().safe_proxy_name(name)
+
+    def config_paths(self, *args: Any, **kwargs: Any) -> list[Path]:
+        return self.context().config_paths(*args, **kwargs)
+
+    def existing_config_paths(self, *args: Any, **kwargs: Any) -> list[Path]:
+        return self.context().existing_config_paths(*args, **kwargs)
+
+    def discover_user_servers(self, *args: Any, **kwargs: Any) -> dict[str, dict[str, Any]]:
+        return self.context().discover_user_servers(*args, **kwargs)
+
+    def read_generated_servers(self, *args: Any, **kwargs: Any) -> dict[str, dict[str, Any]]:
+        return self.context().read_generated_servers(*args, **kwargs)
+
+    def discover_managed_servers(self, *args: Any, **kwargs: Any) -> dict[str, dict[str, Any]]:
+        return self.context().discover_managed_servers(*args, **kwargs)
+
+    def write_native_config(self, *args: Any, **kwargs: Any) -> Path | None:
+        return self.context().write_native_config(*args, **kwargs)
+
+    def auto_discovered_channel_specs(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().auto_discovered_channel_specs(*args, **kwargs)
+
+
+__all__ = [
+    "McpConfigurationCompatibilityApi",
+    "McpConfigurationContext",
+    "McpConfigurationFilePorts",
+    "McpConfigurationPaths",
+    "McpConfigurationRuntimePorts",
+]

package/ciel_runtime_support/mcp_http_proxy.py

@@ -13,6 +13,8 @@ from typing import Any, Callable
 import urllib.error
 import urllib.request
 
+from .mcp_transport import negotiated_protocol_version
+
 
 @dataclass(frozen=True, slots=True)
 class McpHttpProxyCodec:
@@ -101,6 +103,7 @@ def run_mcp_streamable_http_proxy(
     endpoint = str(server.get("url") or server.get("endpoint") or "").strip()
     headers = mcp_server_runtime_headers(server)
     protocol_version = str(server.get("mcp_protocol_version") or server.get("protocolVersion") or server.get("protocol_version") or MCP_STREAMABLE_HTTP_PROTOCOL_VERSION)
+    active_protocol_version = protocol_version
     timeout = max(5.0, min(120.0, float(server.get("mcp_timeout_seconds") or server.get("timeout") or 20.0)))
     requires_session = parse_bool(server.get("streamable_requires_session", server.get("require_session", server.get("mcp_session_required", True))), True)
     notification_stream_enabled = not _mcp_server_disable_proxy_notification_stream(server)
@@ -236,19 +239,22 @@ def run_mcp_streamable_http_proxy(
         Publishes the initialize result (for the stdin initialize reply) and the
         new session id under session_cond, waking any waiter.
         """
-        nonlocal session_id, initialize_result
+        nonlocal session_id, initialize_result, active_protocol_version
         init_payload = initialize_payload
         if not init_payload:
             return None
+        params = init_payload.get("params") if isinstance(init_payload.get("params"), dict) else {}
+        requested_protocol = str(params.get("protocolVersion") or protocol_version)
         try:
             result, returned_session = _mcp_proxy_streamable_http_request(
-                endpoint, headers, init_payload, timeout, protocol_version, None,
+                endpoint, headers, init_payload, timeout, requested_protocol, None,
             )
         except Exception as exc:
             router_log("WARN", f"mcp_http_proxy_session_init_failed server={server_name} error={type(exc).__name__}: {exc}")
             return None
         if isinstance(result, dict):
             _mcp_proxy_observe_json_message(server_name, result)
+        active_protocol_version = negotiated_protocol_version(result, requested_protocol)
         with session_cond:
             session_id = returned_session or session_id
             if isinstance(result, dict):
@@ -258,7 +264,7 @@ def run_mcp_streamable_http_proxy(
         if new_session and initialized_payload:
             try:
                 _mcp_proxy_streamable_http_request(
-                    endpoint, headers, initialized_payload, timeout, protocol_version, new_session,
+                    endpoint, headers, initialized_payload, timeout, active_protocol_version, new_session,
                 )
             except Exception as exc:
                 router_log(
@@ -347,7 +353,7 @@ def run_mcp_streamable_http_proxy(
             reopen_after_close = False
             try:
                 request_headers = _mcp_streamable_headers(
-                    headers, protocol_version, worker_session, accept="text/event-stream",
+                    headers, active_protocol_version, worker_session, accept="text/event-stream",
                 )
                 if last_event_id:
                     request_headers["Last-Event-ID"] = last_event_id
@@ -463,7 +469,7 @@ def run_mcp_streamable_http_proxy(
                         active = session_id
                     if active:
                         try:
-                            _mcp_proxy_streamable_http_request(endpoint, headers, payload, timeout, protocol_version, active)
+                            _mcp_proxy_streamable_http_request(endpoint, headers, payload, timeout, active_protocol_version, active)
                             router_log("INFO", f"mcp_http_proxy_initialized_forwarded server={server_name} session={active}")
                         except urllib.error.HTTPError as exc:
                             body_text = _http_error_body_text(exc)
@@ -519,7 +525,7 @@ def run_mcp_streamable_http_proxy(
                         if not active_session:
                             raise RuntimeError("Streamable HTTP MCP session is not initialized")
                     result, _returned = _mcp_proxy_streamable_http_request(
-                        endpoint, headers, payload, timeout, protocol_version, active_session,
+                        endpoint, headers, payload, timeout, active_protocol_version, active_session,
                     )
                     tool_name = _mcp_proxy_tool_call_name(payload)
                     if isinstance(result, dict):
@@ -549,7 +555,7 @@ def run_mcp_streamable_http_proxy(
                         if active_session:
                             try:
                                 result, _r = _mcp_proxy_streamable_http_request(
-                                    endpoint, headers, payload, timeout, protocol_version, active_session,
+                                    endpoint, headers, payload, timeout, active_protocol_version, active_session,
                                 )
                                 tool_name = _mcp_proxy_tool_call_name(payload)
                                 if isinstance(result, dict):
@@ -572,7 +578,7 @@ def run_mcp_streamable_http_proxy(
                 if _mcp_proxy_tool_is_notification_wait(_mcp_proxy_tool_call_name(payload)):
                     _mcp_proxy_write_json_response(wait_for_proxy_notifications(payload))
                     continue
-                result, _r = _mcp_proxy_streamable_http_request(endpoint, headers, payload, timeout, protocol_version, current_session_id())
+                result, _r = _mcp_proxy_streamable_http_request(endpoint, headers, payload, timeout, active_protocol_version, current_session_id())
                 tool_name = _mcp_proxy_tool_call_name(payload)
                 if isinstance(result, dict):
                     result = _mcp_proxy_compact_tool_result_response(server_name, tool_name, result)

package/ciel_runtime_support/mcp_probe_transport.py

@@ -248,23 +248,34 @@ def probe_streamable_http_mcp_for_channel_capability_detailed(
     initialized_failed = False
     session_id: str | None = None
     try:
-        response, session_id = http.streamable_post_json(
-            url,
-            headers,
-            codec.initialize_dict(protocol_version),
-            max(1.0, min(120.0, effective_timeout)),
-            protocol_version,
-        )
-        preview_source = json.dumps(response, ensure_ascii=False) if isinstance(response, (dict, list)) else str(response or "")
-        bytes_seen = len(preview_source.encode("utf-8", errors="replace"))
-        if isinstance(response, dict) and response.get("id") == 1 and "result" in response:
-            response_received = True
-            capable = codec.capability_present(response)
+        # A channel-capable server can occasionally lose a freshly-created
+        # session between ``initialize`` and ``notifications/initialized``
+        # (for example when a load balancer routes the two requests to
+        # different workers).  Treating that one handshake failure as a
+        # durable negative capability result leaves the cached record false
+        # on every later launch, so Ciel never owns the notification stream.
+        # Retry the complete handshake once, but only after the server has
+        # already advertised the channel capability.
+        for handshake_attempt in range(2):
+            response, session_id = http.streamable_post_json(
+                url,
+                headers,
+                codec.initialize_dict(protocol_version),
+                max(1.0, min(120.0, effective_timeout)),
+                protocol_version,
+            )
+            preview_source = json.dumps(response, ensure_ascii=False) if isinstance(response, (dict, list)) else str(response or "")
+            bytes_seen = len(preview_source.encode("utf-8", errors="replace"))
+            response_received = bool(
+                isinstance(response, dict)
+                and response.get("id") == 1
+                and "result" in response
+            )
+            capable = response_received and codec.capability_present(response)
             if not capable:
                 stdout_preview = codec.decode_preview(preview_source.encode("utf-8"), policy.stdout_preview_bytes)
-        else:
-            stdout_preview = codec.decode_preview(preview_source.encode("utf-8"), policy.stdout_preview_bytes)
-        if response_received:
+            if not response_received:
+                break
             try:
                 http.streamable_post_json(
                     url,
@@ -274,10 +285,31 @@ def probe_streamable_http_mcp_for_channel_capability_detailed(
                     protocol_version,
                     session_id,
                 )
+                initialized_failed = False
+                stderr_preview = ""
+                break
             except Exception as exc:
                 initialized_failed = True
                 capable = False
                 stderr_preview = f"{type(exc).__name__}: {exc}"[:policy.stderr_preview_chars]
+                if handshake_attempt != 0 or not codec.capability_present(response):
+                    break
+                services.log(
+                    "INFO",
+                    "channel_probe_streamable_http_handshake_retry "
+                    f"server={server_name} error={type(exc).__name__}: {exc}",
+                )
+                if session_id:
+                    http.delete_streamable_session(
+                        f"probe-{server_name}",
+                        url,
+                        headers,
+                        protocol_version,
+                        session_id,
+                        "channel_probe_retry_cleanup",
+                        timeout=min(10.0, max(1.0, effective_timeout)),
+                    )
+                session_id = None
         reason = "streamable_http_initialized_post_failed" if initialized_failed else (
             "capable" if capable else ("no_experimental_claude_channel" if response_received else "no_initialize_response")
         )

package/ciel_runtime_support/mcp_transport.py

@@ -8,7 +8,7 @@ import urllib.request
 from typing import Any
 
 
-MCP_STREAMABLE_HTTP_PROTOCOL_VERSION = "2025-03-26"
+MCP_STREAMABLE_HTTP_PROTOCOL_VERSION = "2025-11-25"
 MCP_LEGACY_SSE_PROTOCOL_VERSION = "2024-11-05"
 CODEX_MCP_SPLIT_PROXY_PREFIX = "/ca/codex-mcp/"
 
@@ -114,6 +114,18 @@ def streamable_post_json(
     return result, str(returned_session).strip() if returned_session else None
 
 
+def negotiated_protocol_version(result: Any, requested: str) -> str:
+    """Return the protocol revision selected by a legacy initialize exchange."""
+
+    if isinstance(result, dict):
+        payload = result.get("result")
+        if isinstance(payload, dict):
+            selected = str(payload.get("protocolVersion") or "").strip()
+            if selected:
+                return selected
+    return str(requested or MCP_STREAMABLE_HTTP_PROTOCOL_VERSION).strip()
+
+
 def split_proxy_server_name(path: str, prefix: str = CODEX_MCP_SPLIT_PROXY_PREFIX) -> str | None:
     if not path.startswith(prefix):
         return None
@@ -137,6 +149,7 @@ __all__ = [
     "MCP_LEGACY_SSE_PROTOCOL_VERSION",
     "MCP_STREAMABLE_HTTP_PROTOCOL_VERSION",
     "post_json_with_response_headers",
+    "negotiated_protocol_version",
     "read_sse_json_response",
     "split_proxy_server_name",
     "sse_post_json",

package/ciel_runtime_support/native_context_recovery.py

@@ -0,0 +1,72 @@
+"""Recover Anthropic-compatible requests rejected by an upstream context limit."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class ContextOverflow:
+    context_limit: int
+    message_tokens: int
+    completion_tokens: int
+
+
+_OVERFLOW_PATTERN = re.compile(
+    r"maximum context length is\s*(?P<limit>[\d,]+)\s*tokens?.*?"
+    r"requested\s*(?P<requested>[\d,]+)\s*tokens?\s*\(\s*"
+    r"(?P<messages>[\d,]+)\s*in the messages?,\s*"
+    r"(?P<completion>[\d,]+)\s*in the completion",
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+def _integer(value: str) -> int:
+    try:
+        return int(value.replace(",", ""))
+    except (TypeError, ValueError):
+        return 0
+
+
+def parse_context_overflow(raw: str | bytes | None) -> ContextOverflow | None:
+    text = raw.decode("utf-8", errors="ignore") if isinstance(raw, bytes) else str(raw or "")
+    match = _OVERFLOW_PATTERN.search(text)
+    if not match:
+        return None
+    limit = _integer(match.group("limit"))
+    messages = _integer(match.group("messages"))
+    completion = _integer(match.group("completion"))
+    if limit <= 0 or messages <= 0 or completion <= 0:
+        return None
+    return ContextOverflow(limit, messages, completion)
+
+
+def recover_output_budget(
+    body: dict[str, Any],
+    raw: str | bytes | None,
+    *,
+    reserve_tokens: int = 0,
+    minimum_output_tokens: int = 256,
+) -> dict[str, Any] | None:
+    """Reduce only the output reservation when the prompt itself still fits."""
+
+    overflow = parse_context_overflow(raw)
+    if overflow is None:
+        return None
+    reserve = max(0, int(reserve_tokens or 0))
+    minimum = max(1, int(minimum_output_tokens or 1))
+    available = overflow.context_limit - overflow.message_tokens - reserve
+    if available < minimum:
+        return None
+    requested = int(body.get("max_tokens") or overflow.completion_tokens)
+    adjusted = min(requested, overflow.completion_tokens, available)
+    if adjusted >= requested:
+        return None
+    recovered = dict(body)
+    recovered["max_tokens"] = adjusted
+    return recovered
+
+
+__all__ = ["ContextOverflow", "parse_context_overflow", "recover_output_budget"]