@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/providers/__init__.py

@@ -0,0 +1,65 @@
+"""Concrete provider adapters and their shared transport bases."""
+
+from .anthropic import AnthropicProviderAdapter
+from .base import (
+    HttpBearerProviderAdapter,
+    NoAuthProviderAdapter,
+    OpenAICompatibleProviderAdapter,
+)
+from .constants import PROVIDER_DEFAULT_BASE_URLS, ZAI_MODEL_FALLBACK_IDS
+from .native import AgyProviderAdapter, CodexProviderAdapter
+from .ollama import OllamaCloudProviderAdapter, OllamaProviderAdapter
+from .openrouter import OpenRouterProviderAdapter
+from .lm_studio import LMStudioProviderAdapter
+from .nim import SelfHostedNimProviderAdapter
+from .nvidia import NvidiaHostedProviderAdapter
+from .vllm import VllmProviderAdapter
+from .deepseek import DeepSeekProviderAdapter
+from .fireworks import FireworksProviderAdapter
+from .zai import ZaiProviderAdapter
+from .kimi import KimiProviderAdapter
+from .opencode import OpenCodeProviderAdapter
+from .opencode_go import OpenCodeGoProviderAdapter
+from .catalog import (
+    COMPATIBLE_PROVIDER_SPECS,
+    CatalogOpenAIProviderAdapter,
+    CompatibleProviderSpec,
+)
+from .anthropic_catalog import (
+    ANTHROPIC_COMPATIBLE_PROVIDER_SPECS,
+    AnthropicCompatibleProviderSpec,
+    CatalogAnthropicProviderAdapter,
+)
+from .cloud import AzureOpenAIProviderAdapter, CodeBuddyCnProviderAdapter
+
+__all__ = [
+    "ANTHROPIC_COMPATIBLE_PROVIDER_SPECS",
+    "AnthropicCompatibleProviderSpec",
+    "CatalogAnthropicProviderAdapter",
+    "AzureOpenAIProviderAdapter",
+    "CodeBuddyCnProviderAdapter",
+    "HttpBearerProviderAdapter",
+    "AnthropicProviderAdapter",
+    "NoAuthProviderAdapter",
+    "OpenAICompatibleProviderAdapter",
+    "PROVIDER_DEFAULT_BASE_URLS",
+    "ZAI_MODEL_FALLBACK_IDS",
+    "AgyProviderAdapter",
+    "CodexProviderAdapter",
+    "OllamaCloudProviderAdapter",
+    "OllamaProviderAdapter",
+    "OpenRouterProviderAdapter",
+    "LMStudioProviderAdapter",
+    "NvidiaHostedProviderAdapter",
+    "SelfHostedNimProviderAdapter",
+    "VllmProviderAdapter",
+    "DeepSeekProviderAdapter",
+    "FireworksProviderAdapter",
+    "ZaiProviderAdapter",
+    "KimiProviderAdapter",
+    "OpenCodeProviderAdapter",
+    "OpenCodeGoProviderAdapter",
+    "COMPATIBLE_PROVIDER_SPECS",
+    "CatalogOpenAIProviderAdapter",
+    "CompatibleProviderSpec",
+]

package/ciel_runtime_support/providers/anthropic.py

