@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/provider_runtime_modes.py

@@ -0,0 +1,150 @@
+"""Runtime routing and provider-native compatibility policies."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from ciel_runtime_support.providers.constants import OPENCODE_PROVIDER_NAMES
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeModePolicy:
+    parse_bool: Callable[..., bool]
+    runtime_providers: Mapping[str, str]
+
+    def native_enabled(self, runtime: str, provider: str) -> bool:
+        return provider == self.runtime_providers.get(runtime)
+
+    def routed_enabled(
+        self, runtime: str, provider: str, config: dict[str, Any]
+    ) -> bool:
+        return self.native_enabled(runtime, provider) and self.parse_bool(
+            config.get("route_through_router"), default=False
+        )
+
+    def direct_enabled(
+        self, runtime: str, provider: str, config: dict[str, Any]
+    ) -> bool:
+        return self.native_enabled(runtime, provider) and not self.routed_enabled(
+            runtime, provider, config
+        )
+
+    def label(self, provider: str, config: dict[str, Any]) -> str:
+        for runtime in ("anthropic", "agy", "codex"):
+            if self.direct_enabled(runtime, provider, config):
+                return f"{runtime}-native"
+            if self.routed_enabled(runtime, provider, config):
+                return f"{runtime}-routed"
+        return "ciel-runtime-router"
+
+    def native_anthropic(self, provider: str) -> bool:
+        return self.native_enabled("anthropic", provider)
+
+    def anthropic_routed(
+        self, provider: str, config: dict[str, Any]
+    ) -> bool:
+        return self.routed_enabled("anthropic", provider, config)
+
+    def direct_anthropic(
+        self, provider: str, config: dict[str, Any]
+    ) -> bool:
+        return self.direct_enabled("anthropic", provider, config)
+
+    def native_agy(self, provider: str) -> bool:
+        return self.native_enabled("agy", provider)
+
+    def agy_routed(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.routed_enabled("agy", provider, config)
+
+    def direct_agy(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.direct_enabled("agy", provider, config)
+
+    def native_codex(self, provider: str) -> bool:
+        return self.native_enabled("codex", provider)
+
+    def codex_routed(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.routed_enabled("codex", provider, config)
+
+    def direct_codex(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.direct_enabled("codex", provider, config)
+
+
+def build_default_runtime_mode_policy(
+    parse_bool: Callable[..., bool],
+) -> RuntimeModePolicy:
+    """Build the standard native runtime-to-provider mapping."""
+    return RuntimeModePolicy(
+        parse_bool=parse_bool,
+        runtime_providers={
+            "anthropic": "anthropic",
+            "agy": "agy",
+            "codex": "codex",
+        },
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderNativeCompatibilityPolicy:
+    native_enabled: Callable[[str, dict[str, Any]], bool]
+    compatibility_groups: Mapping[str, frozenset[str]]
+
+    def group_enabled(
+        self, group: str, provider: str, config: dict[str, Any]
+    ) -> bool:
+        return (
+            provider in self.compatibility_groups[group]
+            and self.native_enabled(provider, config)
+        )
+
+    def ollama(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("ollama", provider, config)
+
+    def vllm(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("vllm", provider, config)
+
+    def nim(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("nim", provider, config)
+
+    def lm_studio(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("lm_studio", provider, config)
+
+    def nvidia(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("nvidia", provider, config)
+
+    def deepseek(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("deepseek", provider, config)
+
+    def opencode(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("opencode", provider, config)
+
+    def kimi(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("kimi", provider, config)
+
+    def zai(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("zai", provider, config)
+
+    def fireworks(self, provider: str, config: dict[str, Any]) -> bool:
+        return self.group_enabled("fireworks", provider, config)
+
+
+def build_default_native_compatibility_policy(
+    native_enabled: Callable[[str, dict[str, Any]], bool],
+) -> ProviderNativeCompatibilityPolicy:
+    """Build the provider families supported by native compatibility mode."""
+    return ProviderNativeCompatibilityPolicy(
+        native_enabled=native_enabled,
+        compatibility_groups={
+            "ollama": frozenset({"ollama"}),
+            "vllm": frozenset({"vllm"}),
+            "nim": frozenset({"self-hosted-nim"}),
+            "lm_studio": frozenset({"lm-studio"}),
+            "nvidia": frozenset({"nvidia-hosted"}),
+            "deepseek": frozenset({"deepseek"}),
+            "opencode": frozenset(OPENCODE_PROVIDER_NAMES),
+            "kimi": frozenset({"kimi"}),
+            "zai": frozenset({"zai"}),
+            "fireworks": frozenset({"fireworks"}),
+        },
+    )

package/ciel_runtime_support/provider_sampling_policy.py

@@ -0,0 +1,46 @@
+"""Provider sampling option normalization and validation policy."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .config_value_codec import finite_float, positive_int
+
+
+class ProviderSamplingPolicy:
+    """Canonicalize and validate provider-independent sampling options."""
+
+    _ALIASES = {
+        "temp": "temperature",
+        "temperature": "temperature",
+        "top": "top_p",
+        "top_p": "top_p",
+        "topp": "top_p",
+        "topk": "top_k",
+        "top_k": "top_k",
+    }
+
+    def option_key(self, key: str) -> str | None:
+        normalized = key.strip().lower().replace("-", "_")
+        return self._ALIASES.get(normalized)
+
+    def validate(self, key: str, value: Any) -> float | int:
+        if key == "temperature":
+            fixed = finite_float(value)
+            if fixed is None or fixed < 0 or fixed > 2:
+                raise SystemExit("temperature must be a number from 0 to 2")
+            return fixed
+        if key == "top_p":
+            fixed = finite_float(value)
+            if fixed is None or fixed <= 0 or fixed > 1:
+                raise SystemExit("top_p must be a number greater than 0 and up to 1")
+            return fixed
+        if key == "top_k":
+            fixed = positive_int(value)
+            if not fixed:
+                raise SystemExit("top_k must be a positive integer")
+            return fixed
+        raise SystemExit(f"Unknown provider option: {key}")
+
+
+__all__ = ["ProviderSamplingPolicy"]

