from __future__ import annotations """OpenCode provider with catalog-driven Chat/Responses dispatch.""" import sys from collections.abc import AsyncIterator, Mapping from dataclasses import dataclass import httpx from free_claude_code.application.errors import InvalidRequestError from free_claude_code.application.model_metadata import ProviderModelInfo from free_claude_code.core.anthropic import ReasoningReplayMode from free_claude_code.core.anthropic.models import MessagesRequest from free_claude_code.core.chat_completions.request import ChatRequest from free_claude_code.core.gemini import GeminiRequest from free_claude_code.core.openai_responses import ( OpenAIResponsesRequest, ResponsesToolPolicy, ) from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy from free_claude_code.core.stream_output import StreamOutput from free_claude_code.core.stream_recovery import ContinuationSeed from free_claude_code.providers.admission import ProviderAdmissionController from free_claude_code.providers.base import BaseProvider, ProviderConfig from free_claude_code.providers.endpoint_types import EndpointContext from free_claude_code.providers.history_negotiation import HistoryModeCache from free_claude_code.providers.http import close_provider_stream from free_claude_code.providers.openai_chat import ( NO_REASONING, OpenAIChatBehavior, OpenAIChatProfile, OpenAIChatRequestPolicy, OpenAIChatTransport, create_chat_client, ) from free_claude_code.providers.openai_responses import OpenAIResponsesTransport from .catalog import ( OpenCodeCatalog, OpenCodeCatalogSnapshot, OpenCodeModelRoute, OpenCodeUpstreamTransport, ) @dataclass(frozen=True, slots=True) class OpenCodeProfile: """Immutable identity and catalog configuration for one OpenCode plan.""" provider_id: str provider_name: str catalog_key: str chat_profile: OpenAIChatProfile def _profile( provider_id: str, provider_name: str, catalog_key: str, ) -> OpenCodeProfile: return OpenCodeProfile( provider_id=provider_id, provider_name=provider_name, catalog_key=catalog_key, chat_profile=OpenAIChatProfile( OpenAIChatRequestPolicy( provider_name=provider_name, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT, ), NO_REASONING, user_agent="opencode", ), ) _PROFILES = { "opencode_zen": _profile("opencode_zen", "OPENCODE_ZEN", "opencode"), "opencode_go": _profile("opencode_go", "OPENCODE_GO", "opencode-go"), } class OpenCodeProvider(BaseProvider): """Route OpenCode models through their catalog-declared OpenAI endpoint.""" def __init__( self, config: ProviderConfig, *, profile: OpenCodeProfile, admission: ProviderAdmissionController, history_cache: HistoryModeCache | None = None, catalog_client: httpx.AsyncClient | None = None, ) -> None: super().__init__(config, history_cache=history_cache) self._client = create_chat_client( config, base_url=profile.chat_profile.base_url(config.base_url).rstrip("/"), provider_name=profile.provider_name, default_headers={"User-Agent": "opencode"}, ) self._chat = OpenAIChatTransport( client=self._client, admission=admission, history_cache=self._history_cache, behavior=OpenAIChatBehavior(profile.chat_profile), read_timeout_s=config.http_read_timeout, log_raw_sse_events=config.log_raw_sse_events, log_api_error_tracebacks=config.log_api_error_tracebacks, ) self._opencode_profile = profile self._catalog = OpenCodeCatalog( config, provider_key=profile.catalog_key, provider_name=profile.provider_name, admission=admission, client=catalog_client, ) self._responses = OpenAIResponsesTransport( client=self._client, admission=admission, history_cache=self._history_cache, provider_name=profile.provider_name, read_timeout_s=config.http_read_timeout, log_raw_sse_events=config.log_raw_sse_events, tool_policy=ResponsesToolPolicy( custom_tools_as_functions=True, explicit_search_parameters=True, text_only_web_search=True, client_tool_search=True, flatten_namespaces=True, ), ) async def cleanup(self) -> None: """Close both owned clients even when one cleanup fails.""" errors: list[Exception] = [] try: await self._client.close() except Exception as exc: errors.append(exc) try: await self._catalog.cleanup() except Exception as exc: errors.append(exc) if len(errors) == 1: raise errors[0] if errors: raise ExceptionGroup("OpenCode provider cleanup failed", errors) async def list_model_infos(self) -> frozenset[ProviderModelInfo]: snapshot = await self._catalog.refresh() return snapshot.model_infos def _upstream_headers( self, request_headers: Mapping[str, str] ) -> Mapping[str, str]: headers = {name.lower(): value for name, value in request_headers.items()} upstream_headers = {} user_agent = headers.get("user-agent") if user_agent and user_agent.isascii() and user_agent.strip(): upstream_headers["User-Agent"] = user_agent for name in ( "x-opencode-session", "session-id", "x-session-id", "x-claude-code-session-id", "session_id", "x-grok-session-id", "x-meta-ai-gateway-session-id", "x-tbh-session-id", "x-fcc-launch-id", ): session_id = headers.get(name) if session_id and session_id.strip(): upstream_headers["x-opencode-session"] = session_id break return upstream_headers def stream_messages( self, request: MessagesRequest, input_tokens: int = 0, *, request_id: str | None = None, response_model: str | None = None, reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, endpoint_context: EndpointContext | None = None, request_headers: Mapping[str, str] | None = None, model_info: ProviderModelInfo | None = None, continuation: ContinuationSeed | None = None, ) -> AsyncIterator[StreamOutput]: return self._dispatch_stream( request, input_tokens=input_tokens, request_id=request_id, response_model=response_model or request.model, reasoning=reasoning, endpoint_context=endpoint_context, request_headers=request_headers, continuation=continuation, ) async def _dispatch_stream( self, request: MessagesRequest, *, input_tokens: int, request_id: str | None, response_model: str, reasoning: ReasoningPolicy, endpoint_context: EndpointContext | None = None, request_headers: Mapping[str, str] | None = None, continuation: ContinuationSeed | None = None, ) -> AsyncIterator[StreamOutput]: snapshot = await self._catalog.snapshot(request_id=request_id) route = self._require_route(snapshot, request.model) routed = _routed_messages_request(request, route) selected_stream: AsyncIterator[StreamOutput] | None = None try: if route.transport is OpenCodeUpstreamTransport.RESPONSES: selected_stream = self._responses.stream_messages( routed, input_tokens=input_tokens, request_id=request_id, response_model=response_model, reasoning=reasoning, endpoint_context=endpoint_context, extra_headers=self._upstream_headers(request_headers or {}), model_info=route.model_info, continuation=continuation, ) else: selected_stream = self._chat.stream_messages( routed, input_tokens=input_tokens, request_id=request_id, response_model=response_model, reasoning=reasoning, endpoint_context=endpoint_context, extra_headers=self._upstream_headers(request_headers or {}), model_info=route.model_info, continuation=continuation, ) async for event in selected_stream: yield event finally: if selected_stream is not None: await close_provider_stream( selected_stream, active_error=sys.exception(), provider_name=self._opencode_profile.provider_name, request_id=request_id, ) def stream_chat( self, request: ChatRequest, input_tokens: int = 0, *, request_id: str | None = None, response_model: str | None = None, reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, endpoint_context: EndpointContext | None = None, request_headers: Mapping[str, str] | None = None, model_info: ProviderModelInfo | None = None, continuation: ContinuationSeed | None = None, ) -> AsyncIterator[StreamOutput]: return self._dispatch_openai_stream( request, input_tokens=input_tokens, request_id=request_id, response_model=response_model or request.model, reasoning=reasoning, endpoint_context=endpoint_context, request_headers=request_headers, continuation=continuation, ) def stream_gemini( self, request: GeminiRequest, input_tokens: int = 0, *, request_id: str | None = None, response_model: str | None = None, reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, endpoint_context: EndpointContext | None = None, request_headers: Mapping[str, str] | None = None, model_info: ProviderModelInfo | None = None, continuation: ContinuationSeed | None = None, ) -> AsyncIterator[StreamOutput]: return self._dispatch_openai_stream( request, input_tokens=input_tokens, request_id=request_id, response_model=response_model or request.model, reasoning=reasoning, endpoint_context=endpoint_context, request_headers=request_headers, continuation=continuation, ) def stream_responses( self, request: OpenAIResponsesRequest, input_tokens: int = 0, *, request_id: str | None = None, response_model: str | None = None, reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, endpoint_context: EndpointContext | None = None, request_headers: Mapping[str, str] | None = None, model_info: ProviderModelInfo | None = None, continuation: ContinuationSeed | None = None, ) -> AsyncIterator[StreamOutput]: return self._dispatch_openai_stream( request, input_tokens=input_tokens, request_id=request_id, response_model=response_model or request.model, reasoning=reasoning, endpoint_context=endpoint_context, request_headers=request_headers, continuation=continuation, ) async def _dispatch_openai_stream( self, request: OpenAIResponsesRequest | GeminiRequest | ChatRequest, *, input_tokens: int, request_id: str | None, response_model: str, reasoning: ReasoningPolicy, endpoint_context: EndpointContext | None = None, request_headers: Mapping[str, str] | None = None, continuation: ContinuationSeed | None = None, ) -> AsyncIterator[StreamOutput]: snapshot = await self._catalog.snapshot(request_id=request_id) route = self._require_route(snapshot, request.model) routed = request.model_copy( update={"model": route.upstream_model_id}, deep=True ) selected_stream: AsyncIterator[StreamOutput] | None = None try: if isinstance(routed, ChatRequest): transport = ( self._responses if route.transport is OpenCodeUpstreamTransport.RESPONSES else self._chat ) selected_stream = transport.stream_chat( routed, input_tokens=input_tokens, request_id=request_id, response_model=response_model, reasoning=reasoning, endpoint_context=endpoint_context, extra_headers=self._upstream_headers(request_headers or {}), continuation=continuation, ) elif isinstance(routed, GeminiRequest): transport = ( self._responses if route.transport is OpenCodeUpstreamTransport.RESPONSES else self._chat ) selected_stream = transport.stream_gemini( routed, input_tokens=input_tokens, request_id=request_id, response_model=response_model, reasoning=reasoning, endpoint_context=endpoint_context, extra_headers=self._upstream_headers(request_headers or {}), continuation=continuation, ) elif route.transport is OpenCodeUpstreamTransport.RESPONSES: selected_stream = self._responses.stream_responses( routed, input_tokens=input_tokens, request_id=request_id, response_model=response_model, reasoning=reasoning, endpoint_context=endpoint_context, extra_headers=self._upstream_headers(request_headers or {}), continuation=continuation, ) else: selected_stream = self._chat.stream_responses( routed, input_tokens=input_tokens, request_id=request_id, response_model=response_model, reasoning=reasoning, endpoint_context=endpoint_context, extra_headers=self._upstream_headers(request_headers or {}), continuation=continuation, ) async for event in selected_stream: yield event finally: if selected_stream is not None: await close_provider_stream( selected_stream, active_error=sys.exception(), provider_name=self._opencode_profile.provider_name, request_id=request_id, ) def _require_route( self, snapshot: OpenCodeCatalogSnapshot, selector_id: str, ) -> OpenCodeModelRoute: route = snapshot.route(selector_id) if route is not None: return route raise InvalidRequestError( f"{self._opencode_profile.provider_name} does not advertise " f"model {selector_id!r} in its active catalog." ) def create_opencode_provider( provider_id: str, config: ProviderConfig, admission: ProviderAdmissionController, history_cache: HistoryModeCache | None = None, *, catalog_client: httpx.AsyncClient | None = None, ) -> OpenCodeProvider: """Construct one catalog-aware OpenCode provider.""" profile = _PROFILES.get(provider_id) if profile is None: raise KeyError(f"No OpenCode profile for {provider_id!r}") return OpenCodeProvider( config, profile=profile, admission=admission, history_cache=history_cache, catalog_client=catalog_client, ) def _routed_messages_request( request: MessagesRequest, route: OpenCodeModelRoute, ) -> MessagesRequest: return request.model_copy( update={"model": route.upstream_model_id}, deep=True, )