@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/provider_model_selection.py

@@ -0,0 +1,431 @@
+"""Provider model selection, alias resolution, and request projection."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ModelIdentityPorts:
+    normalize: Callable[[str, str], str]
+    model_map: Callable[[str, dict[str, Any]], dict[str, str]]
+    unslug: Callable[[str, str, dict[str, str]], str | None]
+    api_model_id: Callable[[str, str], str]
+    strip_context_suffix: Callable[[str | None], str]
+    alias: Callable[[str, str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSelectionPorts:
+    adapter: Callable[[str, dict[str, Any]], Any]
+    contract: Callable[[str, dict[str, Any]], Any]
+    placeholders: Callable[[str], set[str]]
+    upstream_ids: Callable[..., list[str]]
+    unique_ids: Callable[[str, list[str]], list[str]]
+    apply_specs: Callable[[str, dict[str, Any]], list[str]]
+    apply_timeout: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelCatalogPorts:
+    model_object: Callable[[str, str, dict[str, Any]], dict[str, Any]]
+    headers: Callable[[str, dict[str, Any], Any | None], dict[str, str]]
+    fetch_anthropic: Callable[..., tuple[list[str], str]]
+    sorted_ids: Callable[[list[str]], list[str]]
+    routed_anthropic: Callable[[str, dict[str, Any]], bool]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelMutationConfigPorts:
+    load_config: Callable[[], dict[str, Any]]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    save_config: Callable[[dict[str, Any]], None]
+    clear_model_cache: Callable[[], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelMutationPolicyPorts:
+    model_map: Callable[..., dict[str, str]]
+    unslug: Callable[[str, str, dict[str, str]], str | None]
+    normalize: Callable[[str, str], str]
+    apply_profile: Callable[[str, dict[str, Any]], list[str]]
+    read_model_info: Callable[[str, dict[str, Any]], dict[str, Any]]
+    positive_int: Callable[[Any], int | None]
+    model_preset: Callable[[str], dict[str, Any]]
+    apply_selection_updates: Callable[[str, dict[str, Any], str], None]
+    alias: Callable[[str, str], str]
+    format_context: Callable[[int], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelMutationEffectPorts:
+    sync_context_limit: Callable[[str, dict[str, Any], str], list[str]]
+    cap_context_settings: Callable[[str, dict[str, Any]], list[str]]
+    apply_recommended_preset: Callable[[str, dict[str, Any], str], list[str]]
+    apply_recommended_timeout: Callable[..., list[str]]
+    read_model_list: Callable[[str, dict[str, Any]], list[str] | None]
+
+
+@dataclass(frozen=True, slots=True)
+class AdvisorModelMutationPorts:
+    load_config: Callable[[], dict[str, Any]]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    save_config: Callable[[dict[str, Any]], None]
+    clear_model_cache: Callable[[], None]
+    normalize: Callable[[str, str], str]
+    read_model_list: Callable[[str, dict[str, Any]], list[str] | None]
+    uses_native_advisor: Callable[[str, dict[str, Any]], bool]
+
+
+class AdvisorModelSelectionController:
+    def __init__(self, ports: AdvisorModelMutationPorts) -> None:
+        self._ports = ports
+
+    def select(self, value: str) -> list[str]:
+        config = self._ports.load_config()
+        provider, provider_config = self._ports.current_provider(config)
+        if self._ports.uses_native_advisor(provider, provider_config):
+            return [
+                f"{provider.title()} modes use Claude Code's built-in /advisor; "
+                "run /advisor in the session to pick its model."
+            ]
+        stripped = value.strip()
+        model_id = self._ports.normalize(provider, stripped) if stripped else ""
+        provider_config["advisor_model"] = model_id
+        if model_id:
+            known = self._ports.read_model_list(provider, provider_config) or []
+            custom = provider_config.setdefault("custom_models", [])
+            if model_id not in custom and model_id not in known:
+                custom.append(model_id)
+        self._ports.save_config(config)
+        self._ports.clear_model_cache()
+        if not model_id:
+            return [f"Advisor Model for {provider} disabled."]
+        return [f"Advisor Model for {provider} set to {model_id}."]
+
+
+class ModelSelectionController:
+    def __init__(
+        self,
+        config: ModelMutationConfigPorts,
+        policy: ModelMutationPolicyPorts,
+        effects: ModelMutationEffectPorts,
+    ) -> None:
+        self._config = config
+        self._policy = policy
+        self._effects = effects
+
+    def select(self, value: str) -> list[str]:
+        config = self._config.load_config()
+        provider, provider_config = self._config.current_provider(config)
+        model_map = self._policy.model_map(provider, provider_config, fetch=False)
+        model_id = self._policy.normalize(
+            provider,
+            self._policy.unslug(provider, value, model_map) or value,
+        )
+        previous_model = str(provider_config.get("current_model") or "")
+        provider_config["current_model"] = model_id
+        self._policy.apply_selection_updates(provider, provider_config, model_id)
+        selected_info = self._policy.read_model_info(provider, provider_config).get(model_id) or {}
+        selected_context = self._policy.positive_int(selected_info.get("max_model_len"))
+        if selected_context:
+            provider_config["max_model_len"] = selected_context
+        profile_messages = self._policy.apply_profile(provider, provider_config)
+        preset = self._policy.model_preset(model_id)
+        if preset.get("num_ctx_min"):
+            provider_config["num_ctx_min"] = preset["num_ctx_min"]
+        if preset.get("num_ctx_max"):
+            provider_config["num_ctx_max"] = preset["num_ctx_max"]
+        context_messages = self._effects.sync_context_limit(provider, provider_config, model_id)
+        context_messages.extend(self._effects.cap_context_settings(provider, provider_config))
+        preset_messages = self._effects.apply_recommended_preset(
+            provider,
+            provider_config,
+            config.get("language", "en"),
+        )
+        timeout_messages = self._effects.apply_recommended_timeout(
+            provider,
+            provider_config,
+            use_context_fallback=False,
+        )
+        known = self._effects.read_model_list(provider, provider_config) or []
+        custom = provider_config.setdefault("custom_models", [])
+        if model_id not in custom and model_id not in known:
+            custom.append(model_id)
+        self._config.save_config(config)
+        self._config.clear_model_cache()
+        messages = [
+            f"Model for {provider} set to {model_id}.",
+            f"Claude Code alias: {self._policy.alias(provider, model_id)}",
+            *profile_messages,
+        ]
+        if model_id != previous_model:
+            messages.append(
+                "Start a new session after changing models to avoid context-cache re-prefill overhead."
+            )
+        if selected_context:
+            messages.append(
+                f"Model context size: {self._policy.format_context(selected_context)} "
+                f"({selected_context:,} tokens)."
+            )
+        messages.extend(context_messages)
+        messages.extend(preset_messages)
+        messages.extend(timeout_messages)
+        if preset.get("thinking"):
+            messages.append("Note: this is a thinking model; compatibility test uses extended token budget.")
+        return messages
+
+
+class ProviderModelSelection:
+    def __init__(
+        self,
+        identity: ModelIdentityPorts,
+        selection: ModelSelectionPorts,
+        catalog: ModelCatalogPorts,
+    ) -> None:
+        self.identity = identity
+        self.selection = selection
+        self.catalog = catalog
+
+    def current_upstream_id(self, provider: str, config: dict[str, Any]) -> str:
+        current = self.identity.normalize(provider, config.get("current_model") or "model")
+        if current.startswith(f"ciel-runtime-{provider}-"):
+            try:
+                return (
+                    self.identity.unslug(
+                        provider, current, self.identity.model_map(provider, config)
+                    )
+                    or current
+                )
+            except Exception:
+                return current
+        return current
+
+    def needs_selection(self, provider: str, config: dict[str, Any]) -> bool:
+        adapter = self.selection.adapter(provider, config)
+        if not adapter.requires_catalog_model_selection(
+            self.selection.contract(provider, config)
+        ):
+            return False
+        current = self.identity.normalize(provider, str(config.get("current_model") or ""))
+        return current in self.selection.placeholders(provider)
+
+    def ensure_selected(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        *,
+        force_refresh: bool = False,
+    ) -> tuple[bool, list[str]]:
+        adapter = self.selection.adapter(provider, config)
+        if not adapter.requires_catalog_model_selection(
+            self.selection.contract(provider, config)
+        ):
+            return True, []
+        current = self.identity.normalize(provider, str(config.get("current_model") or ""))
+        placeholders = self.selection.placeholders(provider)
+        if current and current not in placeholders:
+            return True, []
+        try:
+            ids = self.selection.unique_ids(
+                provider,
+                self.selection.upstream_ids(provider, config, force_refresh=force_refresh),
+            )
+        except Exception as exc:
+            if current:
+                return True, [
+                    f"Model list unavailable for {provider}; keeping configured model "
+                    f"{current} ({type(exc).__name__}: {exc})."
+                ]
+            return False, [
+                f"Model selection required for {provider}: model list unavailable "
+                f"({type(exc).__name__}: {exc})."
+            ]
+        if current and current in ids:
+            return True, []
+        candidates = [
+            model_id
+            for model_id in ids
+            if self.identity.normalize(provider, model_id) not in placeholders
+        ]
+        if len(candidates) == 1:
+            selected = self.identity.normalize(provider, candidates[0])
+            config["current_model"] = selected
+            context = self.selection.apply_specs(provider, config)
+            timeout = self.selection.apply_timeout(
+                provider, config, use_context_fallback=False
+            )
+            return True, [
+                f"Model auto-selected from provider list: {selected}.",
+                *context,
+                *timeout,
+            ]
+        if len(candidates) > 1:
+            return False, [
+                f"Model selection required for {provider}: provider returned "
+                f"{len(candidates)} models; choose one before launch/test."
+            ]
+        if current:
+            return True, [
+                f"Model list for {provider} did not include a non-placeholder model; "
+                f"keeping configured model {current}."
+            ]
+        return False, [
+            f"Model selection required for {provider}: provider returned no usable model ids."
+        ]
+
+    def launch_id(self, provider: str, config: dict[str, Any]) -> str:
+        current = self.identity.normalize(provider, config.get("current_model") or "model")
+        adapter = self.selection.adapter(provider, config)
+        contract = self.selection.contract(provider, config)
+        if adapter.launch_model_strategy(contract) != "ollama_unslug":
+            return current if adapter.preserves_claude_model_alias(current) else self.identity.alias(
+                provider, current
+            )
+        if not current.startswith(f"ciel-runtime-{provider}-"):
+            return current
+        try:
+            return (
+                self.identity.unslug(
+                    provider, current, self.identity.model_map(provider, config)
+                )
+                or current
+            )
+        except Exception:
+            return current
+
+    def resolve_requested(
+        self, provider: str, config: dict[str, Any], requested: str | None
+    ) -> str:
+        requested = self.identity.strip_context_suffix(requested)
+        fallback = self.identity.normalize(provider, config.get("current_model") or "model")
+        adapter = self.selection.adapter(provider, config)
+        model_map = self.identity.model_map(provider, config)
+        if not requested:
+            return self.identity.api_model_id(provider, fallback)
+        resolved = self.identity.unslug(provider, requested, model_map)
+        if resolved:
+            return self.identity.api_model_id(provider, resolved)
+        if requested in set(model_map.values()):
+            return self.identity.api_model_id(provider, requested)
+        if adapter.preserves_claude_model_alias(requested):
+            return self.identity.api_model_id(provider, requested)
+        if requested.startswith(("claude-", "ciel-runtime-")):
+            return self.identity.api_model_id(provider, fallback)
+        return self.identity.api_model_id(
+            provider, self.identity.normalize(provider, requested)
+        )
+
+    def resolve_tool_models(
+        self, provider: str, config: dict[str, Any], body: dict[str, Any]
+    ) -> dict[str, Any]:
+        tools = body.get("tools")
+        if not isinstance(tools, list) or not tools:
+            return body
+        projected: list[Any] = []
+        changed = 0
+        for tool in tools:
+            model = tool.get("model") if isinstance(tool, dict) else None
+            if not isinstance(model, str) or not model.strip():
+                projected.append(tool)
+                continue
+            resolved = self.resolve_requested(provider, config, model)
+            if resolved and resolved != model:
+                projected.append({**tool, "model": resolved})
+                changed += 1
+            else:
+                projected.append(tool)
+        if not changed:
+            return body
+        self.catalog.log(
+            "INFO", f"resolved upstream tool model references for {provider}: {changed}"
+        )
+        return {**body, "tools": projected}
+
+    def list_objects(self, provider: str, config: dict[str, Any]) -> list[dict[str, Any]]:
+        return [
+            self.catalog.model_object(provider, model_id, config)
+            for model_id in self.selection.upstream_ids(provider, config)
+        ]
+
+    def list_objects_for_request(
+        self, provider: str, config: dict[str, Any], inbound_headers: Any | None = None
+    ) -> list[dict[str, Any]]:
+        if self.catalog.routed_anthropic(provider, config):
+            try:
+                ids, source = self.catalog.fetch_anthropic(
+                    config,
+                    self.catalog.headers(
+                        provider,
+                        config,
+                        inbound_headers,
+                        "anthropic_messages",
+                    ),
+                    timeout=6.0,
+                )
+                if ids:
+                    ids.extend(
+                        model_id
+                        for value in config.get("custom_models", []) or []
+                        if (model_id := self.identity.normalize(provider, value))
+                        and model_id not in ids
+                    )
+                    current = self.identity.normalize(
+                        provider, config.get("current_model") or ""
+                    )
+                    if current and current not in ids:
+                        ids.append(current)
+                    self.catalog.log(
+                        "DEBUG",
+                        f"anthropic routed model discovery source={source} count={len(ids)}",
+                    )
+                    models = self.catalog.sorted_ids(
+                        self.selection.unique_ids(provider, ids)
+                    )
+                    return [
+                        self.catalog.model_object(provider, model_id, config)
+                        for model_id in models
+                    ]
+            except Exception as exc:
+                self.catalog.log(
+                    "DEBUG",
+                    "anthropic routed model discovery fallback "
+                    f"error={type(exc).__name__}: {exc}",
+                )
+        return self.list_objects(provider, config)
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelSelectionApi:
+    """Explicit public adapter for late-bound model-selection services."""
+
+    selection_factory: Callable[[], ProviderModelSelection]
+
+    def current_upstream_model_id(self, provider: str, pcfg: dict[str, Any]) -> str:
+        return self.selection_factory().current_upstream_id(provider, pcfg)
+
+    def provider_placeholder_model_ids(self, provider: str) -> set[str]:
+        return self.selection_factory().selection.placeholders(provider)
+
+    def current_model_needs_provider_selection(self, provider: str, pcfg: dict[str, Any]) -> bool:
+        return self.selection_factory().needs_selection(provider, pcfg)
+
+    def ensure_current_model_from_provider_list(self, provider: str, pcfg: dict[str, Any], *, force_refresh: bool = False) -> tuple[bool, list[str]]:
+        return self.selection_factory().ensure_selected(provider, pcfg, force_refresh=force_refresh)
+
+    def launch_model_id(self, provider: str, pcfg: dict[str, Any]) -> str:
+        return self.selection_factory().launch_id(provider, pcfg)
+
+    def resolve_requested_model(self, provider: str, pcfg: dict[str, Any], requested: str | None) -> str:
+        return self.selection_factory().resolve_requested(provider, pcfg, requested)
+
+    def resolve_tool_model_references(self, provider: str, pcfg: dict[str, Any], body: dict[str, Any]) -> dict[str, Any]:
+        return self.selection_factory().resolve_tool_models(provider, pcfg, body)
+
+    def list_model_objects(self, provider: str, pcfg: dict[str, Any]) -> list[dict[str, Any]]:
+        return self.selection_factory().list_objects(provider, pcfg)
+
+    def list_model_objects_for_request(self, provider: str, pcfg: dict[str, Any], inbound_headers: Any | None = None) -> list[dict[str, Any]]:
+        return self.selection_factory().list_objects_for_request(provider, pcfg, inbound_headers)

package/ciel_runtime_support/provider_model_specs.py

@@ -0,0 +1,142 @@
+"""Current-model specification lookup, projection, and refresh service."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from .architecture import ProviderContextPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSpecLookupPorts:
+    read_cache: Callable[[str, dict[str, Any]], Mapping[str, dict[str, Any]]]
+    normalize_model: Callable[[str, str], str]
+    upstream_model: Callable[[str, dict[str, Any]], str]
+    strip_context_suffix: Callable[[str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSpecMutationPorts:
+    positive_int: Callable[[Any], int | None]
+    apply_model_profile: Callable[[str, dict[str, Any]], list[str]]
+    context_policy: Callable[[str, dict[str, Any]], ProviderContextPolicy]
+    ollama_model_matches: Callable[[str, str | None], bool]
+    preserve_ollama_cap: Callable[[dict[str, Any]], bool]
+    format_context: Callable[[int | None], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSpecRefreshPorts:
+    refresh_models: Callable[..., Sequence[str]]
+
+
+class ProviderModelSpecService:
+    def __init__(
+        self,
+        lookup: ModelSpecLookupPorts,
+        mutation: ModelSpecMutationPorts,
+        refresh: ModelSpecRefreshPorts,
+    ) -> None:
+        self.lookup = lookup
+        self.mutation = mutation
+        self.refresh_ports = refresh
+
+    def current_info(
+        self,
+        provider: str,
+        config: dict[str, Any],
+    ) -> dict[str, Any]:
+        info = self.lookup.read_cache(provider, config)
+        if not info:
+            return {}
+        upstream = self.lookup.upstream_model(provider, config)
+        configured = str(config.get("current_model") or "")
+        normalized_upstream = self.lookup.normalize_model(provider, upstream)
+        normalized_configured = self.lookup.normalize_model(provider, configured)
+        candidates = (
+            normalized_upstream,
+            normalized_configured,
+            self.lookup.strip_context_suffix(normalized_configured),
+        )
+        for model_id in candidates:
+            if model_id and model_id in info:
+                return info[model_id]
+        folded_current = normalized_upstream.casefold()
+        for model_id, model_info in info.items():
+            if (
+                self.lookup.normalize_model(provider, model_id).casefold()
+                == folded_current
+            ):
+                return model_info
+        return {}
+
+    def apply(self, provider: str, config: dict[str, Any]) -> list[str]:
+        messages = self.mutation.apply_model_profile(provider, config)
+        info = self.current_info(provider, config)
+        max_context = (
+            self.mutation.positive_int(info.get("max_model_len")) if info else None
+        )
+        if not max_context:
+            return messages
+        model = self.lookup.normalize_model(
+            provider,
+            self.lookup.upstream_model(provider, config),
+        )
+        strategy = self.mutation.context_policy(
+            provider,
+            config,
+        ).settings_strategy
+        if strategy == "ollama":
+            cached_model = str(config.get("model_context_model") or "")
+            cached_context = self.mutation.positive_int(config.get("model_context_max"))
+            if (
+                not self.mutation.ollama_model_matches(model, cached_model)
+                or cached_context != max_context
+            ):
+                config["model_context_max"] = max_context
+                config["model_context_model"] = model
+                messages.append(self._context_notice(max_context))
+            current_max = self.mutation.positive_int(config.get("num_ctx_max"))
+            if not (
+                current_max
+                and current_max <= max_context
+                and self.mutation.preserve_ollama_cap(config)
+            ):
+                config["num_ctx_max"] = (
+                    min(current_max, max_context)
+                    if current_max and current_max > max_context
+                    else max_context
+                )
+        elif strategy == "standard":
+            if self.mutation.positive_int(config.get("max_model_len")) != max_context:
+                config["max_model_len"] = max_context
+                messages.append(self._context_notice(max_context))
+        return messages
+
+    def refresh(self, provider: str, config: dict[str, Any]) -> list[str]:
+        messages: list[str] = []
+        try:
+            models = self.refresh_ports.refresh_models(
+                provider,
+                config,
+                force_refresh=True,
+            )
+            if models:
+                messages.append(
+                    f"Model specs refreshed from provider: {len(models)} model(s)."
+                )
+        except Exception as exc:
+            messages.append(
+                f"Model specs refresh failed: {type(exc).__name__}: {exc}"
+            )
+        messages.extend(self.apply(provider, config))
+        return messages
+
+    def _context_notice(self, max_context: int) -> str:
+        return (
+            "Model context size from provider specs: "
+            f"{self.mutation.format_context(max_context)} "
+            f"({max_context:,} tokens)."
+        )