@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/model_context_hints.py

@@ -0,0 +1,109 @@
+"""Pure model-identity heuristics for context-capacity hints."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class ModelContextHintPorts:
+    strip_context_suffix: Callable[[str], str]
+    catalog_context: Callable[[str], tuple[int | None, str | None, str | None]]
+    model_preset: Callable[[str], Mapping[str, Any]]
+    positive_int: Callable[[Any], int | None]
+
+
+class ModelContextHintPolicy:
+    def __init__(
+        self,
+        zai_hints: Sequence[tuple[str, int]],
+        ports: ModelContextHintPorts,
+    ) -> None:
+        self.zai_hints = tuple(zai_hints)
+        self.ports = ports
+
+    @staticmethod
+    def is_qwen36_plus(model_id: str) -> bool:
+        compact = re.sub(r"[^a-z0-9]+", "", (model_id or "").lower())
+        return "qwen36plus" in compact
+
+    def is_kimi_k3(self, model_id: str) -> bool:
+        normalized = (
+            self.ports.strip_context_suffix(model_id)
+            .strip()
+            .lower()
+            .replace("_", "-")
+        )
+        if normalized.startswith("ciel-runtime-kimi-"):
+            normalized = normalized[len("ciel-runtime-kimi-") :]
+        return normalized in {"k3", "kimi-k3", "kimi/k3", "kimi-code/k3"}
+
+    def zai_hint(self, model_id: str) -> int | None:
+        model = (
+            self.ports.strip_context_suffix(model_id)
+            .strip()
+            .lower()
+            .replace("_", "-")
+        )
+        if not model:
+            return None
+        for prefix, limit in self.zai_hints:
+            if model == prefix or model.startswith(prefix + "-"):
+                return limit
+        return None
+
+    def resolve(self, model_id: str) -> int | None:
+        model = (model_id or "").lower()
+        if not model:
+            return None
+        zai_hint = self.zai_hint(model_id)
+        if zai_hint:
+            return zai_hint
+        if self.is_qwen36_plus(model_id):
+            return 1048576
+        if self.is_kimi_k3(model_id):
+            return 1048576
+        catalog_limit, _family, _source = self.ports.catalog_context(model_id)
+        if catalog_limit:
+            return catalog_limit
+        if any(
+            marker in model
+            for marker in (
+                "deepseek-v4-pro",
+                "deepseek-v4-flash",
+                "deepseek-v4",
+                "v4-pro",
+                "v4-flash",
+                "1m",
+                "million",
+            )
+        ):
+            return 1048576
+        if any(
+            marker in model
+            for marker in (
+                "kimi-for-coding",
+                "kimi-code",
+                "kimi-k2.7",
+                "kimi_k2.7",
+                "kimi2.7",
+                "k2.7",
+                "kimi-k2.6",
+                "kimi_k2.6",
+                "kimi2.6",
+                "kimi-k2",
+            )
+        ):
+            return 262144
+        if "qwen3.6" in model:
+            return 262144
+        if "glm-4.7" in model or "glm-5.1" in model:
+            return 200000
+        if "deepseek-r1" in model or "llama3.3" in model:
+            return 131072
+        return self.ports.positive_int(
+            self.ports.model_preset(model_id).get("num_ctx_max")
+        )

package/ciel_runtime_support/model_panel.py

@@ -0,0 +1,147 @@
+"""Provider-registry-backed model panel projections."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ModelPanelCatalog:
+    alias_for: Callable[..., Any]
+    cached_or_configured_model_ids: Callable[..., Any]
+    read_model_info_cache: Callable[..., Any]
+    read_model_list_cache: Callable[..., Any]
+    unique_model_ids: Callable[..., Any]
+    upstream_model_ids: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelPanelPresentation:
+    advisor_model_badge: Callable[..., Any]
+    advisor_panel_notice: Callable[..., Any]
+    format_context_tokens: Callable[..., Any]
+    format_parameter_count: Callable[..., Any]
+    model_panel_badge: Callable[..., Any]
+    normalize_model_id: Callable[..., Any]
+    positive_int: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelPanelServices:
+    catalog: ModelPanelCatalog
+    presentation: ModelPanelPresentation
+
+
+def model_panel_rows(
+    provider: str,
+    pcfg: dict[str, Any],
+    fetch: bool = True,
+    force_refresh: bool = False,
+    *,
+    services: ModelPanelServices,
+) -> tuple[list[str], list[str]]:
+    catalog = services.catalog
+    presentation = services.presentation
+    alias_for = catalog.alias_for
+    cached_or_configured_model_ids = catalog.cached_or_configured_model_ids
+    format_context_tokens = presentation.format_context_tokens
+    format_parameter_count = presentation.format_parameter_count
+    model_panel_badge = presentation.model_panel_badge
+    normalize_model_id = presentation.normalize_model_id
+    positive_int = presentation.positive_int
+    read_model_info_cache = catalog.read_model_info_cache
+    read_model_list_cache = catalog.read_model_list_cache
+    unique_model_ids = catalog.unique_model_ids
+    upstream_model_ids = catalog.upstream_model_ids
+    values = unique_model_ids(
+        provider,
+        upstream_model_ids(provider, pcfg, force_refresh=force_refresh)
+        if fetch else cached_or_configured_model_ids(provider, pcfg),
+    )
+    rows: list[str] = []
+    current = pcfg.get("current_model")
+    seen_aliases: set[str] = set()
+    deduped_values: list[str] = []
+    cache = read_model_list_cache(provider, pcfg)
+    cached_info = read_model_info_cache(provider, pcfg)
+    rows.append("Refresh provider model list..." if cache is None else "Refresh provider model list")
+    deduped_values.append("__refresh_models__")
+    for mid in values:
+        alias = alias_for(provider, mid)
+        suffix = ""
+        info = cached_info.get(normalize_model_id(provider, mid), {})
+        max_context = positive_int(info.get("max_model_len"))
+        if max_context:
+            suffix += f"  [ctx {format_context_tokens(max_context)}]"
+        parameter_count = format_parameter_count(info.get("parameter_count"))
+        if parameter_count:
+            suffix += f"  [{parameter_count} params]"
+        badge = model_panel_badge(provider, pcfg, mid)
+        if badge:
+            suffix += f"  [{badge}]"
+        alias_key = alias.casefold()
+        if alias_key in seen_aliases:
+            continue
+        seen_aliases.add(alias_key)
+        deduped_values.append(mid)
+        mark = "*" if mid == current else " "
+        rows.append(f"{mark} {mid}  {alias}{suffix}")
+    rows.append("+ Custom model id...")
+    deduped_values.append("__custom__")
+    rows.append("Back")
+    deduped_values.append("back")
+    return rows, deduped_values
+
+
+def advisor_model_panel_rows(
+    provider: str,
+    pcfg: dict[str, Any],
+    fetch: bool = True,
+    force_refresh: bool = False,
+    *,
+    services: ModelPanelServices,
+) -> tuple[list[str], list[str]]:
+    catalog = services.catalog
+    presentation = services.presentation
+    advisor_model_badge = presentation.advisor_model_badge
+    advisor_panel_notice = presentation.advisor_panel_notice
+    cached_or_configured_model_ids = catalog.cached_or_configured_model_ids
+    normalize_model_id = presentation.normalize_model_id
+    read_model_list_cache = catalog.read_model_list_cache
+    unique_model_ids = catalog.unique_model_ids
+    upstream_model_ids = catalog.upstream_model_ids
+    notice = advisor_panel_notice(provider, pcfg)
+    if notice:
+        return list(notice[0]), list(notice[1])
+    current = normalize_model_id(provider, pcfg.get("advisor_model", ""))
+    values = unique_model_ids(
+        provider,
+        (
+            upstream_model_ids(provider, pcfg, force_refresh=force_refresh)
+            if fetch else cached_or_configured_model_ids(provider, pcfg)
+        )
+        + ([current] if current else []),
+    )
+    rows: list[str] = []
+    rows.append(("* Disable Advisor Model" if not current else "  Disable Advisor Model"))
+    deduped_values = [""]
+    cache = read_model_list_cache(provider, pcfg)
+    rows.append("Refresh provider model list..." if cache is None else "Refresh provider model list")
+    deduped_values.append("__refresh_models__")
+    seen: set[str] = set()
+    for mid in values:
+        if not mid or mid in seen:
+            continue
+        seen.add(mid)
+        mark = "*" if mid == current else " "
+        badge = advisor_model_badge(provider, pcfg, mid)
+        suffix = f"  {badge}" if badge else ""
+        rows.append(f"{mark} {mid}{suffix}")
+        deduped_values.append(mid)
+    rows.append("+ Custom advisor model id...")
+    deduped_values.append("__custom__")
+    rows.append("Back")
+    deduped_values.append("back")
+    return rows, deduped_values
+

