@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

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
 
 

package/ciel_runtime_support/ollama_wire_projection.py

@@ -0,0 +1,157 @@
+"""Project provider-owned Ollama request settings onto wire payloads.
+
+The application uses several Ollama request paths (interactive forwarding,
+Advisor, and optional LLM compaction).  This policy is their single boundary
+for optional model/runtime settings.  It deliberately distinguishes required
+protocol fields from explicit operator overrides so persisted adapter defaults
+do not silently become upstream request parameters.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaWireProjectionPorts:
+    think_value: Callable[
+        [str, str | None, dict[str, Any], Mapping[str, Any]], bool | str | None
+    ]
+    positive_int: Callable[[Any], int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaWireProjection:
+    ports: OllamaWireProjectionPorts
+    legacy_keep_alive_default: str = "5m"
+
+    @staticmethod
+    def _marked_keys(config: Mapping[str, Any], name: str) -> set[str]:
+        raw = config.get(name)
+        if not isinstance(raw, (list, tuple, set)):
+            return set()
+        return {str(item) for item in raw if str(item).strip()}
+
+    def explicit_options(self, config: Mapping[str, Any]) -> dict[str, Any]:
+        raw = config.get("ollama_options")
+        if not isinstance(raw, Mapping):
+            return {}
+        allowed = self._marked_keys(
+            config, "ollama_explicit_options"
+        ) | self._marked_keys(config, "ollama_transient_options")
+        return {
+            str(key): value
+            for key, value in raw.items()
+            if str(key) in allowed and value is not None
+        }
+
+    def keep_alive(self, config: Mapping[str, Any]) -> str | None:
+        value = config.get("keep_alive")
+        if value is None or str(value).strip() == "":
+            return None
+        if config.get("keep_alive_explicit"):
+            return str(value)
+        # Before provenance markers existed, any non-default persisted value
+        # could only have come from an operator edit.  Preserve that intent.
+        if str(value) != self.legacy_keep_alive_default:
+            return str(value)
+        return None
+
+    def options(
+        self,
+        config: Mapping[str, Any],
+        *,
+        output_limit: int | None = None,
+    ) -> dict[str, Any]:
+        options = self.explicit_options(config)
+        raw_num_ctx = config.get("num_ctx", "auto")
+        if not (
+            isinstance(raw_num_ctx, str)
+            and raw_num_ctx.strip().lower() in {"", "auto", "dynamic"}
+        ):
+            num_ctx = self.ports.positive_int(raw_num_ctx)
+            if num_ctx:
+                options["num_ctx"] = num_ctx
+
+        output_is_explicit = bool(config.get("output_tokens_explicit")) or (
+            "num_predict"
+            in self._marked_keys(config, "ollama_transient_options")
+        )
+        if output_is_explicit:
+            configured = self.ports.positive_int(
+                options.get("num_predict")
+                or config.get("max_output_tokens")
+            )
+            limit = self.ports.positive_int(output_limit)
+            if configured and limit:
+                options["num_predict"] = min(configured, limit)
+            elif configured:
+                options["num_predict"] = configured
+            elif limit:
+                options["num_predict"] = limit
+        else:
+            options.pop("num_predict", None)
+        return options
+
+    def apply(
+        self,
+        request: dict[str, Any],
+        provider: str,
+        model: str | None,
+        config: dict[str, Any],
+        source_request: Mapping[str, Any] | None = None,
+        *,
+        output_limit: int | None = None,
+    ) -> dict[str, Any]:
+        projected = dict(request)
+        think = self.ports.think_value(
+            provider, model, config, source_request or {}
+        )
+        if think is not None:
+            projected["think"] = think
+        keep_alive = self.keep_alive(config)
+        if keep_alive is not None:
+            projected["keep_alive"] = keep_alive
+        options = self.options(config, output_limit=output_limit)
+        if options:
+            projected["options"] = options
+        return projected
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaWireCompatibilityApi:
+    """Stable facade adapter backed by typed projection dependencies."""
+
+    think_value: Callable[
+        [str, str | None, dict[str, Any], Mapping[str, Any]], bool | str | None
+    ]
+    positive_int: Callable[[Any], int | None]
+
+    def apply(
+        self,
+        request: dict[str, Any],
+        provider: str,
+        model: str | None,
+        config: dict[str, Any],
+        source_request: Mapping[str, Any] | None = None,
+        *,
+        output_limit: int | None = None,
+    ) -> dict[str, Any]:
+        return OllamaWireProjection(
+            OllamaWireProjectionPorts(self.think_value, self.positive_int)
+        ).apply(
+            request,
+            provider,
+            model,
+            config,
+            source_request,
+            output_limit=output_limit,
+        )
+
+
+__all__ = [
+    "OllamaWireCompatibilityApi",
+    "OllamaWireProjection",
+    "OllamaWireProjectionPorts",
+]

package/ciel_runtime_support/openai_forwarding.py

@@ -73,6 +73,7 @@ class OpenAIForwardServices:
     advisor: OpenAIForwardAdvisor
     streaming: OpenAIForwardStreaming
     response: OpenAIForwardResponse
+    hosted_tools: Any
     log: Callable[[str, str], Any]
 
 
@@ -100,10 +101,19 @@ def forward_openai_compatible_chat(
     original_body = body
     upstream_body = request.body_with_advisor_tool(body, pcfg) if request.advisor_provider_supported(provider) else body
     url = request.join_url(request.upstream_request_base(provider, pcfg), "/v1/chat/completions")
+    timeout = rate_limit.request_timeout_seconds(pcfg)
+    headers = request.provider_headers(provider, pcfg, handler.headers, "openai_chat")
     waited, rpm_used, rpm_limit = rate_limit.apply(provider, pcfg, model)
     compatibility_test = str(handler.headers.get(policy.compatibility_test_header) or "").strip().lower() in ("1", "true", "yes", "on")
     stream_enabled = bool(pcfg.get("stream_enabled", True))
     stream = policy.provider_requires_streaming(provider, pcfg) or (bool(body.get("stream", stream_enabled)) and stream_enabled)
+    collected_request = request.build_chat_request(provider, model, upstream_body, pcfg, stream=False)
+    collected_request, hosted_state = services.hosted_tools.prepare(
+        provider, pcfg, collected_request, headers, timeout
+    )
+    if hosted_state.enabled and stream:
+        stream = False
+        services.log("INFO", f"provider-hosted tools enabled for {provider}; collecting tool rounds internally")
     if stream and advisor.model_enabled(pcfg) and request.advisor_provider_supported(provider):
         stream = False
         services.log("INFO", f"advisor tool enabled for {provider}; collecting this turn so advisor tool calls can be resolved internally")
@@ -128,10 +138,8 @@ def forward_openai_compatible_chat(
             upstream_response = streaming.open_with_retry(
                 url,
                 req_body,
-                request.provider_headers(
-                    provider, pcfg, handler.headers, "openai_chat"
-                ),
-                rate_limit.request_timeout_seconds(pcfg),
+                headers,
+                timeout,
                 provider,
                 pcfg,
                 model,
@@ -151,7 +159,6 @@ def forward_openai_compatible_chat(
             )
             if stream_ok:
                 response.mark_delivery_success(handler, "openai_stream_message_stop")
-                response.write_activity("success", provider, model, tokens=req_tokens, bytes=req_bytes, stream=True)
             else:
                 response.mark_delivery_failed(handler, "openai_stream_error")
         except RuntimeError as exc:
@@ -168,21 +175,36 @@ def forward_openai_compatible_chat(
             return
         return
 
-    req_body = request.build_chat_request(provider, model, upstream_body, pcfg, stream=False)
+    req_body = collected_request
     try:
         data = streaming.post_json_with_retry(
             url,
             req_body,
-            request.provider_headers(
-                provider, pcfg, handler.headers, "openai_chat"
-            ),
-            rate_limit.request_timeout_seconds(pcfg),
+            headers,
+            timeout,
             provider,
             pcfg,
             model,
             None,
             retry_rate_limits=not compatibility_test,
         )
+        data = services.hosted_tools.resolve(
+            hosted_state,
+            req_body,
+            data,
+            lambda next_body: streaming.post_json_with_retry(
+                url,
+                next_body,
+                headers,
+                timeout,
+                provider,
+                pcfg,
+                model,
+                None,
+                retry_rate_limits=not compatibility_test,
+            ),
+            timeout,
+        )
     except RuntimeError as exc:
         response.write_json(handler, {"type": "error", "error": {"type": "upstream_error", "message": str(exc)}}, 500)
         return

package/ciel_runtime_support/openai_responses_router.py

@@ -41,6 +41,10 @@ class OpenAIResponsesRouting:
     dump_request: Callable[..., Any]
     normalize_provider_wire: Callable[..., dict[str, Any]]
     collect_message: Callable[..., dict[str, Any]]
+    # Both belong here rather than with the conversions: each one's behaviour is
+    # decided by the routed-vs-native split this group already owns.
+    apply_codex_compat_instructions: Callable[..., dict[str, Any]]
+    recover_preamble_only_turn: Callable[..., dict[str, Any]]
 
 
 @dataclass(frozen=True, slots=True)
@@ -82,6 +86,11 @@ def handle_openai_responses_request(
     routing = services.routing
     delivery = services.delivery
     output = services.output
+    # Codex cannot receive --append-system-prompt, so the routed compatibility
+    # instruction has to ride along in the request itself. Do this before the
+    # conversion so it reaches both the translated path and a native Responses
+    # provider; the native Codex backend is excluded inside the port.
+    body = routing.apply_codex_compat_instructions(cfg, provider, pcfg, body)
     anthropic_body = conversion.to_anthropic(body, conversion.current_alias(cfg))
     if routing.maybe_import_session(
         handler,
@@ -146,6 +155,9 @@ def handle_openai_responses_request(
     )
     try:
         message = routing.collect_message(handler, provider, pcfg, anthropic_body)
+        message = routing.recover_preamble_only_turn(
+            handler, provider, pcfg, anthropic_body, message
+        )
         output.write_response(handler, message, source_body=body, stream=stream)
         delivery.mark_success(handler, "responses_json")
         delivery.commit(anthropic_body, handler)

package/ciel_runtime_support/package_lifecycle.py

@@ -3,12 +3,41 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+import ntpath
 import os
 from pathlib import Path
 import subprocess
 from typing import Callable
 
 
+def windows_executable_image_running(executable_name: str) -> bool:
+    """Return whether Windows currently has the executable image loaded.
+
+    npm replaces native package binaries in place. Windows rejects that copy
+    with EBUSY while any process is using the image, so the update must be
+    deferred instead of starting an install that cannot complete.
+    """
+
+    if os.name != "nt":
+        return False
+    image_name = ntpath.basename(executable_name)
+    if not image_name.casefold().endswith(".exe"):
+        image_name += ".exe"
+    try:
+        result = subprocess.run(
+            ["tasklist", "/FI", f"IMAGENAME eq {image_name}", "/FO", "CSV", "/NH"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return False
+    expected = f'"{image_name}"'.casefold()
+    return any(line.strip().casefold().startswith(expected) for line in result.stdout.splitlines())
+
+
 @dataclass(frozen=True, slots=True)
 class NpmPackageLifecyclePorts:
     find_executable: Callable[[str], str | None]
@@ -98,6 +127,15 @@ class NpmPackageLifecycle:
         if current and not self._ports.version_newer(latest, current):
             self._print(f"{label} is up to date ({current}).")
             return executable
+        if executable_name.casefold() == "codex" and windows_executable_image_running(
+            executable_name
+        ):
+            self._print(
+                f"{label} update deferred: {executable_name}.exe is currently running and "
+                "Windows has locked the executable. Continuing with the current version; "
+                "the update will be retried on a later launch."
+            )
+            return executable
         self._print(f"{label} update available: {current or 'unknown'} -> {latest}; upgrading automatically.")
         prefix = self._ports.install_prefix()
         if prefix is not None:
@@ -214,4 +252,5 @@ __all__ = [
     "NpmPackageLifecyclePorts",
     "SelfUpdateLifecycle",
     "SelfUpdatePorts",
+    "windows_executable_image_running",
 ]