@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/provider_administration_context.py

@@ -0,0 +1,207 @@
+"""Provider configuration and credential administration use cases."""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+from typing import Any, Callable, Protocol
+
+
+class CredentialRepository(Protocol):
+    def store(self, key: str) -> None: ...
+    def clear(self) -> None: ...
+
+
+class OAuthRuntime(Protocol):
+    def token(self) -> str: ...
+    def action(self, action: str) -> list[str]: ...
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdministrationInfrastructure:
+    nvidia_credentials: Callable[[], CredentialRepository]
+    copilot_oauth: Callable[[], OAuthRuntime]
+    output: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdministrationSelection:
+    provider_choice: Callable[[], Any]
+    provider_endpoint: Callable[[], Any]
+    model_selection: Callable[[], Any]
+    advisor_model_selection: Callable[[], Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdministrationCredentials:
+    management: Callable[[], Any]
+    cli: Callable[[], Any]
+    configured_keys: Callable[[str, dict[str, Any]], list[str]]
+    mask: Callable[[str], str]
+    fingerprint: Callable[[str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdministrationPresentation:
+    status: Callable[[], Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdministrationContext:
+    infrastructure: ProviderAdministrationInfrastructure
+    selection: ProviderAdministrationSelection
+    credentials: ProviderAdministrationCredentials
+    presentation: ProviderAdministrationPresentation
+
+    def store_nvidia_api_key(self, key: str) -> None:
+        self.infrastructure.nvidia_credentials().store(key)
+
+    def clear_nvidia_api_key(self) -> None:
+        self.infrastructure.nvidia_credentials().clear()
+
+    def github_copilot_oauth_token(self) -> str:
+        return self.infrastructure.copilot_oauth().token()
+
+    def run_copilot_oauth_action(self, action: str) -> list[str]:
+        return self.infrastructure.copilot_oauth().action(action)
+
+    def cmd_copilot_oauth(self, args: argparse.Namespace) -> None:
+        for line in self.run_copilot_oauth_action(args.action):
+            self.infrastructure.output(line, flush=True)
+
+    def set_provider_config(self, provider: str) -> list[str]:
+        return self.selection.provider_choice().select_standard(provider)
+
+    def set_provider_choice_config(self, choice: str) -> list[str]:
+        return self.selection.provider_choice().select(choice)
+
+    def set_base_url_config(self, provider: str, url: str) -> list[str]:
+        return self.selection.provider_endpoint().set_base_url(provider, url)
+
+    def set_model_config(self, value: str) -> list[str]:
+        return self.selection.model_selection().select(value)
+
+    def set_advisor_model_config(self, value: str) -> list[str]:
+        return self.selection.advisor_model_selection().select(value)
+
+    def store_api_key_config(self, provider: str, key: str) -> list[str]:
+        return self.credentials.management().store_one(provider, key)
+
+    def clear_api_key_config(self, provider: str) -> list[str]:
+        return self.credentials.management().clear(provider)
+
+    def store_api_keys_config(
+        self, provider: str, keys: list[str]
+    ) -> list[str]:
+        return self.credentials.management().store_many(provider, keys)
+
+    def stored_api_key_mask(self, provider: str, pcfg: dict[str, Any]) -> str:
+        keys = self.credentials.configured_keys(provider, pcfg)
+        if not keys:
+            return "not set"
+        primary = (
+            f"{self.credentials.mask(keys[0])}; "
+            f"fp {self.credentials.fingerprint(keys[0])}"
+        )
+        if len(keys) == 1:
+            return primary
+        return f"{len(keys)} keys (round-robin; primary {primary})"
+
+    def store_api_key_input_config(
+        self, provider: str, raw_value: str
+    ) -> list[str]:
+        return self.credentials.management().store_input(provider, raw_value)
+
+    def cmd_set_api_key(self, args: argparse.Namespace) -> None:
+        self.credentials.cli().set_one(args)
+
+    def cmd_set_api_keys(self, args: argparse.Namespace) -> None:
+        self.credentials.cli().set_many(args)
+
+    def cmd_api_key(self, args: argparse.Namespace) -> None:
+        self.credentials.cli().manage(args)
+
+    def status_lines(self) -> list[str]:
+        return self.presentation.status().lines()
+
+    def cmd_status(self, _: argparse.Namespace) -> None:
+        self.infrastructure.output("\n".join(self.status_lines()))
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdministrationCompatibilityApi:
+    context: Callable[[], ProviderAdministrationContext]
+
+    def store_nvidia_api_key(self, key: str) -> None:
+        self.context().store_nvidia_api_key(key)
+
+    def clear_nvidia_api_key(self) -> None:
+        self.context().clear_nvidia_api_key()
+
+    def github_copilot_oauth_token(self) -> str:
+        return self.context().github_copilot_oauth_token()
+
+    def run_copilot_oauth_action(self, action: str) -> list[str]:
+        return self.context().run_copilot_oauth_action(action)
+
+    def cmd_copilot_oauth(self, args: argparse.Namespace) -> None:
+        self.context().cmd_copilot_oauth(args)
+
+    def set_provider_config(self, provider: str) -> list[str]:
+        return self.context().set_provider_config(provider)
+
+    def set_provider_choice_config(self, choice: str) -> list[str]:
+        return self.context().set_provider_choice_config(choice)
+
+    def set_base_url_config(self, provider: str, url: str) -> list[str]:
+        return self.context().set_base_url_config(provider, url)
+
+    def set_model_config(self, value: str) -> list[str]:
+        return self.context().set_model_config(value)
+
+    def set_advisor_model_config(self, value: str) -> list[str]:
+        return self.context().set_advisor_model_config(value)
+
+    def store_api_key_config(self, provider: str, key: str) -> list[str]:
+        return self.context().store_api_key_config(provider, key)
+
+    def clear_api_key_config(self, provider: str) -> list[str]:
+        return self.context().clear_api_key_config(provider)
+
+    def store_api_keys_config(
+        self, provider: str, keys: list[str]
+    ) -> list[str]:
+        return self.context().store_api_keys_config(provider, keys)
+
+    def stored_api_key_mask(self, provider: str, pcfg: dict[str, Any]) -> str:
+        return self.context().stored_api_key_mask(provider, pcfg)
+
+    def store_api_key_input_config(
+        self, provider: str, raw_value: str
+    ) -> list[str]:
+        return self.context().store_api_key_input_config(provider, raw_value)
+
+    def cmd_set_api_key(self, args: argparse.Namespace) -> None:
+        self.context().cmd_set_api_key(args)
+
+    def cmd_set_api_keys(self, args: argparse.Namespace) -> None:
+        self.context().cmd_set_api_keys(args)
+
+    def cmd_api_key(self, args: argparse.Namespace) -> None:
+        self.context().cmd_api_key(args)
+
+    def status_lines(self) -> list[str]:
+        return self.context().status_lines()
+
+    def cmd_status(self, args: argparse.Namespace) -> None:
+        self.context().cmd_status(args)
+
+
+__all__ = [
+    "ProviderAdministrationCompatibilityApi",
+    "ProviderAdministrationContext",
+    "ProviderAdministrationCredentials",
+    "ProviderAdministrationInfrastructure",
+    "ProviderAdministrationPresentation",
+    "ProviderAdministrationSelection",
+]

package/ciel_runtime_support/provider_config_mutations.py

@@ -64,6 +64,7 @@ def apply_ollama_option(
             _set_ollama_option_explicit(pcfg, "num_predict", False)
         elif key in ("keep_alive", "keepalive"):
             pcfg.pop("keep_alive", None)
+            pcfg.pop("keep_alive_explicit", None)
         elif key == "think":
             pcfg["think"] = False
             pcfg.pop("think_explicit", None)
@@ -120,8 +121,10 @@ def apply_ollama_option(
     if key in ("keep_alive", "keepalive"):
         if value is None:
             pcfg.pop("keep_alive", None)
+            pcfg.pop("keep_alive_explicit", None)
         else:
             pcfg["keep_alive"] = str(value)
+            pcfg["keep_alive_explicit"] = True
         return
     if key in ("timeout", "timeout_ms", "request_timeout", "request_timeout_ms"):
         fixed = positive_int(value)

package/ciel_runtime_support/provider_model_catalog_context.py

@@ -0,0 +1,137 @@
+"""Provider model registry and cache lifecycle bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .model_cache_lifecycle import (
+    ModelCacheLifecyclePorts,
+    ModelCacheLifecycleService,
+)
+from .model_registry_repository import (
+    ModelRegistryPaths,
+    ModelRegistryPolicy,
+    ModelRegistryRepository,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelRegistryConfig:
+    config_dir: Path
+    registry_path: Path
+    list_cache_path: Path
+    gateway_cache_path: Path
+    ttl_seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelRegistryPorts:
+    cache_key: Callable[..., str]
+    unique_ids: Callable[..., list[str]]
+    normalize_id: Callable[..., str]
+    positive_int: Callable[..., int]
+    recommendations: Callable[..., dict[str, Any]]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelCachePorts:
+    invalidate_config: Callable[[], None]
+    upstream_model_ids: Callable[..., list[str]]
+    catalog_model_ids: Callable[..., list[str]]
+    sorted_model_ids: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelCatalogCompatibilityPorts:
+    read_list_cache: Callable[..., list[str] | None]
+    read_registry_models: Callable[..., list[str] | None]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelCatalogContext:
+    config: ProviderModelRegistryConfig
+    registry: ProviderModelRegistryPorts
+    cache: ProviderModelCachePorts
+    compatibility: ProviderModelCatalogCompatibilityPorts
+
+    def registry_repository(self) -> ModelRegistryRepository:
+        return ModelRegistryRepository(
+            paths=ModelRegistryPaths(
+                self.config.config_dir,
+                self.config.registry_path,
+                self.config.list_cache_path,
+            ),
+            policy=ModelRegistryPolicy(
+                cache_key=self.registry.cache_key,
+                unique_ids=self.registry.unique_ids,
+                normalize_id=self.registry.normalize_id,
+                positive_int=self.registry.positive_int,
+                recommendations=self.registry.recommendations,
+                log=self.registry.log,
+            ),
+            ttl_seconds=self.config.ttl_seconds,
+        )
+
+    def lifecycle_service(self) -> ModelCacheLifecycleService:
+        return ModelCacheLifecycleService(
+            ModelCacheLifecyclePorts(
+                invalidate_config=self.cache.invalidate_config,
+                artifact_paths=lambda: (
+                    self.config.gateway_cache_path,
+                    self.config.list_cache_path,
+                    self.config.registry_path,
+                ),
+                read_list_cache=self.compatibility.read_list_cache,
+                read_registry_models=self.compatibility.read_registry_models,
+                upstream_model_ids=self.cache.upstream_model_ids,
+                catalog_model_ids=self.cache.catalog_model_ids,
+                normalize_model_id=self.registry.normalize_id,
+                unique_model_ids=self.registry.unique_ids,
+                sorted_model_ids=self.cache.sorted_model_ids,
+                log=self.registry.log,
+            )
+        )
+
+    def clear(self) -> None:
+        self.lifecycle_service().clear()
+
+    def cached_or_configured_ids(
+        self, provider: str, pcfg: dict[str, Any]
+    ) -> list[str]:
+        return self.lifecycle_service().cached_or_configured_ids(provider, pcfg)
+
+    def ensure_for_launch(self, provider: str, pcfg: dict[str, Any]) -> None:
+        self.lifecycle_service().ensure_for_launch(provider, pcfg)
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelCatalogCompatibilityApi:
+    context: Callable[[], ProviderModelCatalogContext]
+
+    def registry_repository(self) -> ModelRegistryRepository:
+        return self.context().registry_repository()
+
+    def lifecycle_service(self) -> ModelCacheLifecycleService:
+        return self.context().lifecycle_service()
+
+    def clear(self) -> None:
+        self.context().clear()
+
+    def cached_or_configured_ids(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().cached_or_configured_ids(*args, **kwargs)
+
+    def ensure_for_launch(self, *args: Any, **kwargs: Any) -> None:
+        self.context().ensure_for_launch(*args, **kwargs)
+
+
+__all__ = [
+    "ProviderModelCachePorts",
+    "ProviderModelCatalogCompatibilityPorts",
+    "ProviderModelCatalogCompatibilityApi",
+    "ProviderModelCatalogContext",
+    "ProviderModelRegistryConfig",
+    "ProviderModelRegistryPorts",
+]

package/ciel_runtime_support/provider_model_context.py

@@ -0,0 +1,107 @@
+"""Provider model context-capacity and output-budget bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .architecture import ProviderContextPolicy
+from .provider_context import ProviderContextServices
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelContextQueries:
+    context_policy: Callable[[str, dict[str, Any]], ProviderContextPolicy]
+    context_limit: Callable[[str, dict[str, Any]], int | None]
+    positive_int: Callable[[Any], int | None]
+    format_context: Callable[[int | None], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelContextAlgorithms:
+    resolve_capacity: Callable[..., int | None]
+    apply_capacity_cap: Callable[..., list[str]]
+    resolve_small_output_cap: Callable[..., int | None]
+    apply_output_token_cap: Callable[..., int | None]
+    apply_output_context_cap: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelContext:
+    services: ProviderContextServices
+    queries: ProviderModelContextQueries
+    algorithms: ProviderModelContextAlgorithms
+
+    def capacity(self, provider: str, config: dict[str, Any]) -> int | None:
+        return self.algorithms.resolve_capacity(
+            provider,
+            config,
+            self.queries.context_policy(provider, config),
+            self.services,
+        )
+
+    def cap_context(self, provider: str, config: dict[str, Any]) -> list[str]:
+        return self.algorithms.apply_capacity_cap(
+            config,
+            self.capacity(provider, config),
+            self.queries.context_policy(provider, config),
+            positive_int=self.queries.positive_int,
+        )
+
+    def small_output_cap(self, context_window: int | None) -> int | None:
+        return self.algorithms.resolve_small_output_cap(
+            context_window, positive_int=self.queries.positive_int
+        )
+
+    def cap_output_tokens(
+        self, provider: str, config: dict[str, Any], configured: int | None
+    ) -> int | None:
+        return self.algorithms.apply_output_token_cap(
+            configured,
+            self.queries.context_policy(provider, config),
+            self.queries.context_limit(provider, config),
+            positive_int=self.queries.positive_int,
+        )
+
+    def cap_output_settings(
+        self, provider: str, config: dict[str, Any]
+    ) -> list[str]:
+        return self.algorithms.apply_output_context_cap(
+            config,
+            self.queries.context_policy(provider, config),
+            self.queries.context_limit(provider, config),
+            positive_int=self.queries.positive_int,
+            format_context=self.queries.format_context,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelContextCompatibilityApi:
+    context: Callable[[], ProviderModelContext]
+
+    def capacity(self, provider: str, config: dict[str, Any]) -> int | None:
+        return self.context().capacity(provider, config)
+
+    def cap_context(self, provider: str, config: dict[str, Any]) -> list[str]:
+        return self.context().cap_context(provider, config)
+
+    def small_output_cap(self, context_window: int | None) -> int | None:
+        return self.context().small_output_cap(context_window)
+
+    def cap_output_tokens(
+        self, provider: str, config: dict[str, Any], configured: int | None
+    ) -> int | None:
+        return self.context().cap_output_tokens(provider, config, configured)
+
+    def cap_output_settings(
+        self, provider: str, config: dict[str, Any]
+    ) -> list[str]:
+        return self.context().cap_output_settings(provider, config)
+
+
+__all__ = [
+    "ProviderModelContext",
+    "ProviderModelContextAlgorithms",
+    "ProviderModelContextCompatibilityApi",
+    "ProviderModelContextQueries",
+]

package/ciel_runtime_support/provider_model_metadata_context.py

@@ -0,0 +1,197 @@
+"""Provider model cache identity, capability, and catalog header policy."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from . import anthropic_model_policy
+
+
+@dataclass(frozen=True, slots=True)
+class ModelCapabilityPorts:
+    normalize_capabilities: Callable[[Any], list[str]]
+    current_model: Callable[[str, dict[str, Any]], str]
+    strip_context_suffix: Callable[[str], str]
+    is_kimi_k3: Callable[[str], bool]
+    parse_bool: Callable[..., bool]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRegistryRecommendationPorts:
+    unique_model_ids: Callable[[list[str]], list[str]]
+    preset_timeout_ms: Callable[[str], int]
+    timeout_idle_ms: Callable[[str], int]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelCatalogHeaderPorts:
+    api_key_count: Callable[[str, dict[str, Any]], int]
+    read_env_file: Callable[[Path], dict[str, str]]
+    environment: Mapping[str, str]
+    user_agent_headers: Callable[..., dict[str, str]]
+    primary_api_key: Callable[[str, dict[str, Any]], str | None]
+    meaningful_key: Callable[[str | None], bool]
+    configured_adapter: Callable[..., Any]
+    contract_config: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelMetadataContext:
+    capabilities: ModelCapabilityPorts
+    recommendations: ModelRegistryRecommendationPorts
+    headers: ModelCatalogHeaderPorts
+    nvidia_env: Path
+
+    def cache_key(self, provider: str, pcfg: dict[str, Any]) -> str:
+        api_state = (
+            "key" if self.headers.api_key_count(provider, pcfg) else "nokey"
+        )
+        return json.dumps(
+            {
+                "provider": provider,
+                "base_url": pcfg.get("base_url", ""),
+                "model_api_base_url": pcfg.get("model_api_base_url", ""),
+                "account_id": pcfg.get("account_id", ""),
+                "api": api_state,
+                "custom": pcfg.get("custom_models", []),
+                "schema": 7,
+            },
+            sort_keys=True,
+        )
+
+    def infer_claude_capabilities(self, model_id: str) -> list[str]:
+        return anthropic_model_policy.infer_capabilities(
+            model_id, self.capabilities.strip_context_suffix
+        )
+
+    def claude_capabilities(
+        self,
+        provider: str,
+        pcfg: dict[str, Any],
+        model_id: str | None = None,
+    ) -> list[str]:
+        caps = self.capabilities.normalize_capabilities(
+            pcfg.get("claude_code_supported_capabilities")
+        )
+        model = model_id or self.capabilities.current_model(provider, pcfg)
+        if not caps:
+            caps = self.infer_claude_capabilities(model)
+        if (
+            provider == "kimi"
+            and self.capabilities.is_kimi_k3(model)
+            and "max_effort" not in caps
+        ):
+            caps.append("max_effort")
+        return caps
+
+    def claude_capability_string(
+        self,
+        provider: str,
+        pcfg: dict[str, Any],
+        model_id: str | None = None,
+    ) -> str:
+        return ",".join(self.claude_capabilities(provider, pcfg, model_id))
+
+    def workflows_enabled(self, provider: str, pcfg: dict[str, Any]) -> bool:
+        del provider
+        ultracode = (
+            pcfg.get("ultracode_enabled")
+            if "ultracode_enabled" in pcfg
+            else pcfg.get("ultracode")
+        )
+        if self.capabilities.parse_bool(ultracode, False):
+            return True
+        value = (
+            pcfg.get("workflows_enabled")
+            if "workflows_enabled" in pcfg
+            else pcfg.get("workflows")
+        )
+        return self.capabilities.parse_bool(value, False)
+
+    def ultracode_enabled(self, provider: str, pcfg: dict[str, Any]) -> bool:
+        del provider
+        value = (
+            pcfg.get("ultracode_enabled")
+            if "ultracode_enabled" in pcfg
+            else pcfg.get("ultracode")
+        )
+        return self.capabilities.parse_bool(value, False)
+
+    def registry_recommendations(
+        self, provider: str, models: list[str]
+    ) -> dict[str, Any]:
+        return anthropic_model_policy.AnthropicModelRecommendations(
+            self.recommendations.unique_model_ids,
+            self.recommendations.preset_timeout_ms,
+            self.recommendations.timeout_idle_ms,
+        ).build(provider, models)
+
+    def nvidia_list_headers(self) -> dict[str, str]:
+        headers = {"content-type": "application/json"}
+        key = self.headers.read_env_file(self.nvidia_env).get(
+            "NVIDIA_API_KEY"
+        ) or self.headers.environment.get("NVIDIA_API_KEY")
+        if key:
+            headers["authorization"] = f"Bearer {key}"
+            headers["x-api-key"] = key
+        return headers
+
+    def provider_list_headers(
+        self, provider: str, pcfg: dict[str, Any]
+    ) -> dict[str, str]:
+        headers = self.headers.user_agent_headers(
+            {"content-type": "application/json"}
+        )
+        key = self.headers.primary_api_key(provider, pcfg)
+        meaningful = str(key) if self.headers.meaningful_key(key) else None
+        adapter = self.headers.configured_adapter(provider, pcfg)
+        headers.update(
+            adapter.build_model_headers(
+                self.headers.contract_config(provider, pcfg), meaningful
+            )
+        )
+        return headers
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelMetadataCompatibilityApi:
+    context: Callable[[], ProviderModelMetadataContext]
+
+    def cache_key(self, *args: Any, **kwargs: Any) -> str:
+        return self.context().cache_key(*args, **kwargs)
+
+    def infer_claude_capabilities(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().infer_claude_capabilities(*args, **kwargs)
+
+    def claude_capabilities(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().claude_capabilities(*args, **kwargs)
+
+    def claude_capability_string(self, *args: Any, **kwargs: Any) -> str:
+        return self.context().claude_capability_string(*args, **kwargs)
+
+    def workflows_enabled(self, *args: Any, **kwargs: Any) -> bool:
+        return self.context().workflows_enabled(*args, **kwargs)
+
+    def ultracode_enabled(self, *args: Any, **kwargs: Any) -> bool:
+        return self.context().ultracode_enabled(*args, **kwargs)
+
+    def registry_recommendations(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        return self.context().registry_recommendations(*args, **kwargs)
+
+    def nvidia_list_headers(self) -> dict[str, str]:
+        return self.context().nvidia_list_headers()
+
+    def provider_list_headers(self, *args: Any, **kwargs: Any) -> dict[str, str]:
+        return self.context().provider_list_headers(*args, **kwargs)
+
+
+__all__ = [
+    "ModelCapabilityPorts",
+    "ModelCatalogHeaderPorts",
+    "ModelRegistryRecommendationPorts",
+    "ProviderModelMetadataCompatibilityApi",
+    "ProviderModelMetadataContext",
+]

package/ciel_runtime_support/provider_model_selection.py

@@ -220,13 +220,20 @@ class ProviderModelSelection:
         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)
+        contract = self.selection.contract(provider, config)
+        catalog_policy = adapter.model_catalog_policy(contract)
+        if (
+            not adapter.requires_catalog_model_selection(contract)
+            and not catalog_policy.authoritative_upstream_catalog
         ):
             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:
+        if (
+            current
+            and current not in placeholders
+            and not catalog_policy.authoritative_upstream_catalog
+        ):
             return True, []
         try:
             ids = self.selection.unique_ids(