@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

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

package/ciel_runtime_support/prelaunch_assembly.py

@@ -0,0 +1,37 @@
+"""Compose the prelaunch application service from bounded UI port groups."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import prelaunch
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchAssembly:
+    terminal: prelaunch.PrelaunchTerminal
+    config: prelaunch.PrelaunchConfig
+    launch_policy: prelaunch.PrelaunchLaunchPolicy
+    panel_rows: prelaunch.PrelaunchPanelRows
+    channel_query: prelaunch.PrelaunchChannelQuery
+    channel_commands: prelaunch.PrelaunchChannelCommands
+    mutations: prelaunch.PrelaunchMutations
+    secrets: prelaunch.PrelaunchSecrets
+    options: prelaunch.PrelaunchOptions
+
+    def services(self) -> prelaunch.PrelaunchServices:
+        return prelaunch.PrelaunchServices(
+            constants=prelaunch.build_default_prelaunch_constants(),
+            terminal=self.terminal,
+            config=self.config,
+            launch_policy=self.launch_policy,
+            panel_rows=self.panel_rows,
+            channel_query=self.channel_query,
+            channel_commands=self.channel_commands,
+            mutations=self.mutations,
+            secrets=self.secrets,
+            options=self.options,
+        )
+
+
+__all__ = ["PrelaunchAssembly"]