@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/providers/ollama_context.py

@@ -0,0 +1,195 @@
+"""Ollama-specific context sizing, options, and context-error recovery policy."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable, Mapping, Set
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaRequestContextPolicy:
+    environ: Mapping[str, str]
+    positive_int: Callable[[Any], int | None]
+    estimate_tokens: Callable[[Any, dict[int, int] | None], int]
+    model_matches: Callable[[str, str | None], bool]
+    preset_names: Set[str]
+    default_request_timeout_ms: int
+
+    @staticmethod
+    def context_bucket(target: int, minimum: int, maximum: int) -> int:
+        target = max(minimum, min(maximum, target))
+        for bucket in (4096, 8192, 16384, 32768, 65536, 131072, 262144):
+            if bucket >= target:
+                return min(bucket, maximum)
+        return maximum
+
+    def provider_context_limit(self, config: dict[str, Any]) -> int | None:
+        current_model = str(config.get("current_model") or "")
+        cached_model = str(config.get("model_context_model") or "")
+        cached_limit = self.positive_int(config.get("model_context_max"))
+        if not cached_limit:
+            return None
+        if cached_model and (
+            not current_model or not self.model_matches(current_model, cached_model)
+        ):
+            return None
+        return cached_limit
+
+    def preserve_configured_context_cap(self, config: dict[str, Any]) -> bool:
+        return str(config.get("llm_preset") or "").strip() in self.preset_names
+
+    def effective_context_limit(self, config: dict[str, Any]) -> int | None:
+        provider_limit = self.provider_context_limit(config)
+        configured_max = self.positive_int(config.get("num_ctx_max"))
+        if (
+            provider_limit
+            and configured_max
+            and self.preserve_configured_context_cap(config)
+        ):
+            return min(provider_limit, configured_max)
+        return provider_limit or configured_max
+
+    def num_ctx_for_payload(
+        self,
+        config: dict[str, Any],
+        payload: Any,
+        _token_cache: dict[int, int] | None = None,
+    ) -> int | None:
+        override = self.environ.get("CIEL_RUNTIME_OLLAMA_NUM_CTX")
+        if override:
+            return self.positive_int(override)
+        raw = config.get("num_ctx", "auto")
+        if isinstance(raw, str) and raw.strip().lower() in {"", "auto", "dynamic"}:
+            provider_limit = self.provider_context_limit(config)
+            if provider_limit:
+                return self.effective_context_limit(config) or provider_limit
+            # No model-card context is available (no /api/show max_model_len, no
+            # catalog/library match, no model-id hint). Do NOT invent a window:
+            # estimating from the payload and clamping to num_ctx_min/max used
+            # to send a guessed num_ctx the model card never advertised
+            # (operator 2026-07-29: if the model card does not provide
+            # num_ctx/num_predict, the parameter must be omitted so the server
+            # default applies — never substituted with our own guess).
+            return None
+        return self.positive_int(raw)
+
+    def num_predict_for_payload(
+        self,
+        config: dict[str, Any],
+        capped: int | None,
+    ) -> int | None:
+        """num_predict with model-card provenance gating.
+
+        An explicit user-configured value always passes through. But the
+        adapter-default ollama_options.num_predict (a heuristic, not a model
+        card value) is only sent when a model-card context exists for the
+        current model — otherwise the parameter is omitted and the server
+        default applies (operator 2026-07-29).
+        """
+        value = self.positive_int(capped)
+        if not value:
+            return None
+        configured = self.positive_int(config.get("ollama_options", {}).get("num_predict") if isinstance(config.get("ollama_options"), dict) else None) or self.positive_int(config.get("max_output_tokens"))
+        if configured:
+            return value
+        if self.provider_context_limit(config):
+            return value
+        return None
+
+    def num_ctx_status(self, config: dict[str, Any]) -> str:
+        raw = config.get("num_ctx", "auto")
+        if isinstance(raw, str) and raw.strip().lower() in {"", "auto", "dynamic"}:
+            provider_limit = self.provider_context_limit(config)
+            if provider_limit:
+                effective_limit = self.effective_context_limit(config) or provider_limit
+                if effective_limit < provider_limit:
+                    return f"auto ({effective_limit:,}; model max {provider_limit:,})"
+                return f"auto (provider {effective_limit:,})"
+            return "auto (server default — no model-card context)"
+        return str(self.positive_int(raw) or raw)
+
+    @staticmethod
+    def extra_options(config: dict[str, Any]) -> dict[str, Any]:
+        raw = config.get("ollama_options") or {}
+        if not isinstance(raw, dict):
+            return {}
+        return {str(key): value for key, value in raw.items() if value is not None}
+
+    def options_status(self, config: dict[str, Any]) -> str:
+        options = self.extra_options(config)
+        if not options:
+            return "{}"
+        return ", ".join(
+            f"{key}={json.dumps(value, ensure_ascii=False)}"
+            for key, value in sorted(options.items())
+        )
+
+    def request_timeout_seconds(self, config: dict[str, Any]) -> float:
+        raw = config.get(
+            "request_timeout_ms",
+            config.get(
+                "request_timeout",
+                config.get("timeout_ms", self.default_request_timeout_ms),
+            ),
+        )
+        try:
+            value = float(raw)
+        except (TypeError, ValueError):
+            return 120.0
+        if value <= 0:
+            return 120.0
+        return max(1.0, value / 1000.0) if value > 10000 else value
+
+    def context_error_limit(self, raw: str | None) -> int | None:
+        text = str(raw or "")
+        normalized = text.lower()
+        if "context" not in normalized and "n_ctx" not in normalized:
+            return None
+        patterns = (
+            r"available context size\s*\(\s*(\d+)\s+tokens?\s*\)",
+            r'"n_ctx"\s*:\s*(\d+)',
+            r"\bn_ctx\s*[=:]\s*(\d+)",
+        )
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                return self.positive_int(match.group(1))
+        return None
+
+    def context_retry_config(
+        self, config: dict[str, Any], context_limit: int
+    ) -> dict[str, Any]:
+        retry_config = dict(config)
+        context_limit = max(8192, int(context_limit))
+        retry_config["num_ctx"] = context_limit
+        retry_config["num_ctx_max"] = context_limit
+        minimum = self.positive_int(retry_config.get("num_ctx_min"))
+        if minimum and minimum > context_limit:
+            retry_config["num_ctx_min"] = context_limit
+        output_cap = max(256, min(2048, context_limit // 8))
+        configured_output = self.positive_int(retry_config.get("max_output_tokens"))
+        retry_config["max_output_tokens"] = (
+            min(configured_output, output_cap) if configured_output else output_cap
+        )
+        options = dict(self.extra_options(retry_config))
+        configured_num_predict = self.positive_int(options.get("num_predict"))
+        if configured_num_predict:
+            options["num_predict"] = min(configured_num_predict, output_cap)
+        retry_config["ollama_options"] = options
+        return retry_config
+
+    def context_limit_for_budget(self, config: dict[str, Any]) -> int:
+        raw = config.get("num_ctx", "auto")
+        if isinstance(raw, str) and raw.strip().lower() in {"", "auto", "dynamic"}:
+            return self.effective_context_limit(config) or 65536
+        return (
+            self.positive_int(raw)
+            or self.positive_int(config.get("num_ctx_max"))
+            or 65536
+        )
+
+
+__all__ = ["OllamaRequestContextPolicy"]

package/ciel_runtime_support/providers/ollama_runtime.py

@@ -0,0 +1,213 @@
+"""Ollama-specific runtime inspection and context output guard."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaRuntimeServices:
+    request_base: Callable[[str, dict[str, Any]], str]
+    post_json: Callable[..., Any]
+    http_json: Callable[..., Any]
+    join_url: Callable[[str, str], str]
+    model_headers: Callable[[str, dict[str, Any]], dict[str, str]]
+    current_model: Callable[[str, dict[str, Any]], str]
+    positive_int: Callable[[Any], int | None]
+    model_context: Callable[[dict[str, Any]], int | None]
+    format_context: Callable[[int | None], str]
+
+
+class OllamaRuntimeService:
+    def __init__(self, services: OllamaRuntimeServices) -> None:
+        self.services = services
+
+    def api_base(self, provider: str, config: dict[str, Any]) -> str:
+        base = self.services.request_base(provider, config)
+        return base[:-4].rstrip("/") if base.endswith("/api") else base.rstrip("/")
+
+    @staticmethod
+    def show_parameters(data: dict[str, Any]) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        raw = data.get("parameters")
+        if isinstance(raw, dict):
+            output.update(raw)
+        elif isinstance(raw, str):
+            for line in raw.splitlines():
+                parts = line.strip().split(None, 1)
+                if len(parts) == 2 and not line.strip().startswith("#"):
+                    output[parts[0].strip()] = parts[1].strip().strip('"')
+        modelfile = data.get("modelfile")
+        if isinstance(modelfile, str):
+            for line in modelfile.splitlines():
+                parts = line.strip().split(None, 2)
+                if (
+                    len(parts) == 3
+                    and not line.strip().startswith("#")
+                    and parts[0].lower() == "parameter"
+                ):
+                    output.setdefault(parts[1].strip(), parts[2].strip().strip('"'))
+        return output
+
+    def fetch_model_specs(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        model_id: str,
+        timeout: float = 3.0,
+    ) -> dict[str, Any]:
+        if provider not in ("ollama", "ollama-cloud") or not model_id:
+            return {}
+        base = self.api_base(provider, config)
+        if not base:
+            return {}
+        data = self.services.post_json(
+            self.services.join_url(base, "/api/show"),
+            {"model": model_id},
+            headers=self.services.model_headers(provider, config),
+            timeout=timeout,
+            provider=provider,
+            pcfg=config,
+        )
+        if not isinstance(data, dict):
+            return {}
+        model_info = data.get("model_info") if isinstance(data.get("model_info"), dict) else {}
+        parameters = self.show_parameters(data)
+        max_context = (
+            self.services.model_context(data)
+            or self.services.model_context(model_info)
+            or self.services.positive_int(parameters.get("num_ctx"))
+            or self.services.positive_int(parameters.get("context_length"))
+        )
+        num_predict = self.services.positive_int(parameters.get("num_predict"))
+        output: dict[str, Any] = {}
+        if max_context:
+            output["max_model_len"] = max_context
+        if num_predict:
+            output["num_predict"] = num_predict
+        return output
+
+    @staticmethod
+    def model_id_matches(left: str, right: str) -> bool:
+        lhs = (left or "").strip().lower()
+        rhs = (right or "").strip().lower()
+        if lhs == rhs:
+            return True
+        return (lhs if ":" in lhs else f"{lhs}:latest") == (
+            rhs if ":" in rhs else f"{rhs}:latest"
+        )
+
+    def runtime_info(
+        self, config: dict[str, Any], timeout: float = 1.5
+    ) -> dict[str, Any] | None:
+        base = self.api_base("ollama", config)
+        current = self.services.current_model("ollama", config)
+        if not base or not current:
+            return None
+        data = self.services.http_json(
+            self.services.join_url(base, "/api/ps"),
+            headers=self.services.model_headers("ollama", config),
+            timeout=timeout,
+        )
+        items = data.get("models") if isinstance(data, dict) else None
+        if not isinstance(items, list):
+            return None
+        selected = next(
+            (
+                item
+                for item in items
+                if isinstance(item, dict)
+                and any(
+                    self.model_id_matches(str(item.get(key) or ""), current)
+                    for key in ("name", "model", "id")
+                )
+            ),
+            None,
+        )
+        if not isinstance(selected, dict):
+            return None
+        details = selected.get("details") if isinstance(selected.get("details"), dict) else {}
+        return {
+            "requested_model": current,
+            "runtime_model": str(selected.get("name") or selected.get("model") or ""),
+            "loaded_context_len": self.services.positive_int(selected.get("context_length"))
+            or self.services.model_context(selected),
+            "size_vram": self.services.positive_int(selected.get("size_vram")),
+            "parameter_size": details.get("parameter_size"),
+            "quantization_level": details.get("quantization_level"),
+            "family": details.get("family"),
+            "families": details.get("families"),
+        }
+
+    def apply_output_guard(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        runtime_info: Callable[[dict[str, Any]], dict[str, Any] | None] | None = None,
+    ) -> list[str]:
+        if provider != "ollama":
+            return []
+        try:
+            info = runtime_info(config) if runtime_info else self.runtime_info(config)
+        except Exception:
+            return []
+        loaded_context = self.services.positive_int((info or {}).get("loaded_context_len"))
+        cap = self.output_cap(loaded_context)
+        if not cap:
+            return []
+        options = config.setdefault("ollama_options", {})
+        configured = self.services.positive_int(
+            options.get("num_predict")
+        ) or self.services.positive_int(config.get("max_output_tokens"))
+        if not configured or configured <= cap:
+            return []
+        options["num_predict"] = cap
+        config["max_output_tokens"] = cap
+        model = str((info or {}).get("runtime_model") or config.get("current_model") or "")
+        return [
+            f"Ollama runtime context {self.services.format_context(loaded_context)} "
+            f"for {model or 'current model'}; output capped to {cap:,} tokens."
+        ]
+
+    def output_cap(self, context_length: int | None) -> int | None:
+        context = self.services.positive_int(context_length)
+        return max(2048, min(8192, context // 16)) if context else None
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaRuntimeApi:
+    """Stable public adapter for late-bound Ollama runtime services."""
+
+    service_factory: Callable[[], OllamaRuntimeService]
+
+    def api_base(self, config: dict[str, Any]) -> str:
+        return self.service_factory().api_base("ollama", config)
+
+    def provider_api_base(self, provider: str, config: dict[str, Any]) -> str:
+        return self.service_factory().api_base(provider, config)
+
+    def show_parameters(self, data: dict[str, Any]) -> dict[str, Any]:
+        return self.service_factory().show_parameters(data)
+
+    def fetch_model_specs(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        model_id: str,
+        timeout: float = 3.0,
+    ) -> dict[str, Any]:
+        return self.service_factory().fetch_model_specs(
+            provider, config, model_id, timeout
+        )
+
+    def model_id_matches(self, left: str, right: str) -> bool:
+        return self.service_factory().model_id_matches(left, right)
+
+    def runtime_info(
+        self, config: dict[str, Any], timeout: float = 1.5
+    ) -> dict[str, Any] | None:
+        return self.service_factory().runtime_info(config, timeout)
+
+    def output_cap(self, context_length: int | None) -> int | None:
+        return self.service_factory().output_cap(context_length)

package/ciel_runtime_support/providers/opencode.py

@@ -0,0 +1,220 @@
+"""OpenCode Zen provider adapter."""
+
+from dataclasses import dataclass, field
+from typing import Mapping
+
+from ..architecture import (
+    MessageProtocol,
+    ProviderCapabilities,
+    ProviderConfigurationPolicy,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+    ProviderStatusPolicy,
+)
+from .base import (
+    HttpBearerProviderAdapter,
+    configuration_policy,
+    provider_configuration,
+)
+from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+
+
+@dataclass(frozen=True)
+class OpenCodeProviderAdapter(HttpBearerProviderAdapter):
+    name: str = "opencode"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["opencode"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "claude-sonnet-4-6",
+            custom_models=("claude-sonnet-4-6", "qwen3.6-plus-free"),
+            native_compat=True,
+            context_window=200000,
+            max_output_tokens=8192,
+            context_reserve_tokens=8192,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+            ip_family="ipv6-preferred",
+            haiku_model="claude-haiku-4-5",
+            subagent_model="claude-sonnet-4-6",
+            model_endpoints={},
+        )
+    )
+    send_placeholder_key: bool = True
+    api_key_display_name_value: str = "OpenCode Zen"
+    api_key_launch_error_value: str = (
+        "Launch blocked: OpenCode Zen requires a OpenCode Zen API key."
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="anthropic_messages",
+            supports_thinking=True,
+            requires_api_key=True,
+        )
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/messages",
+            models_path="/v1/models",
+            probe_strategy="opencode",
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(
+            kind="openai",
+            allow_configured_fallback=True,
+            allow_public_without_auth=True,
+        )
+    )
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="configured_first",
+            settings_strategy="standard",
+            hosted_timeout=True,
+        )
+
+    def router_native_anthropic_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        return bool(config.options.get("native_compat", True)) and (
+            self.select_protocol("anthropic_messages", config, model)
+            == "anthropic_messages"
+        )
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        del config
+        return ProviderOptionPresentationPolicy(
+            show_native=True,
+            show_tool_choice=True,
+            show_stream=True,
+            show_ip_family=True,
+            show_rate_limit_controls=True,
+            show_sampling_controls=True,
+            show_ip_family_control=True,
+        )
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        del operation
+        raw_model = str(model or config.model or "").strip()
+        overrides = config.options.get("model_endpoints")
+        if isinstance(overrides, Mapping):
+            raw = overrides.get(raw_model)
+            key = str(raw or "").strip().lower().replace("_", "-")
+            mapped = {
+                "anthropic": "anthropic_messages",
+                "anthropic-messages": "anthropic_messages",
+                "messages": "anthropic_messages",
+                "openai": "openai_chat",
+                "openai-chat": "openai_chat",
+                "chat": "openai_chat",
+                "openai-responses": "openai_responses",
+                "responses": "openai_responses",
+                "google-generative": "google_generative",
+                "gemini": "google_generative",
+            }.get(key)
+            if mapped is not None:
+                return mapped
+        normalized = raw_model.split("[", 1)[0].lower()
+        for prefix in ("ciel-runtime-opencode-go-", "ciel-runtime-opencode-"):
+            if normalized.startswith(prefix):
+                normalized = normalized[len(prefix) :]
+                break
+        if self.name == "opencode-go":
+            if normalized.startswith(("glm-", "kimi-", "deepseek-", "mimo-", "hy3-")):
+                return "openai_chat"
+            return "anthropic_messages"
+        if normalized.startswith("gpt-"):
+            return "openai_responses"
+        if normalized.startswith("gemini-"):
+            return "google_generative"
+        if normalized.startswith(
+            (
+                "minimax-",
+                "glm-",
+                "kimi-",
+                "grok-",
+                "big-pickle",
+                "deepseek-",
+                "mimo-",
+                "nemotron-",
+                "north-",
+            )
+        ):
+            return "openai_chat"
+        return "anthropic_messages"
+
+    def supported_protocols(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> frozenset[MessageProtocol]:
+        return frozenset({self.select_protocol("anthropic_messages", config, model)})
+
+    def openai_reasoning_passback_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        requested = self.normalize_model_id(str(model or ""))
+        prefix = f"ciel-runtime-{self.name}-"
+        if requested.startswith(prefix):
+            requested = requested[len(prefix) :]
+        elif requested.startswith("ciel-runtime-"):
+            requested = config.model
+        model_id = self.normalize_model_id(requested or config.model).lower()
+        return model_id.startswith("deepseek-") and self.select_protocol(
+            "openai_chat", config, model_id
+        ) == "openai_chat"
+
+    def status_policy(self, config: ProviderConfig) -> ProviderStatusPolicy:
+        del config
+        return ProviderStatusPolicy(
+            kind="catalog",
+            label=self.api_key_display_name_value,
+            catalog_path="/v1/models",
+        )
+
+    def model_panel_badge(self, config: ProviderConfig, model: str) -> str:
+        protocol = self.select_protocol("anthropic_messages", config, model)
+        label = {
+            "anthropic_messages": "messages",
+            "openai_chat": "chat",
+            "openai_responses": "responses unsupported",
+            "google_generative": "gemini unsupported",
+        }.get(protocol, str(protocol))
+        overrides = config.options.get("model_endpoints")
+        if isinstance(overrides, Mapping) and model in overrides:
+            label += " override"
+        return label
+
+    def project_router_model_metadata(
+        self, config: ProviderConfig, model_id: str
+    ) -> Mapping[str, object]:
+        protocol = self.select_protocol("anthropic_messages", config, model_id)
+        endpoint = {
+            "anthropic_messages": "anthropic-messages",
+            "openai_chat": "openai-chat",
+            "openai_responses": "openai-responses",
+            "google_generative": "google-generative",
+        }.get(protocol, str(protocol).replace("_", "-"))
+        return {
+            "opencode_endpoint": endpoint,
+            "router_supported": protocol in {"anthropic_messages", "openai_chat"},
+        }
+
+    def configuration_policy(
+        self, config: ProviderConfig
+    ) -> ProviderConfigurationPolicy:
+        del config
+        return configuration_policy(supports_model_endpoint_overrides=True)
+
+
+__all__ = ["OpenCodeProviderAdapter"]

package/ciel_runtime_support/providers/opencode_go.py

@@ -0,0 +1,37 @@
+"""OpenCode Go provider adapter."""
+
+from dataclasses import dataclass, field
+
+from .base import provider_configuration
+from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+from .opencode import OpenCodeProviderAdapter
+
+
+@dataclass(frozen=True)
+class OpenCodeGoProviderAdapter(OpenCodeProviderAdapter):
+    name: str = "opencode-go"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["opencode-go"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "qwen3.6-plus",
+            custom_models=("qwen3.6-plus",),
+            native_compat=True,
+            context_window=1048576,
+            max_output_tokens=8192,
+            context_reserve_tokens=8192,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+            ip_family="ipv6-preferred",
+            haiku_model="qwen3.5-plus",
+            subagent_model="qwen3.6-plus",
+            model_endpoints={},
+        )
+    )
+    api_key_display_name_value: str = "OpenCode Go"
+    api_key_launch_error_value: str = (
+        "Launch blocked: OpenCode Go requires a OpenCode Go API key."
+    )
+
+
+__all__ = ["OpenCodeGoProviderAdapter"]