package/ciel_runtime_support/model_registry_repository.py

@@ -0,0 +1,231 @@
+"""Persistent provider model registry and short-lived model-list cache."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .runtime_constants import MODEL_CACHE_TTL_SECONDS
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRegistryPaths:
+    config_dir: Path
+    registry: Path
+    list_cache: Path
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRegistryPolicy:
+    cache_key: Callable[[str, dict[str, Any]], str]
+    unique_ids: Callable[[str, list[str]], list[str]]
+    normalize_id: Callable[[str, str], str]
+    positive_int: Callable[[Any], int | None]
+    recommendations: Callable[[str, list[str]], dict[str, Any]]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRegistryRepository:
+    paths: ModelRegistryPaths
+    policy: ModelRegistryPolicy
+    ttl_seconds: float
+
+    def read_registry(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        max_age_seconds: float | None = None,
+    ) -> dict[str, Any] | None:
+        try:
+            data = json.loads(self.paths.registry.read_text(encoding="utf-8"))
+        except Exception:
+            return None
+        providers = data.get("providers") if isinstance(data, dict) else None
+        entry = providers.get(provider) if isinstance(providers, dict) else None
+        if not isinstance(entry, dict) or not self._key_matches(provider, config, entry):
+            return None
+        max_age = self.ttl_seconds if max_age_seconds is None else max_age_seconds
+        try:
+            if max_age > 0 and time.time() - float(entry.get("time", 0)) > max_age:
+                return None
+        except Exception:
+            return None
+        return entry if isinstance(entry.get("models"), list) else None
+
+    def _key_matches(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        entry: dict[str, Any],
+    ) -> bool:
+        current = self.policy.cache_key(provider, config)
+        if entry.get("key") == current:
+            return True
+        if provider != "anthropic" or entry.get("source") != "anthropic-docs":
+            return False
+        try:
+            saved_key = json.loads(str(entry.get("key") or "{}"))
+            current_key = json.loads(current)
+            saved_key.pop("api", None)
+            current_key.pop("api", None)
+            return saved_key == current_key
+        except Exception:
+            return False
+
+    def read_registry_models(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        max_age_seconds: float | None = None,
+    ) -> list[str] | None:
+        entry = self.read_registry(provider, config, max_age_seconds)
+        models = entry.get("models") if entry else None
+        if not isinstance(models, list):
+            return None
+        return self.policy.unique_ids(provider, [str(item) for item in models if str(item).strip()])
+
+    def read_registry_info(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        max_age_seconds: float | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        entry = self.read_registry(provider, config, max_age_seconds)
+        metadata = entry.get("metadata") if entry else None
+        return self._normalize_info(provider, metadata)
+
+    def write_registry(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        models: list[str],
+        source: str = "provider",
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        self.paths.config_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            data = json.loads(self.paths.registry.read_text(encoding="utf-8")) if self.paths.registry.exists() else {}
+        except Exception:
+            data = {}
+        if not isinstance(data, dict):
+            data = {}
+        providers = data.get("providers")
+        if not isinstance(providers, dict):
+            providers = {}
+        providers[provider] = {
+            "time": time.time(),
+            "key": self.policy.cache_key(provider, config),
+            "source": source,
+            "models": self.policy.unique_ids(provider, models),
+            "recommendations": self.policy.recommendations(provider, models),
+            "metadata": metadata or {},
+        }
+        data.update(schema=1, providers=providers)
+        try:
+            self.paths.registry.write_text(
+                json.dumps(data, indent=2, sort_keys=True) + "\n",
+                encoding="utf-8",
+            )
+            os.chmod(self.paths.registry, 0o600)
+        except Exception as error:
+            self.policy.log(
+                "WARN",
+                f"model_registry_write_failed provider={provider} error={type(error).__name__}: {error}",
+            )
+
+    def read_list_cache(self, provider: str, config: dict[str, Any]) -> list[str] | None:
+        try:
+            data = json.loads(self.paths.list_cache.read_text())
+        except Exception:
+            return self.read_registry_models(provider, config, 0)
+        if not isinstance(data, dict) or data.get("key") != self.policy.cache_key(provider, config):
+            return self.read_registry_models(provider, config, 0)
+        if time.time() - float(data.get("time", 0)) > self.ttl_seconds:
+            if registry_models := self.read_registry_models(provider, config, 0):
+                return registry_models
+        models = data.get("models")
+        if not isinstance(models, list):
+            return None
+        return self.policy.unique_ids(provider, [str(item) for item in models if str(item).strip()])
+
+    def read_info_cache(self, provider: str, config: dict[str, Any]) -> dict[str, dict[str, Any]]:
+        try:
+            data = json.loads(self.paths.list_cache.read_text())
+        except Exception:
+            return self.read_registry_info(provider, config, 0)
+        if not isinstance(data, dict) or data.get("key") != self.policy.cache_key(provider, config):
+            return self.read_registry_info(provider, config, 0)
+        info = self._normalize_info(provider, data.get("metadata"))
+        return info or self.read_registry_info(provider, config, 0)
+
+    def _normalize_info(self, provider: str, metadata: Any) -> dict[str, dict[str, Any]]:
+        raw_info = metadata.get("model_info") if isinstance(metadata, dict) else None
+        if not isinstance(raw_info, dict):
+            return {}
+        result: dict[str, dict[str, Any]] = {}
+        for raw_id, raw_value in raw_info.items():
+            model_id = self.policy.normalize_id(provider, str(raw_id))
+            if not model_id or not isinstance(raw_value, dict):
+                continue
+            info = dict(raw_value)
+            if context := self.policy.positive_int(info.get("max_model_len")):
+                info["max_model_len"] = context
+            result[model_id] = info
+        return result
+
+    def write_list_cache(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        models: list[str],
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        self.paths.config_dir.mkdir(parents=True, exist_ok=True)
+        data = {
+            "time": time.time(),
+            "key": self.policy.cache_key(provider, config),
+            "models": models,
+            "metadata": metadata or {},
+        }
+        try:
+            self.paths.list_cache.write_text(json.dumps(data, indent=2) + "\n")
+            os.chmod(self.paths.list_cache, 0o600)
+        except Exception as error:
+            self.policy.log(
+                "WARN",
+                f"model_list_cache_write_failed provider={provider} error={type(error).__name__}: {error}",
+            )
+        self.write_registry(provider, config, models, "provider", metadata)
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRegistryApi:
+    """Explicit public adapter for late-bound model registry repositories."""
+
+    repository_factory: Callable[[], ModelRegistryRepository]
+
+    def read_registry(self, provider: str, pcfg: dict[str, Any], max_age_seconds: float = MODEL_CACHE_TTL_SECONDS) -> dict[str, Any] | None:
+        return self.repository_factory().read_registry(provider, pcfg, max_age_seconds)
+
+    def read_registry_models(self, provider: str, pcfg: dict[str, Any], max_age_seconds: float = MODEL_CACHE_TTL_SECONDS) -> list[str] | None:
+        return self.repository_factory().read_registry_models(provider, pcfg, max_age_seconds)
+
+    def read_registry_info(self, provider: str, pcfg: dict[str, Any], max_age_seconds: float = MODEL_CACHE_TTL_SECONDS) -> dict[str, dict[str, Any]]:
+        return self.repository_factory().read_registry_info(provider, pcfg, max_age_seconds)
+
+    def write_registry(self, provider: str, pcfg: dict[str, Any], models: list[str], source: str = "provider", metadata: dict[str, Any] | None = None) -> None:
+        self.repository_factory().write_registry(provider, pcfg, models, source, metadata)
+
+    def read_list_cache(self, provider: str, pcfg: dict[str, Any]) -> list[str] | None:
+        return self.repository_factory().read_list_cache(provider, pcfg)
+
+    def read_info_cache(self, provider: str, pcfg: dict[str, Any]) -> dict[str, dict[str, Any]]:
+        return self.repository_factory().read_info_cache(provider, pcfg)
+
+    def write_list_cache(self, provider: str, pcfg: dict[str, Any], models: list[str], metadata: dict[str, Any] | None = None) -> None:
+        self.repository_factory().write_list_cache(provider, pcfg, models, metadata)

package/ciel_runtime_support/npm_runtime.py

@@ -0,0 +1,191 @@
+"""npm process, version, and installed-package path utilities."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from collections.abc import Mapping
+from pathlib import Path
+
+
+def parse_version_tuple(value: str) -> tuple[int, ...]:
+    return tuple(int(item) for item in re.split(r"[^0-9]+", value.strip()) if item)
+
+
+def version_newer(latest: str, current: str) -> bool:
+    left = list(parse_version_tuple(latest))
+    right = list(parse_version_tuple(current))
+    size = max(len(left), len(right), 1)
+    left.extend([0] * (size - len(left)))
+    right.extend([0] * (size - len(right)))
+    return tuple(left) > tuple(right)
+
+
+def npm_latest_package_version(
+    npm: str, package_spec: str, timeout: float = 8.0
+) -> str:
+    try:
+        process = subprocess.run(
+            [npm, "view", package_spec, "version"],
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+        )
+    except Exception:
+        return ""
+    if process.returncode != 0:
+        return ""
+    output = (process.stdout or "").strip()
+    return output.splitlines()[-1].strip() if output else ""
+
+
+def npm_global_package_root(
+    npm: str,
+    package_name: str = "@oneciel-ai/ciel-runtime",
+    timeout: float = 8.0,
+) -> Path | None:
+    try:
+        process = subprocess.run(
+            [npm, "root", "-g"],
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+        )
+    except Exception:
+        return None
+    if process.returncode != 0:
+        return None
+    root = (process.stdout or "").strip()
+    if not root:
+        return None
+    package_path = Path(root)
+    for part in package_name.split("/"):
+        if part:
+            package_path /= part
+    return package_path
+
+
+def npm_prefix_from_package_root(package_root: Path) -> Path | None:
+    """Infer the npm install prefix from a global installed package root."""
+
+    parts = package_root.parts
+    for index, part in enumerate(parts):
+        if part != "node_modules":
+            continue
+        try:
+            node_modules = Path(*parts[: index + 1])
+        except Exception:
+            return None
+        parent = node_modules.parent
+        return parent.parent if parent.name == "lib" else parent
+    return None
+
+
+def npm_global_install_command(
+    npm: str, package_spec: str, prefix: Path | None = None
+) -> list[str]:
+    command = [npm, "install", "-g"]
+    if prefix is not None:
+        command.extend(["--prefix", str(prefix)])
+    command.append(package_spec)
+    return command
+
+
+def npm_install_runtime_command(
+    npm: str, package_spec: str, prefix: Path | None = None
+) -> list[str]:
+    command = npm_global_install_command(npm, package_spec, prefix)
+    command.insert(3, "--prefer-online")
+    return command
+
+
+def npm_global_bin_dir_from_prefix(prefix: Path) -> Path:
+    return prefix if os.name == "nt" else prefix / "bin"
+
+
+def executable_version(executable: str, timeout: float = 8.0) -> str:
+    try:
+        process = subprocess.run(
+            [executable, "--version"],
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            timeout=timeout,
+        )
+    except Exception:
+        return ""
+    if process.returncode != 0:
+        return ""
+    match = re.search(r"\d+(?:\.\d+)+", process.stdout or "")
+    return match.group(0) if match else ""
+
+
+def run_upgrade_command(
+    command: list[str],
+    environ: Mapping[str, str],
+    timeout: float = 300.0,
+) -> tuple[int, str]:
+    try:
+        process = subprocess.run(
+            command,
+            text=True,
+            input="y\n",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            env=dict(environ),
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return 124, "timed out"
+    except Exception as exc:
+        return 1, f"{type(exc).__name__}: {exc}"
+    return process.returncode, (process.stdout or "").strip()
+
+
+def claude_code_current_version(claude: str) -> str:
+    return executable_version(claude)
+
+
+def codex_current_version(codex: str) -> str:
+    return executable_version(codex)
+
+
+def package_root_from_installed_path(path: Path) -> Path | None:
+    """Return the npm package root when a path lives inside this package."""
+
+    try:
+        resolved = path.resolve(strict=False)
+    except Exception:
+        resolved = path
+    parts = resolved.parts
+    for index in range(0, max(0, len(parts) - 2)):
+        if (
+            parts[index] == "node_modules"
+            and parts[index + 1] == "@oneciel-ai"
+            and parts[index + 2] == "ciel-runtime"
+        ):
+            try:
+                return Path(*parts[: index + 3])
+            except Exception:
+                return None
+    return None
+
+
+__all__ = [
+    "claude_code_current_version",
+    "codex_current_version",
+    "executable_version",
+    "npm_global_bin_dir_from_prefix",
+    "npm_global_install_command",
+    "npm_global_package_root",
+    "npm_install_runtime_command",
+    "npm_latest_package_version",
+    "npm_prefix_from_package_root",
+    "package_root_from_installed_path",
+    "parse_version_tuple",
+    "run_upgrade_command",
+    "version_newer",
+]