@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

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"]

package/ciel_runtime_support/ollama_catalog_context.py

@@ -0,0 +1,213 @@
+"""Ollama catalog persistence and context-metadata bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from . import ollama_catalog as policy
+from .ollama_catalog_repository import OllamaCatalogRepository
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaCatalogRepositoryPorts:
+    path: Path
+    log: Callable[[str, str], None]
+    with_user_agent: Callable[[dict[str, str] | None], dict[str, str]]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaCatalogProjectionPorts:
+    normalize_model: Callable[[str, str], str]
+    unique_models: Callable[[list[str]], list[str]]
+    sorted_models: Callable[[list[str]], list[str]]
+    model_lookup_ids: Callable[[str], list[str]]
+    positive_int: Callable[[Any], int | None]
+    catalog_url: str
+    default_ttl_seconds: int
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaCatalogWorkflowPorts:
+    load: Callable[[], dict[str, Any]]
+    save: Callable[[dict[str, Any]], None]
+    fetch_json: Callable[[str, float], Any]
+    fetch_context_map: Callable[[str, float], tuple[dict[str, int], str | None]]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaCatalogContext:
+    repository_ports: OllamaCatalogRepositoryPorts
+    projection: OllamaCatalogProjectionPorts
+    workflow: OllamaCatalogWorkflowPorts
+
+    def repository(self) -> OllamaCatalogRepository:
+        return OllamaCatalogRepository(
+            self.repository_ports.path,
+            self.repository_ports.log,
+            self.repository_ports.with_user_agent,
+        )
+
+    def load(self) -> dict[str, Any]:
+        return self.repository().load()
+
+    def save(self, catalog: dict[str, Any]) -> None:
+        self.repository().save(catalog)
+
+    def model_ids(
+        self,
+        provider: str = "ollama-cloud",
+        catalog: dict[str, Any] | None = None,
+    ) -> list[str]:
+        source = catalog if isinstance(catalog, dict) else self.workflow.load()
+        return policy.catalog_model_ids(
+            source,
+            provider,
+            normalize_model_id=self.projection.normalize_model,
+            unique_model_ids=self.projection.unique_models,
+            sorted_model_ids=self.projection.sorted_models,
+        )
+
+    def is_stale(
+        self, catalog: dict[str, Any], ttl_seconds: int | None = None
+    ) -> bool:
+        ttl = (
+            self.projection.default_ttl_seconds
+            if ttl_seconds is None
+            else ttl_seconds
+        )
+        return policy.catalog_is_stale(catalog, ttl)
+
+    def fetch_json(self, url: str, timeout: float = 12.0) -> Any:
+        return self.repository().fetch_json(url, timeout)
+
+    def fetch_context_map(
+        self, base_model: str, timeout: float = 10.0
+    ) -> tuple[dict[str, int], str | None]:
+        return self.repository().fetch_library_context_map(base_model, timeout)
+
+    def refresh(
+        self, include_contexts: bool = True, timeout: float = 10.0
+    ) -> dict[str, Any]:
+        return policy.refresh_model_catalog(
+            policy.OllamaCatalogRefreshServices(
+                load_catalog=self.workflow.load,
+                fetch_catalog=self.workflow.fetch_json,
+                fetch_context_map=self.workflow.fetch_context_map,
+                save_catalog=self.workflow.save,
+                positive_int=self.projection.positive_int,
+            ),
+            include_contexts=include_contexts,
+            timeout=timeout,
+            catalog_url=self.projection.catalog_url,
+        )
+
+    def context_for_model(
+        self, model_id: str
+    ) -> tuple[int | None, str | None, str | None]:
+        return policy.catalog_context_for_model(
+            self.workflow.load(), model_id, self.projection.model_lookup_ids
+        )
+
+    def timeout_for_model(self, model_id: str) -> int | None:
+        return policy.catalog_timeout_for_model(
+            self.workflow.load(), model_id, self.projection.model_lookup_ids
+        )
+
+    def update_context(
+        self,
+        model_id: str,
+        limit: int,
+        matched_model: str | None,
+        source_url: str | None,
+    ) -> None:
+        self.workflow.save(
+            policy.with_updated_context(
+                self.workflow.load(),
+                model_id,
+                limit,
+                matched_model,
+                source_url,
+            )
+        )
+
+    def fetch_context_limit(
+        self, model_id: str, timeout: float = 6.0
+    ) -> tuple[int | None, str | None, str | None]:
+        return policy.fetch_library_context_limit(
+            model_id,
+            timeout=timeout,
+            fetch_context_map=self.workflow.fetch_context_map,
+            positive_int=self.projection.positive_int,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaCatalogCompatibilityApi:
+    context: Callable[[], OllamaCatalogContext]
+
+    def repository(self) -> OllamaCatalogRepository:
+        return self.context().repository()
+
+    def load(self) -> dict[str, Any]:
+        return self.context().load()
+
+    def save(self, catalog: dict[str, Any]) -> None:
+        self.context().save(catalog)
+
+    def model_ids(
+        self,
+        provider: str = "ollama-cloud",
+        catalog: dict[str, Any] | None = None,
+    ) -> list[str]:
+        return self.context().model_ids(provider, catalog)
+
+    def is_stale(
+        self, catalog: dict[str, Any], ttl_seconds: int | None = None
+    ) -> bool:
+        return self.context().is_stale(catalog, ttl_seconds)
+
+    def fetch_json(self, url: str, timeout: float = 12.0) -> Any:
+        return self.context().fetch_json(url, timeout)
+
+    def fetch_context_map(
+        self, base_model: str, timeout: float = 10.0
+    ) -> tuple[dict[str, int], str | None]:
+        return self.context().fetch_context_map(base_model, timeout)
+
+    def refresh(
+        self, include_contexts: bool = True, timeout: float = 10.0
+    ) -> dict[str, Any]:
+        return self.context().refresh(include_contexts, timeout)
+
+    def context_for_model(
+        self, model_id: str
+    ) -> tuple[int | None, str | None, str | None]:
+        return self.context().context_for_model(model_id)
+
+    def timeout_for_model(self, model_id: str) -> int | None:
+        return self.context().timeout_for_model(model_id)
+
+    def update_context(
+        self,
+        model_id: str,
+        limit: int,
+        matched_model: str | None,
+        source_url: str | None,
+    ) -> None:
+        self.context().update_context(model_id, limit, matched_model, source_url)
+
+    def fetch_context_limit(
+        self, model_id: str, timeout: float = 6.0
+    ) -> tuple[int | None, str | None, str | None]:
+        return self.context().fetch_context_limit(model_id, timeout)
+
+
+__all__ = [
+    "OllamaCatalogCompatibilityApi",
+    "OllamaCatalogContext",
+    "OllamaCatalogProjectionPorts",
+    "OllamaCatalogRepositoryPorts",
+    "OllamaCatalogWorkflowPorts",
+]

package/ciel_runtime_support/ollama_stream_collection.py

@@ -0,0 +1,103 @@
+"""Collect an Ollama chat stream into one response, cutting loops short.
+
+The Codex-facing collection path asks providers for a single complete message.
+Asking Ollama for it with ``stream: false`` means a repetition loop is generated
+in full before the router ever sees a character of it -- the reported case ran
+for four minutes and produced 142,635 characters of the same 37-character block.
+Nothing downstream can undo that; the time and the tokens are already spent.
+
+Reading the same request as a stream costs nothing extra and makes the loop
+observable while it is still being written, so the guard can close the
+connection after a couple of thousand characters. The assembled result is the
+same envelope ``decode_ollama_chat_response`` already expects, so every stage
+after collection is unchanged.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from .runaway_output_guard import (
+    RunawayOutputDetector,
+    RunawayOutputPolicy,
+    RunawayVerdict,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaStreamCollection:
+    response: dict[str, Any]
+    verdict: RunawayVerdict | None = None
+    chunks: int = 0
+
+
+def collect_ollama_chat_stream(
+    lines: Iterable[Any], policy: RunawayOutputPolicy | None = None
+) -> OllamaStreamCollection:
+    """Merge Ollama NDJSON chunks into one response envelope.
+
+    Returns as soon as the guard reports a loop, leaving the rest of the stream
+    unread so the caller can close the connection and stop generation.
+    """
+
+    text_runaway = RunawayOutputDetector(policy)
+    thinking_runaway = RunawayOutputDetector(policy)
+    verdict: RunawayVerdict | None = None
+    content: list[str] = []
+    thinking: list[str] = []
+    tool_calls: list[dict[str, Any]] = []
+    response: dict[str, Any] = {}
+    chunks = 0
+    for raw in lines:
+        line = raw.decode("utf-8", errors="ignore").strip() if isinstance(raw, bytes) else str(raw).strip()
+        if not line:
+            continue
+        try:
+            chunk = json.loads(line)
+        except ValueError:
+            continue
+        if not isinstance(chunk, dict):
+            continue
+        chunks += 1
+        for key in ("model", "created_at", "done", "done_reason"):
+            if chunk.get(key) is not None:
+                response[key] = chunk[key]
+        for key in ("prompt_eval_count", "eval_count", "total_duration"):
+            try:
+                value = int(chunk.get(key) or 0)
+            except (TypeError, ValueError):
+                continue
+            if value:
+                response[key] = max(int(response.get(key) or 0), value)
+        message = chunk.get("message")
+        if not isinstance(message, dict):
+            continue
+        text_chunk = str(message.get("content") or "")
+        thinking_chunk = str(message.get("thinking") or "")
+        if text_chunk:
+            content.append(text_chunk)
+            verdict = verdict or text_runaway.feed(text_chunk)
+        if thinking_chunk:
+            thinking.append(thinking_chunk)
+            verdict = verdict or thinking_runaway.feed(thinking_chunk)
+        for call in message.get("tool_calls") or []:
+            if isinstance(call, dict):
+                tool_calls.append(call)
+        if verdict is not None:
+            break
+    collected: dict[str, Any] = {"role": "assistant", "content": "".join(content)}
+    if thinking:
+        collected["thinking"] = "".join(thinking)
+    if tool_calls:
+        collected["tool_calls"] = tool_calls
+    response["message"] = collected
+    response.setdefault("done", True)
+    return OllamaStreamCollection(response=response, verdict=verdict, chunks=chunks)
+
+
+__all__ = [
+    "OllamaStreamCollection",
+    "collect_ollama_chat_stream",
+]

package/ciel_runtime_support/ollama_thinking.py

@@ -131,8 +131,13 @@ class OllamaThinkingPolicy:
             str(item).strip().lower()
             for item in options.get("ollama_model_capabilities") or []
         }
-        if "thinking" in capabilities or options.get("think_explicit"):
+        if options.get("think_explicit"):
             return bool(options.get("think", False))
+        if "thinking" in capabilities:
+            if thinking_disabled(request):
+                return False
+            if effort:
+                return True
         return None