@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/providers/fireworks.py

@@ -0,0 +1,158 @@
+"""Fireworks.ai provider adapter."""
+
+from dataclasses import dataclass, field, replace
+import re
+from typing import Any, Mapping
+from urllib.parse import quote
+
+from ..architecture import (
+    MessageProtocol,
+    ProviderCapabilities,
+    ProviderConfigurationPolicy,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderStatusPolicy,
+)
+from .base import (
+    OpenAICompatibleProviderAdapter,
+    configuration_policy,
+    provider_configuration,
+)
+from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+
+
+@dataclass(frozen=True)
+class FireworksProviderAdapter(OpenAICompatibleProviderAdapter):
+    name: str = "fireworks"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["fireworks"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "accounts/fireworks/models/kimi-k2p5",
+            custom_models=("accounts/fireworks/models/kimi-k2p5",),
+            native_compat=True,
+            account_id="fireworks",
+            model_api_base_url="https://api.fireworks.ai",
+            context_window=262144,
+            max_output_tokens=8192,
+            context_reserve_tokens=8192,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+            haiku_model="accounts/fireworks/models/kimi-k2p5",
+            subagent_model="accounts/fireworks/models/kimi-k2p5",
+        )
+    )
+    send_placeholder_key: bool = True
+    api_key_display_name_value: str = "Fireworks.ai"
+    api_key_launch_error_value: str = (
+        "Launch blocked: Fireworks.ai requires a Fireworks API key."
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="openai_chat", requires_api_key=True
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(kind="fireworks")
+    )
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="configured_first",
+            settings_strategy="standard",
+            hosted_timeout=True,
+        )
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        return replace(super().option_presentation_policy(config), show_sampling=False)
+
+    def supported_protocols(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> frozenset[MessageProtocol]:
+        del config, model
+        return frozenset({"anthropic_messages", "openai_chat"})
+
+    def status_policy(self, config: ProviderConfig) -> ProviderStatusPolicy:
+        account_id = str(config.options.get("account_id") or "").strip()
+        if not account_id:
+            match = re.match(r"^accounts/([^/]+)/models/[^/]+$", config.model)
+            account_id = match.group(1) if match else "fireworks"
+        return ProviderStatusPolicy(
+            kind="catalog",
+            label="Fireworks.ai",
+            catalog_path=f"/v1/accounts/{quote(account_id, safe='')}/models?pageSize=1",
+            catalog_scope="fireworks_management",
+            catalog_count_label="sampled",
+        )
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        del config, model
+        return (
+            "openai_chat"
+            if operation in {"openai_chat", "openai_responses"}
+            else "anthropic_messages"
+        )
+
+    def configuration_policy(
+        self, config: ProviderConfig
+    ) -> ProviderConfigurationPolicy:
+        del config
+        return configuration_policy(
+            text_option_aliases={
+                "account": "account_id",
+                "account_id": "account_id",
+                "management_base_url": "model_api_base_url",
+                "model_api_base_url": "model_api_base_url",
+                "model_base_url": "model_api_base_url",
+                "models_base_url": "model_api_base_url",
+            },
+            strip_trailing_slash_fields=frozenset({"model_api_base_url"}),
+        )
+
+    def project_model_metadata(self, raw: Mapping[str, Any]) -> Mapping[str, Any]:
+        metadata = dict(super().project_model_metadata(raw))
+        for source_key, target_key in (
+            ("displayName", "display_name"),
+            ("description", "description"),
+            ("kind", "kind"),
+            ("importedFrom", "imported_from"),
+        ):
+            value = raw.get(source_key)
+            if value is not None:
+                metadata[target_key] = value
+        for source_key, target_key in (
+            ("supportsTools", "supports_tool_call"),
+            ("supportsImageInput", "supports_vision"),
+            ("public", "public"),
+            ("supportsServerless", "supports_serverless"),
+        ):
+            value = raw.get(source_key)
+            if isinstance(value, bool):
+                metadata[target_key] = value
+        details = raw.get("baseModelDetails")
+        if isinstance(details, Mapping):
+            if details.get("parameterCount") is not None:
+                metadata["parameter_count"] = str(details["parameterCount"])
+            for source_key, target_key in (
+                ("worldSize", "world_size"),
+                ("checkpointFormat", "checkpoint_format"),
+                ("modelType", "model_type"),
+                ("defaultPrecision", "default_precision"),
+            ):
+                value = details.get(source_key)
+                if value is not None:
+                    metadata[target_key] = value
+        return metadata
+
+
+__all__ = ["FireworksProviderAdapter"]

package/ciel_runtime_support/providers/github_copilot_oauth.py

@@ -0,0 +1,199 @@
+"""GitHub Copilot provider backed by GitHub Device OAuth."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+
+from ..architecture import (
+    MessageProtocol,
+    ProviderCapabilities,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+    ProviderStatusPolicy,
+)
+from ..github_copilot_oauth import (
+    COPILOT_API_VERSION,
+    COPILOT_CHAT_VERSION,
+    COPILOT_USER_AGENT,
+    COPILOT_VSCODE_VERSION,
+)
+from .base import HttpBearerProviderAdapter, provider_configuration
+
+
+GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com"
+GITHUB_COPILOT_MODELS = (
+    "gpt-5.4",
+    "gpt-5.3-codex",
+    "gpt-5.2-codex",
+    "claude-sonnet-4.6",
+    "claude-opus-4.6",
+    "gemini-3.1-pro-preview",
+)
+
+
+@dataclass(frozen=True)
+class GitHubCopilotOAuthProviderAdapter(HttpBearerProviderAdapter):
+    name: str = "github-copilot-oauth"
+    base_url: str = GITHUB_COPILOT_BASE_URL
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            GITHUB_COPILOT_MODELS[0],
+            custom_models=GITHUB_COPILOT_MODELS,
+            native_compat=True,
+            context_window=128_000,
+            max_output_tokens=16_384,
+            context_reserve_tokens=16_384,
+            request_timeout_ms=300_000,
+            stream_enabled=True,
+            stream_word_chunking=False,
+        )
+    )
+    include_x_api_key: bool = False
+    require_api_key: bool = True
+    api_key_display_name_value: str = "GitHub Copilot OAuth"
+    api_key_launch_error_value: str = (
+        "Launch blocked: GitHub Copilot OAuth login is required. "
+        "Run: ciel-runtimectl copilot-oauth login"
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="openai_chat",
+            supports_thinking=True,
+            preserves_anthropic_thinking=True,
+            requires_api_key=True,
+        )
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/chat/completions",
+            models_path="/models",
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(
+            kind="openai",
+            fallback_models=GITHUB_COPILOT_MODELS,
+            allow_configured_fallback=True,
+        )
+    )
+
+    def build_headers(
+        self,
+        config: ProviderConfig,
+        api_key: str | None,
+    ) -> Mapping[str, str]:
+        headers = dict(super().build_headers(config, api_key))
+        headers.update(
+            {
+                "copilot-integration-id": "vscode-chat",
+                "editor-version": f"vscode/{COPILOT_VSCODE_VERSION}",
+                "editor-plugin-version": (
+                    f"copilot-chat/{COPILOT_CHAT_VERSION}"
+                ),
+                "user-agent": COPILOT_USER_AGENT,
+                "openai-intent": "conversation-panel",
+                "x-github-api-version": COPILOT_API_VERSION,
+                "x-vscode-user-agent-library-version": "electron-fetch",
+                "X-Initiator": "user",
+                "Accept": "application/json",
+            }
+        )
+        return headers
+
+    def build_model_headers(
+        self,
+        config: ProviderConfig,
+        api_key: str | None,
+    ) -> Mapping[str, str]:
+        return self.build_headers(config, api_key)
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="configured_first",
+            settings_strategy="standard",
+            hosted_timeout=True,
+        )
+
+    def supported_protocols(
+        self,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> frozenset[MessageProtocol]:
+        del config, model
+        return frozenset(
+            {"openai_chat", "openai_responses", "anthropic_messages"}
+        )
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        del config
+        normalized = str(model or "").lower()
+        if "claude" in normalized:
+            return "anthropic_messages"
+        if operation == "openai_responses" and not any(
+            family in normalized for family in ("gemini", "claude")
+        ):
+            return "openai_responses"
+        return "openai_chat"
+
+    def router_native_anthropic_enabled(
+        self,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> bool:
+        del config
+        return "claude" in str(model or "").lower()
+
+    def normalize_request_options(
+        self,
+        config: ProviderConfig,
+        request: Mapping[str, Any],
+    ) -> Mapping[str, Any]:
+        del config
+        normalized = dict(request)
+        if normalized.get("reasoning_effort") == "none":
+            normalized.pop("reasoning_effort", None)
+        model = str(normalized.get("model") or "").lower()
+        if (
+            ("gpt-5" in model or model.startswith(("o1", "o3", "o4")))
+            and "max_tokens" in normalized
+        ):
+            normalized["max_completion_tokens"] = normalized.pop("max_tokens")
+        return normalized
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        del config
+        return ProviderOptionPresentationPolicy(
+            show_native=True,
+            show_tool_choice=True,
+            show_stream=True,
+            show_rate_limit_controls=True,
+            show_sampling_controls=False,
+            show_ip_family_control=True,
+        )
+
+    def status_policy(self, config: ProviderConfig) -> ProviderStatusPolicy:
+        del config
+        return ProviderStatusPolicy(
+            kind="catalog",
+            label="GitHub Copilot OAuth",
+            catalog_path="/models",
+        )
+
+
+__all__ = [
+    "GITHUB_COPILOT_BASE_URL",
+    "GITHUB_COPILOT_MODELS",
+    "GitHubCopilotOAuthProviderAdapter",
+]

package/ciel_runtime_support/providers/kimi.py

@@ -0,0 +1,297 @@
+"""Kimi provider adapter."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Mapping
+
+from ..architecture import (
+    MessageProtocol,
+    ProviderCapabilities,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+    ProviderStatusPolicy,
+    ProviderUiPolicy,
+)
+from .base import HttpBearerProviderAdapter, provider_configuration
+from .constants import PROVIDER_DEFAULT_BASE_URLS
+from ..runtime_constants import KIMI_MODEL_FALLBACK_IDS
+from ..kimi_identity import identity_headers, oauth_access_token
+
+
+@dataclass(frozen=True)
+class KimiProviderAdapter(HttpBearerProviderAdapter):
+    name: str = "kimi"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["kimi"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "kimi-for-coding",
+            custom_models=KIMI_MODEL_FALLBACK_IDS,
+            native_compat=True,
+            preserve_anthropic_thinking=True,
+            normalize_anthropic_tool_use=True,
+            supports_tool_choice=True,
+            claude_code_supported_capabilities=["effort", "thinking"],
+            context_window=262144,
+            max_output_tokens=32768,
+            context_reserve_tokens=32768,
+            request_timeout_ms=600000,
+            stream_enabled=True,
+            stream_word_chunking=False,
+            effort_level="high",
+            haiku_model="kimi-for-coding",
+            subagent_model="kimi-for-coding",
+        )
+    )
+    send_placeholder_key: bool = True
+    api_key_display_name_value: str = "Kimi.com"
+    api_key_launch_error_value: str = (
+        "Launch blocked: Kimi.com requires a Kimi API key."
+    )
+
+    def build_headers(
+        self, config: ProviderConfig, api_key: str | None
+    ) -> Mapping[str, str]:
+        token = api_key or oauth_access_token(Path.home())
+        headers = dict(super().build_headers(config, token))
+        headers.update(identity_headers(Path.home()))
+        return headers
+
+    def launch_api_key_error(self, config: ProviderConfig) -> str | None:
+        if oauth_access_token(Path.home()) is not None:
+            return None
+        return super().launch_api_key_error(config)
+    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="/v1/messages", models_path="/v1/models"
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(
+            kind="openai", allow_configured_fallback=True
+        )
+    )
+
+    def routing_mode_update(self, enabled: bool) -> tuple[str, ...]:
+        return ("Kimi Code routing mode updated.", f"mode: {'kimi-routed' if enabled else 'kimi-native'}")
+
+    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, ...]:
+        return (f"mode: {'kimi-routed' if config.options.get('route_through_router') else 'kimi-native'}",)
+
+    def ui_policy(self, config: ProviderConfig) -> ProviderUiPolicy:
+        del config
+        return ProviderUiPolicy(menu_label="Kimi Native", routed_menu_label="Kimi Routed", native_choice="kimi:native", routed_choice="kimi:routed")
+
+    def normalize_model_id(self, model_id: str) -> str:
+        raw = str(model_id or "").strip()
+        wants_one_million = raw.lower().endswith("[1m]")
+        normalized = super().normalize_model_id(raw)
+        lowered = normalized.lower().replace("_", "-").strip()
+        if lowered in ("k3", "kimi-k3", "kimi/k3", "kimi-code/k3"):
+            return "k3[1m]" if wants_one_million else "k3"
+        if lowered in (
+            "kimi-code/kimi-for-coding",
+            "kimi/kimi-for-coding",
+            "moonshot/kimi-for-coding",
+            "kimi-k2.7-code",
+            "kimi-k2.7-coding",
+            "k2.7-code",
+            "k2.7-coding",
+        ):
+            return "kimi-for-coding"
+        if lowered in (
+            "kimi-for-coding-highspeed",
+            "kimi-code/kimi-for-coding-highspeed",
+            "kimi/kimi-for-coding-highspeed",
+        ):
+            return "kimi-for-coding-highspeed"
+        return normalized
+
+    def upstream_api_model_id(self, model_id: str) -> str:
+        normalized = self.normalize_model_id(model_id)
+        return "k3" if normalized == "k3[1m]" else normalized
+
+    def model_configuration_profile(
+        self, config: ProviderConfig
+    ) -> tuple[Mapping[str, Any], str | None]:
+        model = self.normalize_model_id(config.model)
+        if model == "kimi-for-coding-highspeed":
+            return (
+                {
+                    "context_window": 262144,
+                    "max_model_len": 262144,
+                    "model_profile": "kimi-k2.7-highspeed-256k",
+                },
+                "Kimi K2.7 Code HighSpeed profile applied: 256K context; "
+                "requires Allegretto or above and uses about 3x quota. Start a new session.",
+            )
+        if model == "kimi-for-coding":
+            return (
+                {
+                    "context_window": 262144,
+                    "max_model_len": 262144,
+                    "model_profile": "kimi-k2.7-256k",
+                },
+                "Kimi K2.7 Code profile applied: 256K context with Thinking enabled. "
+                "Start a new session after changing models.",
+            )
+        if model not in {"k3", "k3[1m]"}:
+            return {}, None
+        context = 1048576
+        return (
+            {
+                "context_window": context,
+                "max_model_len": context,
+                "effort_level": "high",
+                "model_profile": "kimi-k3-1m",
+            },
+            "Kimi K3 profile applied: 1M context and high reasoning effort. "
+            "Start a new session after changing model, context, or reasoning effort.",
+        )
+
+    def model_selection_config_updates(
+        self, config: ProviderConfig, model_id: str
+    ) -> dict[str, str]:
+        del config
+        return {
+            "haiku_model": model_id,
+            "opus_model": model_id,
+            "sonnet_model": model_id,
+            "subagent_model": model_id,
+        }
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="hint_first",
+            settings_strategy="standard",
+            hosted_timeout=True,
+        )
+
+    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_stream=True,
+            show_rate_limit_controls=True,
+            show_sampling_controls=False,
+            show_ip_family_control=True,
+        )
+
+    def supported_protocols(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> frozenset[MessageProtocol]:
+        del config, model
+        return frozenset({"anthropic_messages", "openai_chat"})
+
+    def status_policy(self, config: ProviderConfig) -> ProviderStatusPolicy:
+        del config
+        return ProviderStatusPolicy(
+            kind="catalog", label="Kimi.com", catalog_path="/v1/models"
+        )
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        del config, model
+        return (
+            "openai_chat"
+            if operation in {"openai_chat", "openai_responses"}
+            else "anthropic_messages"
+        )
+
+    def normalize_request_options(
+        self, config: ProviderConfig, request: Mapping[str, Any]
+    ) -> Mapping[str, Any]:
+        del config
+        model = (
+            str(request.get("model") or "")
+            .split("[", 1)[0]
+            .strip()
+            .lower()
+            .replace("_", "-")
+        )
+        if model.startswith("ciel-runtime-kimi-"):
+            model = model[len("ciel-runtime-kimi-") :]
+        normalized = dict(request)
+        for key in ("temperature", "top_p", "top_k", "n"):
+            normalized.pop(key, None)
+        thinking = request.get("thinking")
+        if not isinstance(thinking, Mapping):
+            return normalized
+        if str(thinking.get("type") or "").strip().lower() == "disabled":
+            thinking = {**thinking, "type": "enabled"}
+        if model in {"k3", "k3-1m", "kimi-k3", "kimi/k3", "kimi-code/k3"}:
+            normalized["thinking"] = {
+                **thinking,
+                "effort": self._reasoning_effort(thinking.get("effort")),
+            }
+        else:
+            normalized["thinking"] = thinking
+        return normalized
+
+    def openai_reasoning_effort(
+        self, config: ProviderConfig, model: str, request: Mapping[str, Any]
+    ) -> str | None:
+        if self.normalize_model_id(model) not in {"k3", "k3[1m]"}:
+            return None
+        thinking = request.get("thinking")
+        requested = thinking.get("effort") if isinstance(thinking, Mapping) else None
+        if requested is None:
+            requested = config.options.get("effort_level")
+        return self._reasoning_effort(requested)
+
+    def allows_sampling_overrides(self, config: ProviderConfig) -> bool:
+        del config
+        return False
+
+    @staticmethod
+    def _reasoning_effort(value: Any) -> str:
+        effort = str(value or "high").strip().lower()
+        if effort == "ultra":
+            return "max"
+        if effort in {"minimum", "light"}:
+            return "low"
+        if effort in {"low", "medium", "high", "xhigh", "max"}:
+            return effort
+        return "high"
+
+    def normalize_tool_choice(
+        self, config: ProviderConfig, model: str, tool_choice: Any
+    ) -> Any:
+        del model
+        if config.options.get("supports_tool_choice") is False or not isinstance(
+            tool_choice, Mapping
+        ):
+            return tool_choice
+        if str(tool_choice.get("type") or "").strip().lower() in {"any", "tool"}:
+            return {"type": "auto"}
+        return tool_choice
+
+
+__all__ = ["KimiProviderAdapter"]