@@ -0,0 +1,160 @@
+"""Anthropic native and routed provider adapter."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+
+from ..architecture import (
+    ProviderCapabilities,
+    ProviderConfigurationPolicy,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+    ProviderUiPolicy,
+)
+from .base import NoAuthProviderAdapter, provider_configuration
+from .constants import PROVIDER_DEFAULT_BASE_URLS
+
+
+@dataclass(frozen=True)
+class AnthropicProviderAdapter(NoAuthProviderAdapter):
+    name: str = "anthropic"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["anthropic"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "claude-sonnet-4-6", route_through_router=False
+        )
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="anthropic_messages",
+            supports_thinking=True,
+            preserves_anthropic_thinking=True,
+            blocks_default_tools=False,
+            repairs_anthropic_tool_input=True,
+        )
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/v1/messages",
+            models_path="/v1/models",
+            credential_strategy="anthropic_inbound",
+            normalize_historical_tool_turns=False,
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(kind="anthropic")
+    )
+
+    def advisor_panel_notice(
+        self, config: ProviderConfig
+    ) -> tuple[tuple[str, ...], tuple[str, ...]]:
+        del config
+        return (
+            (
+                "Claude native and Anthropic routed sessions use Claude Code's",
+                "built-in /advisor (run /advisor in the session to pick its model).",
+                "Back",
+            ),
+            ("back", "back", "back"),
+        )
+
+    def configuration_policy(
+        self, config: ProviderConfig
+    ) -> ProviderConfigurationPolicy:
+        del config
+        return ProviderConfigurationPolicy(
+            supports_route_through_router=True, restricts_runtime_options=True
+        )
+
+    def supports_server_advisor_tool(self, config: ProviderConfig) -> bool:
+        del config
+        return True
+
+    def context_compaction_available(self, config: ProviderConfig) -> bool:
+        return bool(config.api_keys)
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        routed = bool(config.options.get("route_through_router"))
+        return ProviderContextPolicy(
+            capacity_strategy="anthropic_hint" if routed else "managed",
+            hosted_timeout=True,
+            managed_preset_inference=True,
+            status_capacity_strategy="provider" if routed else "configured",
+        )
+
+    def intercepts_advisor_shortcut(self, config: ProviderConfig) -> bool:
+        del config
+        return False
+
+    def routing_mode_update(self, enabled: bool) -> tuple[str, ...]:
+        mode = (
+            "routed through ciel-runtime router" if enabled else "direct Claude Native"
+        )
+        return ("Anthropic routing mode updated.", f"mode: {mode}")
+
+    def selection_config_updates(self, config: ProviderConfig) -> Mapping[str, Any]:
+        del config
+        return {"route_through_router": False}
+
+    def selection_status_lines(self, config: ProviderConfig) -> tuple[str, ...]:
+        del config
+        return ("mode: anthropic-native",)
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        del config
+        return ProviderOptionPresentationPolicy(
+            show_route=True, show_ip_family_control=True
+        )
+
+    def ui_policy(self, config: ProviderConfig) -> ProviderUiPolicy:
+        del config
+        return ProviderUiPolicy(
+            menu_label="Claude Native",
+            routed_menu_label="Anthropic routed",
+            native_choice="anthropic:native",
+            routed_choice="anthropic:routed",
+            advisor_placeholder="Claude Code native /advisor",
+            uses_native_advisor=True,
+        )
+
+    def option_timeout_default(self) -> str:
+        return "Claude Code default"
+
+    def propagates_inbound_beta_query(self, config: ProviderConfig) -> bool:
+        del config
+        return True
+
+    def api_key_status(
+        self, config: ProviderConfig, *, key_count: int, primary_detail: str
+    ) -> str:
+        routed = bool(config.options.get("route_through_router"))
+        scope = "Anthropic routed" if routed else "Anthropic"
+        if key_count > 1:
+            return f"API keys: {key_count} keys, round-robin ({scope}{primary_detail})"
+        if key_count:
+            return f"API key: set ({scope}{primary_detail})"
+        return (
+            "API key: not set (uses Claude Code OAuth/API auth headers)"
+            if routed
+            else "API key: not set (use API key or Claude login)"
+        )
+
+    def build_model_headers(
+        self, config: ProviderConfig, api_key: str | None
+    ) -> Mapping[str, str]:
+        del config
+        key = str(api_key or "").strip()
+        return (
+            {"anthropic-version": "2023-06-01", "x-api-key": key}
+            if key
+            else {"anthropic-version": "2023-06-01"}
+        )
+
+
+__all__ = ["AnthropicProviderAdapter"]

package/ciel_runtime_support/providers/anthropic_catalog.py

@@ -0,0 +1,119 @@
+"""Declarative adapters for Anthropic Messages-compatible API providers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import partial
+from typing import Callable
+
+from ..architecture import (
+    ProviderAdapter,
+    ProviderCapabilities,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderRequestPolicy,
+)
+from ..runtime_constants import DEFAULT_REQUEST_TIMEOUT_MS
+from .base import HttpBearerProviderAdapter, provider_configuration
+
+
+@dataclass(frozen=True, slots=True)
+class AnthropicCompatibleProviderSpec:
+    name: str
+    label: str
+    base_url: str
+    models: tuple[str, ...]
+    aliases: tuple[str, ...] = ()
+
+
+class CatalogAnthropicProviderAdapter(HttpBearerProviderAdapter):
+    """Anthropic-compatible transport assembled from immutable provider data."""
+
+    def __init__(
+        self,
+        spec: AnthropicCompatibleProviderSpec,
+        *,
+        base_url: str = "",
+    ) -> None:
+        self.spec = spec
+        super().__init__(
+            name=spec.name,
+            base_url=base_url or spec.base_url,
+            configuration_defaults_value=provider_configuration(
+                spec.models[0],
+                custom_models=spec.models,
+                native_compat=True,
+                preserve_anthropic_thinking=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,
+            ),
+            require_api_key=True,
+            api_key_display_name_value=spec.label,
+            api_key_launch_error_value=(
+                f"Launch blocked: {spec.label} requires an API key."
+            ),
+            capabilities_value=ProviderCapabilities(
+                upstream_protocol="anthropic_messages",
+                requires_api_key=True,
+                supports_thinking=True,
+                preserves_anthropic_thinking=True,
+            ),
+            request_policy_value=ProviderRequestPolicy(
+                chat_path="/v1/messages",
+                models_path="/v1/models",
+            ),
+            model_catalog_policy_value=ProviderModelCatalogPolicy(
+                kind="openai",
+                fallback_models=spec.models,
+                allow_configured_fallback=True,
+            ),
+        )
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="configured_first",
+            settings_strategy="standard",
+            hosted_timeout=True,
+        )
+
+
+def anthropic_catalog_provider_factory(
+    spec: AnthropicCompatibleProviderSpec,
+) -> Callable[..., ProviderAdapter]:
+    return partial(CatalogAnthropicProviderAdapter, spec)
+
+
+ANTHROPIC_COMPATIBLE_PROVIDER_SPECS = (
+    AnthropicCompatibleProviderSpec(
+        "minimax",
+        "MiniMax",
+        "https://api.minimax.io/anthropic",
+        ("MiniMax-M2.5", "MiniMax-M2.1", "MiniMax-M2"),
+    ),
+    AnthropicCompatibleProviderSpec(
+        "minimax-cn",
+        "MiniMax China",
+        "https://api.minimaxi.com/anthropic",
+        ("MiniMax-M2.5", "MiniMax-M2.1", "MiniMax-M2"),
+        ("minimaxi",),
+    ),
+)
+
+ANTHROPIC_CATALOG_PROVIDER_BASE_URLS = {
+    spec.name: spec.base_url for spec in ANTHROPIC_COMPATIBLE_PROVIDER_SPECS
+}
+
+
+__all__ = [
+    "ANTHROPIC_CATALOG_PROVIDER_BASE_URLS",
+    "ANTHROPIC_COMPATIBLE_PROVIDER_SPECS",
+    "AnthropicCompatibleProviderSpec",
+    "CatalogAnthropicProviderAdapter",
+    "anthropic_catalog_provider_factory",
+]