package/ciel_runtime_support/provider_status.py

@@ -0,0 +1,145 @@
+"""Provider base URL status projection application service."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from typing import Any, Callable
+import urllib.error
+import urllib.request
+
+from .architecture import ProviderStatusPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderStatusRouting:
+    codex_routed: Callable[..., bool]
+    agy_routed: Callable[..., bool]
+    nvidia_native: Callable[..., bool]
+    native_anthropic_base: Callable[..., str]
+    router_up: Callable[[], bool]
+    router_base: str
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderStatusCatalog:
+    model_headers: Callable[..., dict[str, str]]
+    http_json: Callable[..., Any]
+    join_url: Callable[..., str]
+    management_base: Callable[..., str]
+    model_ids: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderStatusGeneric:
+    primary_api_key: Callable[..., str]
+    meaningful_key: Callable[..., bool]
+    with_user_agent: Callable[..., dict[str, str]]
+    provider_urlopen: Callable[..., Any]
+    model_context_limit: Callable[..., int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderStatusServices:
+    routing: ProviderStatusRouting
+    catalog: ProviderStatusCatalog
+    generic: ProviderStatusGeneric
+
+
+def base_url_status_line(
+    provider: str,
+    pcfg: dict[str, Any],
+    policy: ProviderStatusPolicy,
+    *,
+    services: ProviderStatusServices,
+) -> str:
+    base = str(pcfg.get("base_url") or "").rstrip("/")
+    if not base:
+        return "Base URL: missing"
+    if "your-" in base:
+        return f"Base URL: placeholder ({base})"
+    routing = services.routing
+    if policy.kind == "native_codex":
+        if routing.codex_routed(provider, pcfg):
+            return f"Base URL: Codex routed through local router ({routing.router_base}/backend-api/codex)"
+        return "Base URL: native Codex config (ciel-runtime does not override it)"
+    if policy.kind == "native_agy":
+        if routing.agy_routed(provider, pcfg):
+            return "Base URL: AGY routed uses native Antigravity model upstream; Ciel routes channel/PTY wake only"
+        return "Base URL: native AGY config (ciel-runtime does not override it)"
+    if policy.kind == "nvidia":
+        if routing.nvidia_native(provider, pcfg):
+            return f"Base URL: NVIDIA hosted native ({routing.native_anthropic_base(provider, pcfg)}/v1/messages)"
+        state = "ready" if routing.router_up() else "starts on launch"
+        return f"Base URL: NVIDIA hosted ({base}); local router {routing.router_base} {state}"
+    if policy.kind == "configured":
+        return f"Base URL: {policy.configured_description} ({base})"
+    if policy.kind == "catalog":
+        return _catalog_status(provider, pcfg, base, policy, services.catalog)
+    return _generic_status(provider, pcfg, base, policy, services.generic, services.catalog.join_url)
+
+
+def _catalog_status(
+    provider: str,
+    pcfg: dict[str, Any],
+    base: str,
+    policy: ProviderStatusPolicy,
+    catalog: ProviderStatusCatalog,
+) -> str:
+    probe_base = catalog.management_base(pcfg) if policy.catalog_scope == "fireworks_management" else base
+    scope = "model API" if policy.catalog_scope == "fireworks_management" else "model list"
+    try:
+        data = catalog.http_json(
+            catalog.join_url(probe_base, policy.catalog_path),
+            headers=catalog.model_headers(provider, pcfg),
+            timeout=2.5,
+            provider=provider,
+            pcfg=pcfg,
+        )
+        count = len(catalog.model_ids(data))
+        return f"Base URL: {policy.label} {scope} reachable ({policy.catalog_path}, {count} {policy.catalog_count_label})"
+    except urllib.error.HTTPError as exc:
+        if exc.code in (401, 403):
+            return f"Base URL: {policy.label} reachable, auth rejected ({exc.code})"
+        return f"Base URL: {policy.label} HTTP {exc.code}"
+    except Exception as exc:
+        return f"Base URL: {policy.label} {scope} unreachable ({type(exc).__name__})"
+
+
+def _generic_status(
+    provider: str,
+    pcfg: dict[str, Any],
+    base: str,
+    policy: ProviderStatusPolicy,
+    generic: ProviderStatusGeneric,
+    join_url: Callable[..., str],
+) -> str:
+    headers: dict[str, str] = {}
+    key = generic.primary_api_key(provider, pcfg)
+    if generic.meaningful_key(key):
+        headers = {"x-api-key": key, "authorization": f"Bearer {key}"}
+    headers = generic.with_user_agent(headers)
+    path = policy.catalog_path or "/v1/models"
+    try:
+        request = urllib.request.Request(join_url(base, path), headers=headers)
+        with generic.provider_urlopen(request, timeout=2.5, provider=provider, pcfg=pcfg) as response:
+            body = response.read(131072).decode("utf-8", errors="ignore")
+        count = ""
+        try:
+            data = json.loads(body)
+        except (TypeError, ValueError):
+            data = {}
+        models = data.get(policy.catalog_count_key) if isinstance(data, dict) else None
+        if isinstance(models, list):
+            count = f", {len(models)} models"
+            if policy.catalog_count_key == "data":
+                limit = generic.model_context_limit(provider, pcfg, timeout=1.0)
+                if limit:
+                    count += f", max_model_len {limit}"
+        return f"Base URL: model list reachable ({path}{count})"
+    except urllib.error.HTTPError as exc:
+        if exc.code in (401, 403):
+            return f"Base URL: model list reachable, auth rejected ({exc.code})"
+        return f"Base URL: HTTP {exc.code}"
+    except Exception as exc:
+        return f"Base URL: unreachable ({type(exc).__name__})"

package/ciel_runtime_support/provider_timeout_policy.py

@@ -0,0 +1,184 @@
+"""Context-aware provider request timeout calculation and application policy."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from .architecture import ProviderContextPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderTimeoutSettings:
+    default_ms: int
+    minimum_ms: int
+    maximum_ms: int
+    round_ms: int
+    idle_max_ms: int
+    preset_timeouts: Mapping[str, int]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderTimeoutPorts:
+    positive_int: Callable[[Any], int | None]
+    context_policy: Callable[[str, dict[str, Any]], ProviderContextPolicy]
+    context_capacity: Callable[[str, dict[str, Any]], int | None]
+    output_token_cap: Callable[[str, dict[str, Any], int | None], int | None]
+    ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
+    catalog_timeout: Callable[[str], int | None]
+    model_preset: Callable[[str], Mapping[str, Any]]
+    timeout_for_context: Callable[[int | None], int]
+    format_context: Callable[[int | None], str]
+
+
+class ProviderTimeoutPolicy:
+    def __init__(
+        self,
+        settings: ProviderTimeoutSettings,
+        ports: ProviderTimeoutPorts,
+    ) -> None:
+        self.settings = settings
+        self.ports = ports
+
+    def configured_context(
+        self,
+        provider: str,
+        config: dict[str, Any],
+    ) -> int | None:
+        strategy = self.ports.context_policy(provider, config).settings_strategy
+        positive_int = self.ports.positive_int
+        if strategy == "ollama":
+            fixed = positive_int(config.get("num_ctx"))
+            if fixed:
+                return fixed
+            return self.ports.context_capacity(provider, config) or positive_int(
+                config.get("num_ctx_max")
+            )
+        if strategy == "standard":
+            return positive_int(
+                config.get("context_window")
+            ) or self.ports.context_capacity(provider, config)
+        return self.ports.context_capacity(provider, config)
+
+    def configured_output(
+        self,
+        provider: str,
+        config: dict[str, Any],
+    ) -> int | None:
+        positive_int = self.ports.positive_int
+        if self.ports.context_policy(provider, config).settings_strategy == "ollama":
+            options = self.ports.ollama_options(config)
+            configured = positive_int(options.get("num_predict")) or positive_int(
+                config.get("max_output_tokens")
+            )
+        else:
+            configured = positive_int(
+                config.get("max_output_tokens")
+            ) or positive_int(config.get("num_predict"))
+        return self.ports.output_token_cap(provider, config, configured)
+
+    def clamp(self, milliseconds: int | float | None) -> int:
+        value = self.ports.positive_int(milliseconds) or self.settings.default_ms
+        value = max(self.settings.minimum_ms, min(self.settings.maximum_ms, value))
+        return int(
+            math.ceil(value / self.settings.round_ms) * self.settings.round_ms
+        )
+
+    def calculated(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        timeout_candidates: list[int] | None = None,
+    ) -> int:
+        context_policy = self.ports.context_policy(provider, config)
+        context_tokens = self.ports.positive_int(
+            self.configured_context(provider, config)
+        )
+        output_tokens = self.ports.positive_int(
+            self.configured_output(provider, config)
+        )
+        timeout_ms = self.settings.minimum_ms
+        if context_tokens:
+            context_score = max(
+                0.0,
+                min(
+                    1.0,
+                    math.log2(max(context_tokens, 65536) / 65536) / 4.0,
+                ),
+            )
+            timeout_ms += int(240000 * context_score)
+        if output_tokens:
+            output_score = max(0.0, min(1.0, (output_tokens - 2048) / 6144))
+            timeout_ms += int(120000 * output_score)
+        if context_policy.hosted_timeout:
+            timeout_ms += 60000
+        for candidate in timeout_candidates or []:
+            fixed = self.ports.positive_int(candidate)
+            if fixed:
+                timeout_ms = max(timeout_ms, fixed)
+        timeout_ms *= context_policy.timeout_weight
+        return self.clamp(timeout_ms)
+
+    def recommended(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        *,
+        use_context_fallback: bool = True,
+    ) -> int:
+        model = str(config.get("current_model") or "")
+        candidates: list[int] = []
+        context_policy = self.ports.context_policy(provider, config)
+        preset_id = str(config.get("llm_preset") or "").strip()
+        preset_timeout = self.ports.positive_int(
+            self.settings.preset_timeouts.get(preset_id)
+        )
+        if preset_timeout:
+            candidates.append(preset_timeout)
+        if context_policy.uses_catalog_timeout:
+            catalog_timeout = self.ports.catalog_timeout(model)
+            if catalog_timeout:
+                candidates.append(catalog_timeout)
+        model_timeout = self.ports.positive_int(
+            self.ports.model_preset(model).get("recommended_timeout_ms")
+        )
+        if model_timeout:
+            candidates.append(model_timeout)
+        if candidates:
+            return self.calculated(provider, config, candidates)
+        if not use_context_fallback:
+            return self.settings.default_ms
+        context_timeout = self.ports.timeout_for_context(
+            self.configured_context(provider, config)
+        )
+        return self.calculated(provider, config, [context_timeout])
+
+    def apply(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        *,
+        use_context_fallback: bool = True,
+    ) -> list[str]:
+        timeout_ms = self.recommended(
+            provider,
+            config,
+            use_context_fallback=use_context_fallback,
+        )
+        idle_ms = min(timeout_ms, self.settings.idle_max_ms)
+        positive_int = self.ports.positive_int
+        changed = (
+            positive_int(config.get("request_timeout_ms")) != timeout_ms
+            or positive_int(config.get("stream_idle_timeout_ms")) != idle_ms
+        )
+        config["request_timeout_ms"] = timeout_ms
+        config["stream_idle_timeout_ms"] = idle_ms
+        if not changed:
+            return []
+        context = self.configured_context(provider, config)
+        return [
+            f"Auto timeout: {timeout_ms}ms for context {self.ports.format_context(context)}.",
+            f"stream_idle_timeout_ms: {idle_ms}",
+        ]

