dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
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"
@dataclass(frozen=True, slots=True)
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
@property
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,
)
@dataclass(frozen=True, slots=True)
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
@property
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}"
)