Spaces:
Sleeping
Sleeping
| """Provider model-list metadata cache.""" | |
| from collections.abc import Iterable | |
| from free_claude_code.application.model_metadata import ProviderModelInfo | |
| from free_claude_code.config.provider_catalog import SUPPORTED_PROVIDER_IDS | |
| class ProviderModelCache: | |
| """Store provider model metadata for instant model-list responses.""" | |
| def __init__( | |
| self, | |
| available_provider_ids: Iterable[str] = SUPPORTED_PROVIDER_IDS, | |
| ) -> None: | |
| self._available_provider_ids = frozenset(available_provider_ids) | |
| self._model_infos_by_provider: dict[str, dict[str, ProviderModelInfo]] = {} | |
| def cache_model_infos( | |
| self, provider_id: str, model_infos: Iterable[ProviderModelInfo] | |
| ) -> None: | |
| """Store provider model metadata by raw provider model id.""" | |
| if provider_id not in self._available_provider_ids: | |
| return | |
| clean_infos = { | |
| info.model_id: info for info in model_infos if info.model_id.strip() | |
| } | |
| self._model_infos_by_provider[provider_id] = clean_infos | |
| def set_available_providers(self, provider_ids: Iterable[str]) -> None: | |
| """Replace the provider scope and discard entries outside it.""" | |
| self._available_provider_ids = frozenset(provider_ids) | |
| self._model_infos_by_provider = { | |
| provider_id: infos | |
| for provider_id, infos in self._model_infos_by_provider.items() | |
| if provider_id in self._available_provider_ids | |
| } | |
| def add_provider(self, provider_id: str) -> None: | |
| """Make one dynamically authenticated provider cacheable.""" | |
| self._available_provider_ids = self._available_provider_ids | {provider_id} | |
| def remove_provider(self, provider_id: str) -> None: | |
| """Evict one provider and stop accepting its discovered metadata.""" | |
| self._available_provider_ids = self._available_provider_ids - {provider_id} | |
| self._model_infos_by_provider.pop(provider_id, None) | |
| def cached_model_ids(self) -> dict[str, frozenset[str]]: | |
| """Return cached raw provider model ids by provider.""" | |
| return { | |
| provider_id: frozenset(infos) | |
| for provider_id, infos in self._model_infos_by_provider.items() | |
| } | |
| def has_provider(self, provider_id: str) -> bool: | |
| """Return whether this provider has any cached model-list result.""" | |
| return provider_id in self._model_infos_by_provider | |
| def cached_model_supports_thinking( | |
| self, provider_id: str, model_id: str | |
| ) -> bool | None: | |
| """Return cached thinking support when a provider exposes it.""" | |
| info = self._model_infos_by_provider.get(provider_id, {}).get(model_id) | |
| if info is None: | |
| return None | |
| return info.supports_thinking | |
| def cached_prefixed_model_infos(self) -> tuple[ProviderModelInfo, ...]: | |
| """Return cached provider models with user-selectable prefixed ids.""" | |
| infos: list[ProviderModelInfo] = [] | |
| for provider_id in SUPPORTED_PROVIDER_IDS: | |
| provider_infos = self._model_infos_by_provider.get(provider_id, {}) | |
| infos.extend( | |
| ProviderModelInfo( | |
| model_id=f"{provider_id}/{info.model_id}", | |
| supports_thinking=info.supports_thinking, | |
| ) | |
| for info in sorted( | |
| provider_infos.values(), key=lambda item: item.model_id | |
| ) | |
| ) | |
| return tuple(infos) | |
| def clear(self) -> None: | |
| """Clear all cached model metadata.""" | |
| self._model_infos_by_provider.clear() | |