@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/config_migrations.py

@@ -0,0 +1,307 @@
+"""Configuration schema migrations independent from persistence and runtime I/O."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigMigrationPolicy:
+    default_request_timeout_ms: int
+    kimi_k3_model: str
+    opencode_provider_names: tuple[str, ...]
+    is_qwen36_plus_model_id: Callable[..., Any]
+    normalize_channel_delivery: Callable[..., Any]
+    normalize_model_id: Callable[..., Any]
+    nvidia_hosted_context_default: Callable[..., Any]
+    positive_int: Callable[..., Any]
+    strip_claude_context_suffix: Callable[..., Any]
+
+
+def apply_config_migrations(cfg: dict[str, Any], *, policy: ConfigMigrationPolicy) -> None:
+    DEFAULT_REQUEST_TIMEOUT_MS = policy.default_request_timeout_ms
+    KIMI_K3_MODEL = policy.kimi_k3_model
+    OPENCODE_PROVIDER_NAMES = policy.opencode_provider_names
+    is_qwen36_plus_model_id = policy.is_qwen36_plus_model_id
+    normalize_channel_delivery = policy.normalize_channel_delivery
+    normalize_model_id = policy.normalize_model_id
+    nvidia_hosted_context_default = policy.nvidia_hosted_context_default
+    positive_int = policy.positive_int
+    strip_claude_context_suffix = policy.strip_claude_context_suffix
+    migrations = cfg.setdefault("migrations", {})
+    if not isinstance(migrations, dict):
+        migrations = {}
+        cfg["migrations"] = migrations
+
+    marker = "ollama_cloud_glm52_thinking_context_20260711"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("ollama-cloud", {})
+        if isinstance(pcfg, dict):
+            model = strip_claude_context_suffix(str(pcfg.get("current_model") or "")).lower()
+            if model in {"glm-5.2", "glm-5.2:cloud"}:
+                pcfg["think"] = True
+                if positive_int(pcfg.get("num_ctx_max")) in {0, 131072, 1048576}:
+                    pcfg["num_ctx_max"] = 999424
+        migrations[marker] = True
+
+    marker = "ollama_cloud_provider_context_default_20260724"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("ollama-cloud", {})
+        if isinstance(pcfg, dict):
+            model = strip_claude_context_suffix(
+                str(pcfg.get("current_model") or "")
+            ).lower()
+            if model in {"glm-5.2", "glm-5.2:cloud"}:
+                detected_limit = 1_000_000
+                legacy_auto_512k = (
+                    str(pcfg.get("llm_preset") or "") == "long-context-512k"
+                    and str(pcfg.get("num_ctx") or "auto").strip().lower()
+                    in {"", "auto", "dynamic"}
+                    and positive_int(pcfg.get("num_ctx_max")) == 524288
+                )
+                if legacy_auto_512k:
+                    pcfg.pop("llm_preset", None)
+                    pcfg["num_ctx_max"] = detected_limit
+                elif not pcfg.get("llm_preset") and positive_int(
+                    pcfg.get("num_ctx_max")
+                ) in {131072, 999424, 1048576}:
+                    pcfg["num_ctx_max"] = detected_limit
+                pcfg["model_context_max"] = detected_limit
+                pcfg["model_context_model"] = "glm-5.2"
+                pcfg["think"] = True
+        migrations[marker] = True
+
+    marker = "nvidia_hosted_router_default_20260509"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("nvidia-hosted", {})
+        if isinstance(pcfg, dict) and bool(pcfg.get("native_compat", False)):
+            pcfg["native_compat"] = False
+        migrations[marker] = True
+
+    marker = "lm_studio_native_default_20260523"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("lm-studio", {})
+        if isinstance(pcfg, dict):
+            pcfg["native_compat"] = True
+        migrations[marker] = True
+
+    marker = "default_timeout_5m_20260513"
+    if not migrations.get(marker):
+        # Historical marker kept for configs that have already recorded it.
+        # Do not rewrite 10/30 minute values here anymore: those can now be
+        # deliberate long-running timeout profiles.
+        migrations[marker] = True
+
+    marker = "default_timeout_2m_20260514"
+    if not migrations.get(marker):
+        # Historical marker only. The 2-minute default was too short for
+        # 50k+ token hosted requests, so newer migrations no longer apply it.
+        migrations[marker] = True
+
+    marker = "default_timeout_restore_5m_20260515"
+    if not migrations.get(marker):
+        for pcfg in (cfg.get("providers") or {}).values():
+            if not isinstance(pcfg, dict):
+                continue
+            if positive_int(pcfg.get("request_timeout_ms")) == 120000 and not pcfg.get("llm_preset"):
+                pcfg["request_timeout_ms"] = DEFAULT_REQUEST_TIMEOUT_MS
+                if "stream_idle_timeout_ms" not in pcfg:
+                    pcfg["stream_idle_timeout_ms"] = DEFAULT_REQUEST_TIMEOUT_MS
+        migrations[marker] = True
+
+    marker = "nvidia_context_window_32k_20260513"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("nvidia-hosted", {})
+        if isinstance(pcfg, dict) and not positive_int(pcfg.get("context_window")):
+            pcfg["context_window"] = nvidia_hosted_context_default(str(pcfg.get("current_model") or ""))
+        migrations[marker] = True
+
+    marker = "nvidia_context_window_unforce_32k_20260513"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("nvidia-hosted", {})
+        if isinstance(pcfg, dict) and positive_int(pcfg.get("context_window")) == 32768:
+            pcfg["context_window"] = nvidia_hosted_context_default(str(pcfg.get("current_model") or ""))
+        migrations[marker] = True
+
+    marker = "stream_enabled_default_true_20260513"
+    if not migrations.get(marker):
+        for pcfg in (cfg.get("providers") or {}).values():
+            if isinstance(pcfg, dict) and "stream_enabled" not in pcfg:
+                pcfg["stream_enabled"] = True
+        migrations[marker] = True
+
+    marker = "default_channel_delivery_native_20260520"
+    if not migrations.get(marker):
+        ccfg = cfg.setdefault("claude_code", {})
+        if not isinstance(ccfg, dict):
+            ccfg = {}
+            cfg["claude_code"] = ccfg
+        if normalize_channel_delivery(ccfg.get("channel_delivery")) == "stdin":
+            ccfg["channel_delivery"] = "native"
+        migrations[marker] = True
+
+    marker = "default_channel_delivery_llm_20260523"
+    if not migrations.get(marker):
+        ccfg = cfg.setdefault("claude_code", {})
+        if not isinstance(ccfg, dict):
+            ccfg = {}
+            cfg["claude_code"] = ccfg
+        if normalize_channel_delivery(ccfg.get("channel_delivery")) == "native":
+            ccfg["channel_delivery"] = "llm"
+        migrations[marker] = True
+
+    marker = "rate_limit_defaults_off_20260526"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        for provider_name in ("ollama", "ollama-cloud", "nvidia-hosted", "self-hosted-nim"):
+            pcfg = providers.get(provider_name)
+            if not isinstance(pcfg, dict):
+                continue
+            old_default_rpm = str(pcfg.get("rate_limit_rpm", "")).strip() == "40"
+            old_default_status = bool(pcfg.get("rate_limit_status", True))
+            if old_default_rpm and old_default_status:
+                pcfg["rate_limit_rpm"] = 0
+                pcfg["rate_limit_status"] = False
+        pcfg = providers.get("lm-studio")
+        if (
+            isinstance(pcfg, dict)
+            and str(pcfg.get("rate_limit_rpm", "")).strip() == "0"
+            and bool(pcfg.get("rate_limit_status", True))
+        ):
+            pcfg["rate_limit_status"] = False
+        migrations[marker] = True
+
+    marker = "opencode_go_qwen36_plus_context_1m_20260530"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("opencode-go")
+        if (
+            isinstance(pcfg, dict)
+            and is_qwen36_plus_model_id(str(pcfg.get("current_model") or ""))
+            and positive_int(pcfg.get("context_window")) == 262144
+        ):
+            pcfg["context_window"] = 1048576
+        migrations[marker] = True
+
+    marker = "opencode_zen_qwen36_plus_free_model_20260614"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("opencode")
+        if isinstance(pcfg, dict):
+            custom = pcfg.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                pcfg["custom_models"] = custom
+            normalized_custom = {normalize_model_id("opencode", str(mid)) for mid in custom if str(mid).strip()}
+            if "qwen3.6-plus-free" not in normalized_custom:
+                custom.append("qwen3.6-plus-free")
+        migrations[marker] = True
+
+    marker = "opencode_qwen36_plus_parameters_20260614"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        for provider_name in OPENCODE_PROVIDER_NAMES:
+            pcfg = providers.get(provider_name)
+            if not isinstance(pcfg, dict):
+                continue
+            if not is_qwen36_plus_model_id(str(pcfg.get("current_model") or "")):
+                continue
+            if (positive_int(pcfg.get("context_window")) or 0) < 1048576:
+                pcfg["context_window"] = 1048576
+            if (positive_int(pcfg.get("context_reserve_tokens")) or 0) < 16384:
+                pcfg["context_reserve_tokens"] = 16384
+            if (positive_int(pcfg.get("max_output_tokens")) or 0) < 8192:
+                pcfg["max_output_tokens"] = 8192
+        migrations[marker] = True
+
+    marker = "anthropic_drop_preset_output_tokens_20260610"
+    if not migrations.get(marker):
+        # Older anthropic presets force-wrote max_output_tokens (2048/4096/6144/8192),
+        # which pinned CLAUDE_CODE_MAX_OUTPUT_TOKENS and overrode Claude Code's native
+        # per-model default in routed mode. Those values are no longer written. Drop a
+        # stale preset-origin value so existing routed configs recover the native cap.
+        # Trade-off (matches the rate_limit precedent): a user who deliberately set one
+        # of these exact round numbers via the CLI is cleared once; re-setting persists.
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("anthropic")
+        if isinstance(pcfg, dict) and positive_int(pcfg.get("max_output_tokens")) in (2048, 4096, 6144, 8192):
+            pcfg.pop("max_output_tokens", None)
+        migrations[marker] = True
+
+    marker = "opencode_default_ipv6_preferred_20260611"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        for provider_name in OPENCODE_PROVIDER_NAMES:
+            pcfg = providers.get(provider_name)
+            if isinstance(pcfg, dict) and not pcfg.get("ip_family"):
+                pcfg["ip_family"] = "ipv6-preferred"
+        migrations[marker] = True
+
+    marker = "kimi_tool_choice_auto_only_20260625"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("kimi")
+        if isinstance(pcfg, dict):
+            pcfg["normalize_anthropic_tool_use"] = True
+            pcfg["supports_tool_choice"] = False
+        migrations[marker] = True
+
+    marker = "kimi_forward_tool_choice_20260628"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("kimi")
+        if isinstance(pcfg, dict):
+            pcfg["normalize_anthropic_tool_use"] = True
+            pcfg["supports_tool_choice"] = True
+        migrations[marker] = True
+
+    marker = "kimi_k3_model_20260716"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("kimi")
+        if isinstance(pcfg, dict):
+            custom = pcfg.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                pcfg["custom_models"] = custom
+            normalized_custom = {normalize_model_id("kimi", str(mid)) for mid in custom if str(mid).strip()}
+            if KIMI_K3_MODEL not in normalized_custom:
+                custom.append(KIMI_K3_MODEL)
+        migrations[marker] = True
+
+    marker = "kimi_k3_official_profile_20260722"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("kimi")
+        if isinstance(pcfg, dict):
+            custom = pcfg.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                pcfg["custom_models"] = custom
+            normalized_custom = {normalize_model_id("kimi", str(mid)) for mid in custom if str(mid).strip()}
+            for model_id in (f"{KIMI_K3_MODEL}[1m]", "kimi-for-coding-highspeed"):
+                if normalize_model_id("kimi", model_id) not in normalized_custom:
+                    custom.append(model_id)
+            current = normalize_model_id("kimi", str(pcfg.get("current_model") or ""))
+            if current in {KIMI_K3_MODEL, f"{KIMI_K3_MODEL}[1m]"}:
+                pcfg["context_window"] = 1048576
+                pcfg["max_model_len"] = 1048576
+                pcfg["effort_level"] = "high"
+                pcfg["model_profile"] = "kimi-k3-1m"
+        migrations[marker] = True
+
+    marker = "kimi_k3_default_1m_20260723"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("kimi")
+        if isinstance(pcfg, dict):
+            current = normalize_model_id("kimi", str(pcfg.get("current_model") or ""))
+            if current in {KIMI_K3_MODEL, f"{KIMI_K3_MODEL}[1m]"}:
+                pcfg["context_window"] = 1048576
+                pcfg["max_model_len"] = 1048576
+                pcfg["effort_level"] = "high"
+                pcfg["model_profile"] = "kimi-k3-1m"
+        migrations[marker] = True
+
+__all__ = ["ConfigMigrationPolicy", "apply_config_migrations"]

package/ciel_runtime_support/config_repository.py

@@ -0,0 +1,175 @@
+"""Configuration persistence port with atomic JSON file storage."""
+
+from __future__ import annotations
+
+import copy
+import json
+import os
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+
+def build_default_config(provider_defaults: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "current_provider": "nvidia-hosted",
+        "last_launch_action": "",
+        "language": "en",
+        "migrations": {},
+        "router_debug_external_access": False,
+        "router_debug_external_access_confirmed": False,
+        "router_debug_message_preview_chars": 0,
+        "web_backend": {
+            "enabled": False,
+            "host": "127.0.0.1",
+            "port": 0,
+            "tailscale_https": False,
+        },
+        "claude_code": {
+            "compat_prompt_for_non_anthropic": True,
+            "channels": [],
+            "development_channels": False,
+            "channel_delivery": "llm",
+        },
+        "cleanup": {"managed_services_on_launch": True},
+        "web_search": {
+            "auto_for_non_native": True,
+            "provider": "duckduckgo",
+            "package": "ddg-mcp-search",
+            "fetch_enabled": True,
+            "fetch_package": "mcp-server-fetch",
+            "fetch_ignore_robots_txt": False,
+            "fetch_user_agent": "",
+        },
+        "providers": provider_defaults,
+    }
+
+
+def deep_merge(defaults: dict[str, Any], overrides: dict[str, Any]) -> dict[str, Any]:
+    merged = json.loads(json.dumps(defaults))
+    for key, value in overrides.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = deep_merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def normalize_loaded_config(
+    config: dict[str, Any],
+    normalize_model_id: Callable[[str, str], str],
+) -> None:
+    providers = config["providers"]
+    cloud = providers.get("ollama-cloud", {})
+    local_key = providers.get("ollama", {}).get("api_key", "")
+    if not cloud.get("api_key") and local_key and local_key not in {"ollama", "dummy", "not-used"}:
+        cloud["api_key"] = local_key
+    for provider_name, provider_config in providers.items():
+        if not isinstance(provider_config, dict):
+            continue
+        if provider_config.get("current_model"):
+            provider_config["current_model"] = normalize_model_id(
+                provider_name, str(provider_config["current_model"])
+            )
+        custom_models = provider_config.get("custom_models")
+        if isinstance(custom_models, list):
+            provider_config["custom_models"] = [
+                normalize_model_id(provider_name, str(model_id))
+                for model_id in custom_models
+                if str(model_id).strip()
+            ]
+
+
+class JsonConfigRepository:
+    """Own configuration caching, persistence, migration, and normalization."""
+
+    def __init__(
+        self,
+        *,
+        path: Path,
+        defaults: dict[str, Any],
+        merge: Callable[[dict[str, Any], dict[str, Any]], dict[str, Any]],
+        migrate: Callable[[dict[str, Any]], None],
+        normalize: Callable[[dict[str, Any]], None],
+    ) -> None:
+        self._path = path
+        self._defaults = defaults
+        self._merge = merge
+        self._migrate = migrate
+        self._normalize = normalize
+        self._cache: dict[str, Any] | None = None
+        self._cache_mtime = 0.0
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def load(self) -> dict[str, Any]:
+        try:
+            mtime = self._path.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+        if self._cache is not None and mtime == self._cache_mtime:
+            return copy.deepcopy(self._cache)
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8")) if self._path.exists() else {}
+        except (OSError, ValueError, TypeError):
+            data = {}
+        config = self._merge(self._defaults, data if isinstance(data, dict) else {})
+        self._migrate(config)
+        self._normalize(config)
+        self._cache = config
+        self._cache_mtime = mtime
+        return copy.deepcopy(config)
+
+    def save(self, config: dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = self._path.with_name(f"{self._path.name}.{os.getpid()}.{time.time_ns()}.tmp")
+        temporary.write_text(json.dumps(config, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        os.chmod(temporary, 0o600)
+        temporary.replace(self._path)
+        self._cache = copy.deepcopy(config)
+        try:
+            self._cache_mtime = self._path.stat().st_mtime
+        except OSError:
+            self._cache_mtime = 0.0
+
+    def invalidate(self) -> None:
+        self._cache = None
+        self._cache_mtime = 0.0
+
+
+class ConfigRepositoryProvider:
+    """Path-aware repository factory that owns the mutable cache instance."""
+
+    def __init__(self) -> None:
+        self._repository: JsonConfigRepository | None = None
+
+    def get(
+        self,
+        *,
+        path: Path,
+        defaults: dict[str, Any],
+        merge: Callable[[dict[str, Any], dict[str, Any]], dict[str, Any]],
+        migrate: Callable[[dict[str, Any]], None],
+        normalize: Callable[[dict[str, Any]], None],
+    ) -> JsonConfigRepository:
+        if self._repository is None or self._repository.path != path:
+            self._repository = JsonConfigRepository(
+                path=path,
+                defaults=defaults,
+                merge=merge,
+                migrate=migrate,
+                normalize=normalize,
+            )
+        return self._repository
+
+
+__all__ = [
+    "ConfigRepositoryProvider",
+    "JsonConfigRepository",
+    "build_default_config",
+    "deep_merge",
+    "normalize_loaded_config",
+]

package/ciel_runtime_support/config_value_codec.py

@@ -0,0 +1,64 @@
+"""Scalar parsing and validation for environment, CLI, and persisted config."""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+
+def positive_int(value: Any) -> int | None:
+    try:
+        parsed = int(value)
+    except Exception:
+        return None
+    return parsed if parsed > 0 else None
+
+
+def finite_float(value: Any) -> float | None:
+    try:
+        parsed = float(value)
+    except Exception:
+        return None
+    return parsed if math.isfinite(parsed) else None
+
+
+def parse_config_value(value: str) -> Any:
+    text = value.strip()
+    normalized = text.lower()
+    if normalized in {"true", "yes", "on"}:
+        return True
+    if normalized in {"false", "no", "off"}:
+        return False
+    if normalized in {"none", "null"}:
+        return None
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    try:
+        return int(text)
+    except Exception:
+        pass
+    try:
+        return float(text)
+    except Exception:
+        return text
+
+
+def parse_bool(value: Any, default: bool = False) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    if isinstance(value, (int, float)):
+        return bool(value)
+    normalized = str(value).strip().lower()
+    if normalized in {"true", "yes", "on", "1", "enable", "enabled"}:
+        return True
+    if normalized in {"false", "no", "off", "0", "disable", "disabled"}:
+        return False
+    return default
+
+
+__all__ = ["finite_float", "parse_bool", "parse_config_value", "positive_int"]