Spaces:
Running
Running
Download src/free_claude_code/providers/opencode/catalog.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 11.2 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/opencode/catalog.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/providers/opencode/catalog.py
-
curl -L -o catalog.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/opencode/catalog.py
11.2 kB
| from __future__ import annotations | |
| """OpenCode rich-catalog parsing and provider-scoped snapshot ownership.""" | |
| import asyncio | |
| from collections.abc import Mapping | |
| from dataclasses import dataclass | |
| from enum import StrEnum | |
| from types import MappingProxyType | |
| import httpx | |
| from free_claude_code.application.model_metadata import ProviderModelInfo | |
| from free_claude_code.core.model_capabilities import ModelInputModality | |
| from free_claude_code.core.reasoning import ReasoningCapability | |
| from free_claude_code.providers.admission import ( | |
| ProviderAdmissionController, | |
| ProviderOperationKind, | |
| ) | |
| from free_claude_code.providers.base import ProviderConfig | |
| from free_claude_code.providers.failure_reporting import finalize_provider_failure | |
| from free_claude_code.providers.model_listing import ( | |
| ModelListResponseError, | |
| optional_input_modalities, | |
| optional_positive_int, | |
| ) | |
| OPENCODE_CATALOG_URL = "https://models.opencode.ai/api.json" | |
| _DEFAULT_PACKAGE = "@ai-sdk/openai-compatible" | |
| _RESPONSES_PACKAGE = "@ai-sdk/openai" | |
| _VISIBLE_STATUSES = frozenset({"active", "beta"}) | |
| _HIDDEN_STATUSES = frozenset({"alpha", "deprecated"}) | |
| class OpenCodeUpstreamTransport(StrEnum): | |
| """Standard OpenAI endpoint selected by one catalog route.""" | |
| CHAT_COMPLETIONS = "chat_completions" | |
| RESPONSES = "responses" | |
| class OpenCodeModelRoute: | |
| """One public selector resolved to its upstream model and transport.""" | |
| selector_id: str | |
| upstream_model_id: str | |
| transport: OpenCodeUpstreamTransport | |
| supports_thinking: bool | None | |
| input_modalities: frozenset[ModelInputModality] | None | |
| context_window_tokens: int | None | |
| max_output_tokens: int | None | |
| def model_info(self) -> ProviderModelInfo: | |
| return ProviderModelInfo( | |
| model_id=self.selector_id, | |
| supports_thinking=self.supports_thinking, | |
| input_modalities=self.input_modalities, | |
| context_window_tokens=self.context_window_tokens, | |
| max_output_tokens=self.max_output_tokens, | |
| reasoning_capability=ReasoningCapability.NONE | |
| if self.supports_thinking is False | |
| else ReasoningCapability.UNKNOWN, | |
| ) | |
| class OpenCodeCatalogSnapshot: | |
| """One fully validated immutable provider-specific catalog view.""" | |
| routes: Mapping[str, OpenCodeModelRoute] | |
| model_infos: frozenset[ProviderModelInfo] | |
| def route(self, selector_id: str) -> OpenCodeModelRoute | None: | |
| return self.routes.get(selector_id) | |
| def parse_open_code_catalog( | |
| payload: object, | |
| *, | |
| provider_key: str, | |
| provider_name: str, | |
| ) -> OpenCodeCatalogSnapshot: | |
| """Parse one provider section without publishing a partial snapshot.""" | |
| root = _mapping(payload, provider_name, "top-level object") | |
| provider = _mapping( | |
| root.get(provider_key), | |
| provider_name, | |
| f"provider section {provider_key!r}", | |
| ) | |
| provider_package = _optional_package( | |
| provider.get("npm"), | |
| provider_name=provider_name, | |
| location="provider npm", | |
| ) | |
| models = _mapping( | |
| provider.get("models"), | |
| provider_name, | |
| "models object", | |
| ) | |
| routes: dict[str, OpenCodeModelRoute] = {} | |
| for raw_selector_id, raw_model in models.items(): | |
| selector_id = _required_string( | |
| raw_selector_id, | |
| provider_name=provider_name, | |
| location="model selector", | |
| ) | |
| if selector_id in routes: | |
| raise _catalog_error( | |
| provider_name, | |
| f"duplicate normalized model selector {selector_id!r}", | |
| ) | |
| model = _mapping( | |
| raw_model, | |
| provider_name, | |
| f"model {selector_id!r}", | |
| ) | |
| status = _model_status(model, provider_name, selector_id) | |
| if status in _HIDDEN_STATUSES: | |
| continue | |
| upstream_model_id = _required_string( | |
| model.get("id"), | |
| provider_name=provider_name, | |
| location=f"model {selector_id!r} id", | |
| ) | |
| model_provider = model.get("provider") | |
| model_package = None | |
| if model_provider is not None: | |
| provider_override = _mapping( | |
| model_provider, | |
| provider_name, | |
| f"model {selector_id!r} provider", | |
| ) | |
| model_package = _optional_package( | |
| provider_override.get("npm"), | |
| provider_name=provider_name, | |
| location=f"model {selector_id!r} provider npm", | |
| ) | |
| supports_thinking = _optional_boolean(model.get("reasoning")) | |
| raw_modalities = model.get("modalities") | |
| input_modalities = ( | |
| optional_input_modalities(raw_modalities.get("input")) | |
| if isinstance(raw_modalities, Mapping) | |
| else None | |
| ) | |
| limit = model.get("limit") | |
| context_window_tokens = ( | |
| optional_positive_int(limit.get("context")) | |
| if isinstance(limit, Mapping) | |
| else None | |
| ) | |
| max_output_tokens = ( | |
| optional_positive_int(limit.get("output")) | |
| if isinstance(limit, Mapping) | |
| else None | |
| ) | |
| effective_package = model_package or provider_package or _DEFAULT_PACKAGE | |
| route = OpenCodeModelRoute( | |
| selector_id=selector_id, | |
| upstream_model_id=upstream_model_id, | |
| transport=( | |
| OpenCodeUpstreamTransport.RESPONSES | |
| if effective_package == _RESPONSES_PACKAGE | |
| else OpenCodeUpstreamTransport.CHAT_COMPLETIONS | |
| ), | |
| supports_thinking=supports_thinking, | |
| input_modalities=input_modalities, | |
| context_window_tokens=context_window_tokens, | |
| max_output_tokens=max_output_tokens, | |
| ) | |
| routes[selector_id] = route | |
| if not routes: | |
| raise _catalog_error(provider_name, "no active or beta models") | |
| model_infos = frozenset(route.model_info for route in routes.values()) | |
| return OpenCodeCatalogSnapshot( | |
| routes=MappingProxyType(routes), | |
| model_infos=model_infos, | |
| ) | |
| class OpenCodeCatalog: | |
| """Own one OpenCode provider's catalog client and last-good snapshot.""" | |
| def __init__( | |
| self, | |
| config: ProviderConfig, | |
| *, | |
| provider_key: str, | |
| provider_name: str, | |
| admission: ProviderAdmissionController, | |
| client: httpx.AsyncClient | None = None, | |
| ) -> None: | |
| self._provider_key = provider_key | |
| self._provider_name = provider_name | |
| self._admission = admission | |
| self._client = client or httpx.AsyncClient( | |
| proxy=config.proxy, | |
| timeout=httpx.Timeout( | |
| config.http_read_timeout, | |
| connect=config.http_connect_timeout, | |
| read=config.http_read_timeout, | |
| write=config.http_write_timeout, | |
| ), | |
| ) | |
| self._snapshot: OpenCodeCatalogSnapshot | None = None | |
| self._lock = asyncio.Lock() | |
| self._read_timeout = config.http_read_timeout | |
| def current_snapshot(self) -> OpenCodeCatalogSnapshot | None: | |
| return self._snapshot | |
| async def snapshot( | |
| self, *, request_id: str | None = None | |
| ) -> OpenCodeCatalogSnapshot: | |
| """Return last-good data or coalesce one cold catalog load.""" | |
| if self._snapshot is not None: | |
| return self._snapshot | |
| async with self._lock: | |
| if self._snapshot is not None: | |
| return self._snapshot | |
| try: | |
| return await self._load_and_publish(request_id=request_id) | |
| except Exception as exc: | |
| raise finalize_provider_failure( | |
| exc, | |
| provider_name=self._provider_name, | |
| read_timeout_s=self._read_timeout, | |
| request_id=request_id, | |
| ) from exc | |
| async def refresh(self) -> OpenCodeCatalogSnapshot: | |
| """Load and atomically publish one fully validated fresh snapshot.""" | |
| async with self._lock: | |
| return await self._load_and_publish() | |
| async def cleanup(self) -> None: | |
| await self._client.aclose() | |
| async def _load_and_publish( | |
| self, *, request_id: str | None = None | |
| ) -> OpenCodeCatalogSnapshot: | |
| async def request() -> OpenCodeCatalogSnapshot: | |
| response = await self._client.get( | |
| OPENCODE_CATALOG_URL, | |
| headers={"Accept": "application/json", "User-Agent": "opencode"}, | |
| ) | |
| try: | |
| response.raise_for_status() | |
| try: | |
| payload: object = response.json() | |
| except ValueError as exc: | |
| raise _catalog_error( | |
| self._provider_name, | |
| "invalid JSON", | |
| ) from exc | |
| return parse_open_code_catalog( | |
| payload, | |
| provider_key=self._provider_key, | |
| provider_name=self._provider_name, | |
| ) | |
| finally: | |
| await response.aclose() | |
| execution = self._admission.start_execution(request_id=request_id, model=None) | |
| snapshot = await execution.run_call( | |
| request, | |
| operation_kind=ProviderOperationKind.MODEL_DISCOVERY, | |
| ) | |
| self._snapshot = snapshot | |
| return snapshot | |
| def _mapping( | |
| value: object, | |
| provider_name: str, | |
| location: str, | |
| ) -> Mapping[object, object]: | |
| if isinstance(value, Mapping): | |
| return value | |
| raise _catalog_error(provider_name, f"expected {location}") | |
| def _required_string( | |
| value: object, | |
| *, | |
| provider_name: str, | |
| location: str, | |
| ) -> str: | |
| if isinstance(value, str) and (normalized := value.strip()): | |
| return normalized | |
| raise _catalog_error(provider_name, f"expected non-empty {location}") | |
| def _optional_package( | |
| value: object, | |
| *, | |
| provider_name: str, | |
| location: str, | |
| ) -> str | None: | |
| if value is None: | |
| return None | |
| return _required_string( | |
| value, | |
| provider_name=provider_name, | |
| location=location, | |
| ) | |
| def _optional_boolean(value: object) -> bool | None: | |
| return value if isinstance(value, bool) else None | |
| def _model_status( | |
| model: Mapping[object, object], | |
| provider_name: str, | |
| selector_id: str, | |
| ) -> str: | |
| value = model.get("status") | |
| if value is None: | |
| return "active" | |
| status = _required_string( | |
| value, | |
| provider_name=provider_name, | |
| location=f"model {selector_id!r} status", | |
| ) | |
| if status not in _VISIBLE_STATUSES | _HIDDEN_STATUSES: | |
| raise _catalog_error( | |
| provider_name, | |
| f"unknown model {selector_id!r} status {status!r}", | |
| ) | |
| return status | |
| def _catalog_error(provider_name: str, detail: str) -> ModelListResponseError: | |
| return ModelListResponseError( | |
| f"{provider_name} rich catalog is malformed: {detail}" | |
| ) | |