@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/kimi_runtime_context.py

@@ -0,0 +1,208 @@
+"""Kimi Code installation, OAuth identity, and launch bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class KimiIdentityPorts:
+    home: Path
+    code_home: Callable[[Path], Path]
+    token_record: Callable[[Path], dict[str, Any] | None]
+    access_token: Callable[[Path], str | None]
+    configured: Callable[[Path], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class KimiProcessPorts:
+    find_executable: Callable[[str], str | None]
+    run: Callable[..., Any]
+    call: Callable[..., int]
+    print_line: Callable[..., None]
+    environment: dict[str, str]
+    augment_path: Callable[[dict[str, str]], str]
+
+
+@dataclass(frozen=True, slots=True)
+class KimiConfigurationPorts:
+    load: Callable[[], dict[str, Any]]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    provider_has_key: Callable[[str, dict[str, Any]], bool]
+    current_alias: Callable[[dict[str, Any]], str]
+    positive_int: Callable[[Any], int | None]
+    clear_api_key: Callable[[str], list[str]]
+    router_base: str
+
+
+@dataclass(frozen=True, slots=True)
+class KimiLifecyclePorts:
+    install: Callable[[], str]
+    oauth_configured: Callable[[], bool]
+    oauth_login: Callable[[], int]
+    start_router: Callable[[], Any]
+    run_with_router: Callable[[Callable[[], int], bool], int]
+
+
+@dataclass(frozen=True, slots=True)
+class KimiRuntimeContext:
+    identity: KimiIdentityPorts
+    process: KimiProcessPorts
+    config: KimiConfigurationPorts
+    lifecycle: KimiLifecyclePorts
+
+    def code_home(self) -> Path:
+        return self.identity.code_home(self.identity.home)
+
+    def oauth_token_record(self) -> dict[str, Any] | None:
+        return self.identity.token_record(self.identity.home)
+
+    def oauth_access_token(self) -> str | None:
+        return self.identity.access_token(self.identity.home)
+
+    def oauth_configured(self) -> bool:
+        return self.identity.configured(self.identity.home)
+
+    def install_if_missing(self) -> str:
+        executable = self.process.find_executable("kimi")
+        if executable:
+            return executable
+        npm = self.process.find_executable("npm")
+        if not npm:
+            raise RuntimeError(
+                "Kimi Code CLI is missing; install @moonshot-ai/kimi-code "
+                "(Node.js 22.19+)."
+            )
+        self.process.print_line(
+            "Installing official Kimi Code CLI (@moonshot-ai/kimi-code)...",
+            flush=True,
+        )
+        result = self.process.run(
+            [npm, "install", "-g", "@moonshot-ai/kimi-code"], check=False
+        )
+        if result.returncode:
+            raise RuntimeError(
+                f"Kimi Code CLI installation failed (exit {result.returncode})."
+            )
+        executable = self.process.find_executable("kimi")
+        if not executable:
+            raise RuntimeError(
+                "Kimi Code CLI installed but 'kimi' is not available on PATH."
+            )
+        return executable
+
+    def oauth_login(self) -> int:
+        return self.process.call([self.lifecycle.install(), "login"])
+
+    def oauth_action(self, action: str) -> list[str]:
+        if action != "login":
+            return [f"Unsupported Kimi OAuth action: {action}"]
+        try:
+            code = self.lifecycle.oauth_login()
+        except Exception as exc:
+            return [f"Kimi OAuth login failed: {type(exc).__name__}: {exc}"]
+        if code:
+            return [f"Kimi OAuth login exited with status {code}."]
+        if not self.lifecycle.oauth_configured():
+            return [
+                "Kimi OAuth login exited successfully, but no usable credential "
+                "was detected; the existing Kimi API key was not cleared."
+            ]
+        messages = [
+            "Kimi OAuth login completed in the official Kimi Code credential store."
+        ]
+        messages.extend(self.config.clear_api_key("kimi"))
+        return messages
+
+    def launch(self, passthrough: list[str]) -> int:
+        cfg = self.config.load()
+        provider, pcfg = self.config.current_provider(cfg)
+        if provider != "kimi":
+            self.process.print_line(
+                "Launch Kimi Code requires Kimi Native or Kimi Routed provider.",
+                flush=True,
+            )
+            return 2
+        executable = self.lifecycle.install()
+        routed = bool(pcfg.get("route_through_router"))
+        env = self.process.environment.copy()
+        env["PATH"] = self.process.augment_path(env)
+        if not routed:
+            if not self.lifecycle.oauth_configured():
+                self.process.print_line(
+                    "Kimi Code OAuth login is required for first launch.", flush=True
+                )
+                if self.process.call([executable, "login"], env=env):
+                    return 1
+            return self.process.call([executable, *passthrough], env=env)
+        if (
+            not self.config.provider_has_key(provider, pcfg)
+            and not self.lifecycle.oauth_configured()
+        ):
+            self.process.print_line(
+                "Kimi Routed requires Kimi OAuth login or a Kimi API key.",
+                flush=True,
+            )
+            if self.process.call([executable, "login"], env=env):
+                return 1
+        manage_router = bool(self.lifecycle.start_router())
+        env.update(
+            {
+                "KIMI_MODEL_NAME": self.config.current_alias(cfg)
+                or str(pcfg.get("current_model") or "kimi-for-coding"),
+                "KIMI_MODEL_API_KEY": "ciel-runtime-router-local-key",
+                "KIMI_MODEL_PROVIDER_TYPE": "openai",
+                "KIMI_MODEL_BASE_URL": f"{self.config.router_base.rstrip('/')}/v1",
+                "KIMI_MODEL_MAX_CONTEXT_SIZE": str(
+                    self.config.positive_int(pcfg.get("context_window")) or 262144
+                ),
+                "KIMI_MODEL_THINKING_EFFORT": str(
+                    pcfg.get("effort_level") or "high"
+                ),
+            }
+        )
+        return self.lifecycle.run_with_router(
+            lambda: self.process.call([executable, *passthrough], env=env),
+            manage_router,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class KimiRuntimeCompatibilityApi:
+    context: Callable[[], KimiRuntimeContext]
+
+    def code_home(self) -> Path:
+        return self.context().code_home()
+
+    def oauth_token_record(self) -> dict[str, Any] | None:
+        return self.context().oauth_token_record()
+
+    def oauth_access_token(self) -> str | None:
+        return self.context().oauth_access_token()
+
+    def oauth_configured(self) -> bool:
+        return self.context().oauth_configured()
+
+    def install_if_missing(self) -> str:
+        return self.context().install_if_missing()
+
+    def oauth_login(self) -> int:
+        return self.context().oauth_login()
+
+    def oauth_action(self, action: str) -> list[str]:
+        return self.context().oauth_action(action)
+
+    def launch(self, passthrough: list[str]) -> int:
+        return self.context().launch(passthrough)
+
+
+__all__ = [
+    "KimiConfigurationPorts",
+    "KimiIdentityPorts",
+    "KimiLifecyclePorts",
+    "KimiProcessPorts",
+    "KimiRuntimeCompatibilityApi",
+    "KimiRuntimeContext",
+]

package/ciel_runtime_support/llm_preset_context.py

@@ -0,0 +1,338 @@
+"""LLM preset identity, recommendation, and presentation bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import Any, Callable, Mapping
+
+from .architecture import ProviderContextPolicy
+from . import llm_presets
+from .llm_presets import PresetIdentityPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetCatalog:
+    presets: Mapping[str, tuple[str, str]]
+    preset_i18n: Mapping[str, Mapping[str, tuple[str, str]]]
+    family_i18n: Mapping[str, Mapping[str, str]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetQueries:
+    load_config: Callable[[], dict[str, Any]]
+    context_policy: Callable[[str, dict[str, Any]], ProviderContextPolicy]
+    context_capacity: Callable[[str, dict[str, Any]], int | None]
+    context_services: Callable[[str], Any]
+    ui_text: Callable[[str, str | None], str]
+    pad_cells: Callable[[str, int], str]
+    format_context: Callable[[int | None], str]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetAlgorithms:
+    classify_family: Callable[..., str]
+    recommend: Callable[[str, int | None], str]
+    infer: Callable[..., str | None]
+    required_context: Callable[[str, ProviderContextPolicy], int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetDefinitionPorts:
+    context_heavy_presets: set[str] | frozenset[str]
+    llm_presets: Mapping[str, tuple[str, str]]
+    preset_text: Callable[..., tuple[str, str]]
+    load_config: Callable[[], dict[str, Any]]
+    family_text: Callable[..., str]
+    model_family: Callable[[str, dict[str, Any]], str]
+    positive_int: Callable[[Any], int | None]
+    required_context: Callable[[str, str | None], int | None]
+    ui_text: Callable[[str, str | None], str]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetContextPolicyPorts:
+    lm_studio_guard: Callable[..., list[str]]
+    ollama_output_guard: Callable[..., list[str]]
+    recommended_timeout: Callable[..., list[str]]
+    cap_context: Callable[..., list[str]]
+    cap_output: Callable[..., list[str]]
+    ollama_context_status: Callable[..., str]
+    model_capacity: Callable[..., int | None]
+    sync_ollama_context: Callable[..., list[str]]
+    upstream_context_limit: Callable[..., int | None]
+    timeout_tokens: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetMutationPorts:
+    apply_ollama_option: Callable[..., list[str]]
+    apply_provider_option: Callable[..., list[str]]
+    ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetContext:
+    catalog: LlmPresetCatalog
+    queries: LlmPresetQueries
+    algorithms: LlmPresetAlgorithms
+    definition: LlmPresetDefinitionPorts
+    policy: LlmPresetContextPolicyPorts
+    mutation: LlmPresetMutationPorts
+
+    def model_family(self, provider: str, config: dict[str, Any]) -> str:
+        return self.algorithms.classify_family(
+            config,
+            self.queries.context_policy(provider, config),
+            self.queries.context_capacity(provider, config),
+            self.queries.context_services(provider),
+        )
+
+    def recommended(self, provider: str, config: dict[str, Any]) -> str:
+        return self.algorithms.recommend(
+            self.model_family(provider, config),
+            self.queries.context_capacity(provider, config),
+        )
+
+    def slider_ids(self) -> list[str]:
+        return list(self.catalog.presets)
+
+    @staticmethod
+    def command_name(preset_id: str) -> str:
+        normalized = re.sub(
+            r"[^a-z0-9]+", "-", str(preset_id or "").lower()
+        ).strip("-")
+        return f"llm-{normalized}"
+
+    def slash_command(self, preset_id: str) -> str:
+        label, description = self.text(preset_id, "en")
+        return f"""---
+description: Apply ciel-runtime live preset: {label}
+argument-hint: [ignored]
+---
+
+CIEL_RUNTIME_LIVE_LLM_OPTIONS
+
+Value: {preset_id}
+
+Apply the ciel-runtime live LLM preset `{preset_id}` ({description}) to this routed session. The original options are captured before the first live preset change and can be restored with `/llm-restore`.
+"""
+
+    def resolve(self, value: str) -> str | None:
+        return PresetIdentityPolicy(self.catalog.presets, self.command_name).resolve(value)
+
+    def required_context(
+        self, preset_id: str, provider: str | None = None
+    ) -> int | None:
+        selected = provider or "anthropic"
+        return self.algorithms.required_context(
+            preset_id, self.queries.context_policy(selected, {})
+        )
+
+    def available(
+        self, provider: str, config: dict[str, Any], preset_id: str
+    ) -> bool:
+        required = self.required_context(preset_id, provider)
+        if not required:
+            return True
+        capacity = self.queries.context_capacity(provider, config)
+        return not capacity or required <= capacity
+
+    def infer(self, provider: str, config: dict[str, Any]) -> str | None:
+        return self.algorithms.infer(
+            config,
+            self.queries.context_policy(provider, config),
+            self.queries.context_services(provider),
+        )
+
+    def applied(self, provider: str, config: dict[str, Any]) -> str:
+        preset_id = str(config.get("llm_preset") or "").strip()
+        if preset_id in self.catalog.presets:
+            return preset_id
+        inferred = self.infer(provider, config)
+        if inferred and self.available(provider, config, inferred):
+            return inferred
+        recommended = self.recommended(provider, config)
+        return recommended if self.available(provider, config, recommended) else "balanced"
+
+    def text(self, preset_id: str, lang: str | None = None) -> tuple[str, str]:
+        language = lang or str(self.queries.load_config().get("language") or "en")
+        return self.catalog.preset_i18n.get(language, {}).get(
+            preset_id, self.catalog.presets[preset_id]
+        )
+
+    def family_text(self, family: str, lang: str | None = None) -> str:
+        language = lang or str(self.queries.load_config().get("language") or "en")
+        return self.catalog.family_i18n.get(language, {}).get(family, family)
+
+    def panel_rows(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        lang: str | None = None,
+    ) -> tuple[list[str], list[str]]:
+        language = lang or str(self.queries.load_config().get("language") or "en")
+        recommended = self.recommended(provider, config)
+        applied = self.applied(provider, config)
+        family = self.model_family(provider, config)
+        recommended_label, _ = self.text(recommended, language)
+        rows = [
+            f"{self.queries.ui_text('model_family', language)}: "
+            f"{self.family_text(family, language)}; "
+            f"{self.queries.ui_text('recommended_preset_is', language)} "
+            f"{recommended_label}"
+        ]
+        values = ["__info__"]
+        for preset_id in self.catalog.presets:
+            label, description = self.text(preset_id, language)
+            mark = "*" if preset_id == applied else " "
+            suffix = ""
+            required = self.required_context(preset_id, provider)
+            capacity = (
+                self.queries.context_capacity(provider, config) if required else None
+            )
+            if required and capacity and required > capacity:
+                suffix = (
+                    f" (requires {self.queries.format_context(required)}; "
+                    f"server {self.queries.format_context(capacity)})"
+                )
+            rows.append(
+                f"{mark} {self.queries.pad_cells(label, 24)} {description}{suffix}"
+            )
+            values.append(preset_id)
+        rows.append(self.queries.ui_text("back", language))
+        values.append("back")
+        return rows, values
+
+    def apply(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        preset_id: str,
+        lang: str | None = None,
+        *,
+        sync_ollama_context: bool = True,
+        load_lm_studio: bool = False,
+    ) -> list[str]:
+        return llm_presets.apply_preset_to_provider(
+            provider,
+            config,
+            preset_id,
+            lang,
+            sync_ollama_context=sync_ollama_context,
+            load_lm_studio=load_lm_studio,
+            services=llm_presets.PresetServices(
+                definition=llm_presets.PresetDefinition(
+                    CONTEXT_HEAVY_PRESETS=self.definition.context_heavy_presets,
+                    LLM_PRESETS=self.definition.llm_presets,
+                    llm_preset_text=self.definition.preset_text,
+                    load_config=self.definition.load_config,
+                    model_family_text=self.definition.family_text,
+                    model_option_family=self.definition.model_family,
+                    positive_int=self.definition.positive_int,
+                    required_context_for_preset=self.definition.required_context,
+                    ui_text=self.definition.ui_text,
+                ),
+                context_policy=llm_presets.PresetContextPolicy(
+                    apply_lm_studio_loaded_context_guard=self.policy.lm_studio_guard,
+                    apply_ollama_runtime_output_guard=self.policy.ollama_output_guard,
+                    apply_recommended_timeout_for_model_context=self.policy.recommended_timeout,
+                    cap_context_settings_to_model_capacity=self.policy.cap_context,
+                    cap_output_settings_to_context_ratio=self.policy.cap_output,
+                    ollama_num_ctx_status=self.policy.ollama_context_status,
+                    provider_model_context_capacity=self.policy.model_capacity,
+                    sync_ollama_library_context_limit=self.policy.sync_ollama_context,
+                    upstream_model_context_limit=self.policy.upstream_context_limit,
+                    with_preset_timeout_tokens=self.policy.timeout_tokens,
+                ),
+                provider_mutation=llm_presets.PresetProviderMutation(
+                    apply_ollama_option=self.mutation.apply_ollama_option,
+                    apply_provider_option=self.mutation.apply_provider_option,
+                    ollama_extra_options=self.mutation.ollama_options,
+                ),
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetCompatibilityApi:
+    context: Callable[[], LlmPresetContext]
+
+    def model_family(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().model_family(provider, config)
+
+    def recommended(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().recommended(provider, config)
+
+    def slider_ids(self) -> list[str]:
+        return self.context().slider_ids()
+
+    def command_name(self, preset_id: str) -> str:
+        return self.context().command_name(preset_id)
+
+    def slash_command(self, preset_id: str) -> str:
+        return self.context().slash_command(preset_id)
+
+    def resolve(self, value: str) -> str | None:
+        return self.context().resolve(value)
+
+    def required_context(
+        self, preset_id: str, provider: str | None = None
+    ) -> int | None:
+        return self.context().required_context(preset_id, provider)
+
+    def available(
+        self, provider: str, config: dict[str, Any], preset_id: str
+    ) -> bool:
+        return self.context().available(provider, config, preset_id)
+
+    def applied(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().applied(provider, config)
+
+    def infer(self, provider: str, config: dict[str, Any]) -> str | None:
+        return self.context().infer(provider, config)
+
+    def text(self, preset_id: str, lang: str | None = None) -> tuple[str, str]:
+        return self.context().text(preset_id, lang)
+
+    def family_text(self, family: str, lang: str | None = None) -> str:
+        return self.context().family_text(family, lang)
+
+    def panel_rows(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        lang: str | None = None,
+    ) -> tuple[list[str], list[str]]:
+        return self.context().panel_rows(provider, config, lang)
+
+    def apply(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        preset_id: str,
+        lang: str | None = None,
+        *,
+        sync_ollama_context: bool = True,
+        load_lm_studio: bool = False,
+    ) -> list[str]:
+        return self.context().apply(
+            provider,
+            config,
+            preset_id,
+            lang,
+            sync_ollama_context=sync_ollama_context,
+            load_lm_studio=load_lm_studio,
+        )
+
+
+__all__ = [
+    "LlmPresetAlgorithms",
+    "LlmPresetCatalog",
+    "LlmPresetCompatibilityApi",
+    "LlmPresetContext",
+    "LlmPresetContextPolicyPorts",
+    "LlmPresetDefinitionPorts",
+    "LlmPresetMutationPorts",
+    "LlmPresetQueries",
+]

package/ciel_runtime_support/managed_mcp_config.py

@@ -119,19 +119,23 @@ class ManagedMcpConfigService:
         return self.paths.channel
 
     def _fetch_command(self, web: dict[str, Any]) -> tuple[str | None, list[Any]]:
-        arguments: list[Any] = [web.get("fetch_package") or "mcp-server-fetch"]
+        package = str(web.get("fetch_package") or "mcp-server-fetch")
+        arguments: list[Any] = [package]
         if web.get("fetch_user_agent"):
             arguments.extend(["--user-agent", str(web["fetch_user_agent"])])
         if web.get("fetch_ignore_robots_txt", False):
             arguments.append("--ignore-robots-txt")
+        dependency_args = ["--with", "mcp<2"] if package == "mcp-server-fetch" else []
         command = self.ports.find_executable("uvx")
         if command:
-            return command, arguments
+            return command, [*dependency_args, *arguments]
         uv = self.ports.find_executable("uv")
         if uv:
-            return uv, ["tool", "run", *arguments]
+            return uv, ["tool", "run", *dependency_args, *arguments]
         if importlib.util.find_spec("uv") is not None:
-            return sys.executable, ["-m", "uv", "tool", "run", *arguments]
+            return sys.executable, [
+                "-m", "uv", "tool", "run", *dependency_args, *arguments
+            ]
         pipx = self.ports.find_executable("pipx")
         return (pipx, ["run", *arguments]) if pipx else (None, arguments)