package/ciel_runtime_support/provider_tool_policy.py

@@ -0,0 +1,145 @@
+"""Provider-owned tool exposure and tool-choice application policy."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .protocols.anthropic_thinking_policy import (
+    ToolChoicePorts,
+    normalize_tool_choice,
+)
+
+
+ProviderConfig = dict[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderToolPolicy:
+    adapter_for: Callable[..., Any]
+    contract_for: Callable[..., Any]
+    current_model: Callable[[str, ProviderConfig], str]
+    strip_context_suffix: Callable[[str], str]
+    resolve_emitted_name: Callable[
+        [str, dict[str, Any] | None],
+        str,
+    ]
+    default_blocked_tools: frozenset[str]
+    repair_tools: frozenset[str]
+    log: Callable[[str, str], None]
+
+    def blocked_tools(
+        self,
+        provider: str,
+        config: ProviderConfig,
+    ) -> set[str]:
+        override = config.get("blocked_tools")
+        if override is False:
+            return set()
+        if isinstance(override, list):
+            return {
+                str(name).strip()
+                for name in override
+                if str(name).strip()
+            }
+        adapter, contract = self._adapter(provider, config)
+        if adapter.capabilities(contract).blocks_default_tools:
+            return set(self.default_blocked_tools)
+        return set()
+
+    def normalize_anthropic_stream_tool_use(
+        self,
+        provider: str,
+        config: ProviderConfig,
+    ) -> bool:
+        adapter, contract = self._adapter(provider, config)
+        return adapter.normalizes_anthropic_tool_use(contract)
+
+    def supports_tool_choice(
+        self,
+        provider: str,
+        config: ProviderConfig,
+        body: dict[str, Any],
+    ) -> bool:
+        raw_model = str(
+            body.get("model") or config.get("current_model") or ""
+        )
+        model = self.strip_context_suffix(raw_model).lower()
+        adapter, contract = self._adapter(provider, config)
+        return adapter.supports_tool_choice(contract, model)
+
+    def tool_choice_status(
+        self,
+        provider: str,
+        config: ProviderConfig,
+    ) -> str:
+        configured = config.get("supports_tool_choice")
+        if configured is not None:
+            return "on" if bool(configured) else "off"
+        model = self.current_model(provider, config)
+        enabled = self.supports_tool_choice(
+            provider,
+            config,
+            {"model": model},
+        )
+        return f"auto ({'on' if enabled else 'off'})"
+
+    def normalize_tool_choice(
+        self,
+        provider: str,
+        config: ProviderConfig,
+        body: dict[str, Any],
+    ) -> dict[str, Any]:
+        return normalize_tool_choice(
+            provider,
+            config,
+            body,
+            ToolChoicePorts(
+                normalize=self._normalize_choice,
+                supports=self.supports_tool_choice,
+                log=self.log,
+            ),
+        )
+
+    def should_repair_passthrough_input(
+        self,
+        provider: str,
+        config: ProviderConfig,
+        raw_name: str,
+        source_body: dict[str, Any] | None,
+    ) -> bool:
+        adapter, contract = self._adapter(provider, config)
+        if not adapter.capabilities(contract).repairs_anthropic_tool_input:
+            return False
+        return self.resolve_emitted_name(
+            raw_name,
+            source_body,
+        ) in self.repair_tools
+
+    def _adapter(
+        self,
+        provider: str,
+        config: ProviderConfig,
+    ) -> tuple[Any, Any]:
+        return (
+            self.adapter_for(provider, config),
+            self.contract_for(provider, config),
+        )
+
+    def _normalize_choice(
+        self,
+        provider: str,
+        config: ProviderConfig,
+        request: dict[str, Any],
+        choice: Any,
+    ) -> Any:
+        adapter, contract = self._adapter(provider, config)
+        model = str(
+            request.get("model")
+            or config.get("current_model")
+            or ""
+        )
+        return adapter.normalize_tool_choice(contract, model, choice)
+
+
+__all__ = ["ProviderToolPolicy"]