@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/advisor_request_builder.py

@@ -37,12 +37,7 @@ class AdvisorBudgetPorts:
     reserve: Callable[[dict[str, Any], int], int]
     compact_messages: Callable[..., list[dict[str, Any]]]
     configured_output: Callable[..., int]
-    ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
-    positive_int: Callable[[Any], int]
-    ollama_num_ctx: Callable[..., int]
-    think_value: Callable[
-        [str, str | None, dict[str, Any], dict[str, Any]], bool | str | None
-    ]
+    apply_ollama_optional: Callable[..., dict[str, Any]]
 
 
 @dataclass(frozen=True, slots=True)
@@ -208,22 +203,14 @@ class AdvisorRequestBuilder:
             "messages": messages,
             "stream": False,
         }
-        think = self.budget.think_value(provider, upstream_model, config, body)
-        if think is not None:
-            request["think"] = think
-        options = self.budget.ollama_options(config)
-        options.setdefault(
-            "num_predict",
-            min(4096, self.budget.positive_int(options.get("num_predict")) or 4096),
+        return self.budget.apply_ollama_optional(
+            request,
+            provider,
+            upstream_model,
+            config,
+            body,
+            output_limit=4096,
         )
-        num_ctx = self.budget.ollama_num_ctx(
-            config, {"messages": messages, "tools": []}
-        )
-        if num_ctx:
-            options.setdefault("num_ctx", num_ctx)
-        if options:
-            request["options"] = options
-        return request
 
     @staticmethod
     def _sampling_options(

package/ciel_runtime_support/anthropic_tool_turns.py

@@ -9,8 +9,6 @@ from typing import Any
 
 @dataclass(frozen=True, slots=True)
 class AnthropicToolTurnServices:
-    tool_use_as_text: Callable[[dict[str, Any]], dict[str, str]]
-    tool_result_as_text: Callable[[dict[str, Any]], dict[str, str]]
     log: Callable[[str, str], Any]
 
 
@@ -19,7 +17,14 @@ def normalize_historical_anthropic_tool_turns(
     body: dict[str, Any],
     services: AnthropicToolTurnServices,
 ) -> dict[str, Any]:
-    """Downgrade unmatched historical tool blocks instead of synthesizing success."""
+    """Discard unmatched historical tool blocks instead of replaying them as text.
+
+    An unmatched tool block cannot be sent on provider wires that require strict
+    tool-use/result pairing.  Turning it into conversation text is also unsafe:
+    the model can treat the diagnostic, command, or stale result as a new user
+    instruction.  Keep valid pairs verbatim and report discarded history only
+    through the runtime log.
+    """
     messages = body.get("messages")
     if not isinstance(messages, list):
         return body
@@ -57,12 +62,12 @@ def normalize_historical_anthropic_tool_turns(
                 if isinstance(block, dict) and block.get("type") == "tool_use":
                     tool_id = str(block.get("id") or "")
                     if not tool_id or tool_id not in retained:
-                        next_content.append(services.tool_use_as_text(block))
                         converted_tool_uses += 1
                         content_changed = True
                         continue
                 next_content.append(block)
-            normalized_messages.append(_with_content(message, next_content) if content_changed else message)
+            if next_content:
+                normalized_messages.append(_with_content(message, next_content) if content_changed else message)
             changed = changed or content_changed
             retained_tool_ids_for_next_user = retained
             continue
@@ -76,12 +81,12 @@ def normalize_historical_anthropic_tool_turns(
                     if tool_id and tool_id in retained_tool_ids_for_next_user:
                         next_content.append(block)
                     else:
-                        next_content.append(services.tool_result_as_text(block))
                         converted_tool_results += 1
                         content_changed = True
                     continue
                 next_content.append(block)
-            normalized_messages.append(_with_content(message, next_content) if content_changed else message)
+            if next_content:
+                normalized_messages.append(_with_content(message, next_content) if content_changed else message)
             changed = changed or content_changed
             retained_tool_ids_for_next_user = set()
             continue
@@ -95,7 +100,7 @@ def normalize_historical_anthropic_tool_turns(
     out["messages"] = normalized_messages
     services.log(
         "WARN",
-        "normalized historical Anthropic tool turns for provider=%s converted_tool_uses=%d converted_tool_results=%d"
+        "discarded unmatched historical Anthropic tool blocks for provider=%s tool_uses=%d tool_results=%d"
         % (provider, converted_tool_uses, converted_tool_results),
     )
     return out

package/ciel_runtime_support/architecture.py

@@ -152,6 +152,8 @@ class ProviderModelCatalogPolicy:
     allow_configured_fallback: bool = False
     allow_public_without_auth: bool = False
     use_bundled_catalog_fallback: bool = False
+    authoritative_upstream_catalog: bool = False
+    supplemental_model_aliases: tuple[tuple[str, str], ...] = ()
 
 
 @dataclass(frozen=True)
@@ -220,6 +222,14 @@ class ProviderOptionPresentationPolicy:
     show_ip_family_control: bool = False
 
 
+@dataclass(frozen=True)
+class HostedToolPolicy:
+    """Provider-owned hosted tool catalog and execution endpoint."""
+
+    base_url: str = ""
+    formulas: tuple[str, ...] = ()
+
+
 @dataclass(frozen=True)
 class ProviderUiPolicy:
     """Provider-owned labels used by shared menus."""
@@ -269,6 +279,12 @@ class ProviderAdapter(ABC):
     def default_base_url(self) -> str:
         """Return the provider default API base URL."""
 
+    def anthropic_base_url(self, config: ProviderConfig) -> str:
+        """Return the base URL used for native Anthropic Messages requests."""
+
+        del config
+        return self.default_base_url()
+
     def normalize_base_url(self, value: str) -> str:
         """Normalize a user-supplied endpoint before it is persisted."""
 
@@ -365,6 +381,17 @@ class ProviderAdapter(ABC):
         del model
         return self.capabilities(config).supports_tool_choice
 
+    def supports_tool_choice_for_request(
+        self,
+        config: ProviderConfig,
+        model: str | None,
+        request: Mapping[str, Any],
+    ) -> bool:
+        """Return whether this request may include an explicit tool choice."""
+
+        del request
+        return self.supports_tool_choice(config, model)
+
     def normalizes_anthropic_tool_use(
         self,
         config: ProviderConfig,
@@ -392,6 +419,28 @@ class ProviderAdapter(ABC):
         del config, model
         return False
 
+    def reasoning_passback_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        """Whether provider-native reasoning should survive history conversion."""
+
+        return self.openai_reasoning_passback_enabled(config, model)
+
+    def hosted_tool_policy(self, config: ProviderConfig) -> HostedToolPolicy:
+        del config
+        return HostedToolPolicy()
+
+    def should_omit_openai_tool_choice(
+        self,
+        config: ProviderConfig,
+        model: str | None,
+        request: Mapping[str, Any],
+    ) -> bool:
+        """Whether this provider/model cannot combine reasoning with tool_choice."""
+
+        del request
+        return self.openai_reasoning_passback_enabled(config, model)
+
     def model_catalog_policy(self, config: ProviderConfig) -> ProviderModelCatalogPolicy:
         del config
         return ProviderModelCatalogPolicy()
@@ -589,6 +638,12 @@ class ProviderAdapter(ABC):
         del config
         return False
 
+    def supports_server_web_tools(self, config: ProviderConfig) -> bool:
+        """Whether this provider can execute Claude's server-side web tools."""
+
+        del config
+        return False
+
     def context_compaction_available(self, config: ProviderConfig) -> bool:
         """Whether this configured provider can run an auxiliary summary request."""
 
@@ -617,6 +672,19 @@ class ProviderAdapter(ABC):
         del config
         return request
 
+    def anthropic_system_role_strategy(
+        self, config: ProviderConfig
+    ) -> Literal["inline_user", "hoist_top_level"]:
+        """Choose how non-standard system-role history is made wire-valid.
+
+        Keeping the item at its original position protects the stable prefix
+        used by provider-side context caches.  Compatibility servers that only
+        accept top-level system context may opt into hoisting explicitly.
+        """
+
+        del config
+        return "inline_user"
+
     def openai_reasoning_effort(
         self, config: ProviderConfig, model: str, request: Mapping[str, Any]
     ) -> str | None:

package/ciel_runtime_support/architecture_budget.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 
 FINAL_FILE_LINE_BUDGET = 4_999
-MAIN_FILE_LINE_BUDGET = 12_989
+MAIN_FILE_LINE_BUDGET = 4_980
 
 
 def production_python_files(root: Path) -> tuple[Path, ...]:

package/ciel_runtime_support/channel_connection_context.py

@@ -0,0 +1,233 @@
+"""Channel connection registry, worker, and lifecycle bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .channel_connection_lifecycle import (
+    ChannelConnectionLifecycle,
+    ChannelConnectionLifecycleEffects,
+    ChannelConnectionLifecyclePolicy,
+    ChannelConnectionLifecycleStore,
+)
+from .channel_connection_registry import ChannelConnectionRegistry
+from .channel_connection_worker import (
+    ChannelConnectionWorker,
+    ChannelWorkerEffects,
+    ChannelWorkerPolicy,
+    ChannelWorkerStateStore,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionStatePorts:
+    connections: dict[str, dict[str, Any]]
+    lock: Any
+    rpc_condition: Any
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionWorkerPorts:
+    log: Callable[[str, str], None]
+    dispatch: Callable[..., Any]
+    initialize_streamable: Callable[[str], None]
+    close_state_session: Callable[[dict[str, Any], str], bool]
+    streamable_headers: Callable[..., dict[str, str]]
+    session_not_found: Callable[..., bool]
+    http_error_body: Callable[..., str]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionLifecyclePorts:
+    safe_segment: Callable[[Any], str]
+    close_session: Callable[[dict[str, Any], str], bool]
+    cleanup_stale_sessions: Callable[..., None]
+    parse_bool: Callable[..., bool]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionProtocol:
+    streamable_version: str
+    legacy_sse_version: str
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionContext:
+    state: ChannelConnectionStatePorts
+    worker_ports: ChannelConnectionWorkerPorts
+    lifecycle_ports: ChannelConnectionLifecyclePorts
+    protocol: ChannelConnectionProtocol
+
+    def registry(self) -> ChannelConnectionRegistry:
+        return ChannelConnectionRegistry(
+            states=self.state.connections,
+            lock=self.state.lock,
+            rpc_condition=self.state.rpc_condition,
+            log=self.worker_ports.log,
+        )
+
+    def statuses(self) -> dict[str, Any]:
+        return self.registry().statuses()
+
+    def update(self, name: str, **updates: Any) -> None:
+        self.registry().update(name, **updates)
+
+    def mark_session_lost(self, name: str, reason: str) -> None:
+        self.registry().mark_session_lost(name, reason)
+
+    def store_rpc_response(self, name: str, data_text: str) -> bool:
+        return self.registry().store_rpc_response(name, data_text)
+
+    def take_rpc_response(
+        self, name: str, rpc_id: Any, timeout: float
+    ) -> dict[str, Any] | None:
+        return self.registry().take_rpc_response(name, rpc_id, timeout)
+
+    def state_name_for_mcp_server(self, server_name: str) -> str | None:
+        return self.registry().state_name_for_mcp_server(server_name)
+
+    def connection_matches(
+        self, state: dict[str, Any], connection_id: str | None
+    ) -> bool:
+        if not connection_id:
+            return True
+        return str(state.get("connection_id") or "") == str(connection_id)
+
+    def worker_running(self, name: str, connection_id: str | None) -> bool:
+        with self.state.lock:
+            state = self.state.connections.get(name)
+            return bool(
+                state
+                and state.get("running")
+                and self.connection_matches(state, connection_id)
+            )
+
+    def worker(self) -> ChannelConnectionWorker:
+        ports = self.worker_ports
+        return ChannelConnectionWorker(
+            state_store=ChannelWorkerStateStore(
+                self.state.connections, self.state.lock
+            ),
+            effects=ChannelWorkerEffects(
+                log=ports.log,
+                dispatch=ports.dispatch,
+                set_state=self.update,
+                initialize_streamable=ports.initialize_streamable,
+                close_state_session=ports.close_state_session,
+                streamable_headers=ports.streamable_headers,
+                session_not_found=ports.session_not_found,
+                http_error_body=ports.http_error_body,
+            ),
+            policy=ChannelWorkerPolicy(
+                streamable_protocol_version=self.protocol.streamable_version,
+                legacy_sse_protocol_version=self.protocol.legacy_sse_version,
+                parse_bool=self.lifecycle_ports.parse_bool,
+            ),
+        )
+
+    def run_sse_worker(
+        self, name: str, connection_id: str | None = None
+    ) -> None:
+        self.worker().run_sse(name, connection_id)
+
+    def run_streamable_http_worker(
+        self, name: str, connection_id: str | None = None
+    ) -> None:
+        self.worker().run_streamable_http(name, connection_id)
+
+    def lifecycle(self) -> ChannelConnectionLifecycle:
+        ports = self.lifecycle_ports
+        return ChannelConnectionLifecycle(
+            store=ChannelConnectionLifecycleStore(
+                self.state.connections, self.state.lock
+            ),
+            effects=ChannelConnectionLifecycleEffects(
+                safe_segment=ports.safe_segment,
+                close_session=ports.close_session,
+                cleanup_stale_sessions=ports.cleanup_stale_sessions,
+                public_status=ChannelConnectionRegistry.public_status,
+                all_statuses=self.statuses,
+                sse_worker=self.run_sse_worker,
+                streamable_http_worker=self.run_streamable_http_worker,
+            ),
+            policy=ChannelConnectionLifecyclePolicy(
+                streamable_protocol_version=self.protocol.streamable_version,
+                legacy_sse_protocol_version=self.protocol.legacy_sse_version,
+                parse_bool=ports.parse_bool,
+            ),
+        )
+
+    def start(self, config: dict[str, Any]) -> dict[str, Any]:
+        return self.lifecycle().start(config)
+
+    def stop(self, name: str | None = None) -> dict[str, Any]:
+        return self.lifecycle().stop(name)
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionCompatibilityApi:
+    context: Callable[[], ChannelConnectionContext]
+
+    def registry(self) -> ChannelConnectionRegistry:
+        return self.context().registry()
+
+    def statuses(self) -> dict[str, Any]:
+        return self.context().statuses()
+
+    def update(self, name: str, **updates: Any) -> None:
+        self.context().update(name, **updates)
+
+    def mark_session_lost(self, name: str, reason: str) -> None:
+        self.context().mark_session_lost(name, reason)
+
+    def store_rpc_response(self, name: str, data_text: str) -> bool:
+        return self.context().store_rpc_response(name, data_text)
+
+    def take_rpc_response(
+        self, name: str, rpc_id: Any, timeout: float
+    ) -> dict[str, Any] | None:
+        return self.context().take_rpc_response(name, rpc_id, timeout)
+
+    def state_name_for_mcp_server(self, server_name: str) -> str | None:
+        return self.context().state_name_for_mcp_server(server_name)
+
+    def connection_matches(
+        self, state: dict[str, Any], connection_id: str | None
+    ) -> bool:
+        return self.context().connection_matches(state, connection_id)
+
+    def worker_running(self, name: str, connection_id: str | None) -> bool:
+        return self.context().worker_running(name, connection_id)
+
+    def worker(self) -> ChannelConnectionWorker:
+        return self.context().worker()
+
+    def run_sse_worker(
+        self, name: str, connection_id: str | None = None
+    ) -> None:
+        self.context().run_sse_worker(name, connection_id)
+
+    def run_streamable_http_worker(
+        self, name: str, connection_id: str | None = None
+    ) -> None:
+        self.context().run_streamable_http_worker(name, connection_id)
+
+    def lifecycle(self) -> ChannelConnectionLifecycle:
+        return self.context().lifecycle()
+
+    def start(self, config: dict[str, Any]) -> dict[str, Any]:
+        return self.context().start(config)
+
+    def stop(self, name: str | None = None) -> dict[str, Any]:
+        return self.context().stop(name)
+
+
+__all__ = [
+    "ChannelConnectionCompatibilityApi",
+    "ChannelConnectionContext",
+    "ChannelConnectionLifecyclePorts",
+    "ChannelConnectionProtocol",
+    "ChannelConnectionStatePorts",
+    "ChannelConnectionWorkerPorts",
+]