package/ciel_runtime_support/providers/base.py

@@ -0,0 +1,232 @@
+"""Shared transport bases for concrete provider adapters."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import Any, Mapping, Sequence
+
+from ..architecture import (
+    MessageProtocol,
+    ModelInfo,
+    ProviderAdapter,
+    ProviderCapabilities,
+    ProviderConfigurationPolicy,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+)
+
+
+ROUTER_STATUS_FIELDS: tuple[str, ...] = (
+    "context_window",
+    "context_reserve_tokens",
+    "max_output_tokens",
+    "request_timeout_ms",
+    "stream_idle_timeout_ms",
+)
+
+
+def configuration_policy(**values: Any) -> ProviderConfigurationPolicy:
+    status_fields = values.pop("status_fields", ROUTER_STATUS_FIELDS)
+    return ProviderConfigurationPolicy(status_fields=status_fields, **values)
+
+
+def provider_configuration(
+    current_model: str = "",
+    *,
+    api_key: str = "",
+    custom_models: Sequence[str] = (),
+    **values: Any,
+) -> dict[str, Any]:
+    """Build the common persisted configuration shape for one provider."""
+
+    return {
+        "api_key": api_key,
+        "current_model": current_model,
+        "advisor_model": "",
+        "custom_models": list(custom_models),
+        **values,
+    }
+
+
+@dataclass(frozen=True)
+class HttpBearerProviderAdapter(ProviderAdapter):
+    """Provider adapter for bearer/x-api-key compatible APIs."""
+
+    name: str
+    base_url: str = ""
+    configuration_defaults_value: Mapping[str, Any] = field(default_factory=dict)
+    authorization_header: str = "authorization"
+    include_x_api_key: bool = True
+    require_api_key: bool = False
+    send_placeholder_key: bool = False
+    api_key_display_name_value: str = ""
+    api_key_launch_error_value: str = ""
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=ProviderCapabilities
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/v1/chat/completions",
+            models_path="/v1/models",
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=ProviderModelCatalogPolicy
+    )
+
+    def default_base_url(self) -> str:
+        return self.base_url
+
+    def default_configuration(self) -> Mapping[str, Any]:
+        defaults = dict(super().default_configuration())
+        defaults.update(deepcopy(dict(self.configuration_defaults_value)))
+        defaults["base_url"] = self.default_base_url()
+        return defaults
+
+    def list_models(self, config: ProviderConfig) -> Sequence[ModelInfo]:
+        raw_models: Any = (
+            config.options.get("available_models") or config.options.get("models") or ()
+        )
+        if isinstance(raw_models, str):
+            raw_models = [raw_models]
+        models: list[ModelInfo] = []
+        if isinstance(raw_models, (list, tuple)):
+            for item in raw_models:
+                if isinstance(item, str) and item.strip():
+                    models.append(ModelInfo(id=item.strip()))
+                elif isinstance(item, dict) and str(item.get("id") or "").strip():
+                    models.append(ModelInfo(id=str(item["id"]).strip(), raw=item))
+        if config.model and all(model.id != config.model for model in models):
+            models.insert(0, ModelInfo(id=config.model))
+        return tuple(models)
+
+    def build_headers(
+        self, config: ProviderConfig, api_key: str | None
+    ) -> Mapping[str, str]:
+        key = str(api_key or "").strip()
+        if self.require_api_key and not key:
+            raise RuntimeError(f"{self.name} requires a configured API key.")
+        if not key and self.send_placeholder_key:
+            key = "not-used"
+        if not key:
+            return {}
+        headers = {self.authorization_header: f"Bearer {key}"}
+        if self.include_x_api_key:
+            headers["x-api-key"] = key
+        return headers
+
+    def capabilities(self, config: ProviderConfig) -> ProviderCapabilities:
+        del config
+        return self.capabilities_value
+
+    def request_policy(self, config: ProviderConfig) -> ProviderRequestPolicy:
+        del config
+        return self.request_policy_value
+
+    def model_catalog_policy(
+        self, config: ProviderConfig
+    ) -> ProviderModelCatalogPolicy:
+        del config
+        return self.model_catalog_policy_value
+
+    def configuration_policy(
+        self, config: ProviderConfig
+    ) -> ProviderConfigurationPolicy:
+        del config
+        return configuration_policy()
+
+    def api_key_display_name(self) -> str:
+        return self.api_key_display_name_value
+
+    def launch_api_key_error(self, config: ProviderConfig) -> str | None:
+        if self.capabilities(config).requires_api_key and not config.api_keys:
+            return self.api_key_launch_error_value or super().launch_api_key_error(
+                config
+            )
+        return None
+
+    def build_model_headers(
+        self, config: ProviderConfig, api_key: str | None
+    ) -> Mapping[str, str]:
+        del config
+        key = str(api_key or "").strip()
+        if not key:
+            return {}
+        headers = {self.authorization_header: f"Bearer {key}"}
+        if self.include_x_api_key:
+            headers["x-api-key"] = key
+        return headers
+
+
+@dataclass(frozen=True)
+class NoAuthProviderAdapter(HttpBearerProviderAdapter):
+    def build_headers(
+        self, config: ProviderConfig, api_key: str | None
+    ) -> Mapping[str, str]:
+        del config, api_key
+        return {}
+
+
+@dataclass(frozen=True)
+class OpenAICompatibleProviderAdapter(HttpBearerProviderAdapter):
+    """Base for providers that implement the OpenAI Chat/Models wire surface."""
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="hint_configured", settings_strategy="standard"
+        )
+
+    def router_native_anthropic_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        del model
+        return bool(config.options.get("native_compat", True))
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        del config
+        return ProviderOptionPresentationPolicy(
+            show_native=True,
+            show_tool_choice=True,
+            show_sampling=True,
+            show_stream=True,
+            show_rate_limit_controls=True,
+            show_sampling_controls=True,
+            show_ip_family_control=True,
+        )
+
+    def supported_protocols(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> frozenset[MessageProtocol]:
+        del model
+        protocols: set[MessageProtocol] = {"openai_chat"}
+        native = config.options.get("native_compat")
+        if native is True or str(native).strip().lower() in {"1", "true", "yes", "on"}:
+            protocols.add("anthropic_messages")
+        return frozenset(protocols)
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        supported = self.supported_protocols(config, model)
+        if operation == "anthropic_messages" and "anthropic_messages" in supported:
+            return "anthropic_messages"
+        return "openai_chat"
+
+
+__all__ = [
+    "HttpBearerProviderAdapter",
+    "NoAuthProviderAdapter",
+    "OpenAICompatibleProviderAdapter",
+    "ROUTER_STATUS_FIELDS",
+    "configuration_policy",
+]