Coverage for src/copytrading_engine/parsing/providers/openai_compatible.py: 97%
61 statements
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
1"""Every model service that speaks OpenAI's chat interface, read through one adapter.
3Each named service has its own address and, where PydanticAI knows the service, its own provider
4class, which carries that service's model quirks (which token limit field it takes, which settings
5a reasoning model refuses). The answer is asked for as JSON in the prompt, the one output mode
6every chat model supports; the worker still validates and grounds it like any other answer."""
8import logging
9from collections.abc import Callable
10from dataclasses import dataclass
11from functools import partial
13import httpx2 as httpx
14from openai import APIConnectionError, AsyncOpenAI
15from pydantic_ai import Agent, PromptedOutput
16from pydantic_ai.models.openai import OpenAIChatModel
17from pydantic_ai.profiles import ModelProfileSpec
18from pydantic_ai.profiles.openai import OpenAIModelProfile
19from pydantic_ai.providers import Provider
20from pydantic_ai.providers.cerebras import CerebrasProvider
21from pydantic_ai.providers.fireworks import FireworksProvider
22from pydantic_ai.providers.moonshotai import MoonshotAIProvider
23from pydantic_ai.providers.ollama import OllamaProvider
24from pydantic_ai.providers.openai import OpenAIProvider
25from pydantic_ai.providers.openrouter import OpenRouterProvider
26from pydantic_ai.providers.together import TogetherProvider
28from copytrading_engine.parsing.learning import LEARN_INSTRUCTIONS, PlaybookProposal
29from copytrading_engine.shared.cleanup import close_logged
30from copytrading_engine.shared.model_providers import OLLAMA_ENDPOINT, ModelProvider, ProviderConfig
31from copytrading_engine.shared.payload_capture import PayloadCapture
33from .pydantic_ai import PydanticAIDecoder, reading_agent
34from .registry import DecoderFactory, ManagedDecoder
35from .transport import DiagnosticHTTPTransport
37log = logging.getLogger(__name__)
39# Services whose chat endpoint takes `max_tokens` but not OpenAI's `max_completion_tokens`.
40_MAX_TOKENS_ONLY = OpenAIModelProfile(openai_chat_supports_max_completion_tokens=False)
43@dataclass(frozen=True)
44class Service:
45 endpoint: str | None
46 provider: Callable[[AsyncOpenAI], Provider[AsyncOpenAI]]
47 profile: ModelProfileSpec | None = None
50def _openai(client: AsyncOpenAI) -> Provider[AsyncOpenAI]:
51 return OpenAIProvider(openai_client=client)
54SERVICES: dict[ModelProvider, Service] = {
55 "openai": Service("https://api.openai.com/v1", _openai),
56 "google": Service(
57 "https://generativelanguage.googleapis.com/v1beta/openai/", _openai, _MAX_TOKENS_ONLY
58 ),
59 "openrouter": Service(
60 "https://openrouter.ai/api/v1", lambda client: OpenRouterProvider(openai_client=client)
61 ),
62 "groq": Service("https://api.groq.com/openai/v1", _openai),
63 "xai": Service("https://api.x.ai/v1", _openai),
64 "mistral": Service("https://api.mistral.ai/v1", _openai, _MAX_TOKENS_ONLY),
65 "together": Service(
66 "https://api.together.xyz/v1", lambda client: TogetherProvider(openai_client=client)
67 ),
68 "fireworks": Service(
69 "https://api.fireworks.ai/inference/v1",
70 lambda client: FireworksProvider(openai_client=client),
71 ),
72 "cerebras": Service(
73 "https://api.cerebras.ai/v1", lambda client: CerebrasProvider(openai_client=client)
74 ),
75 "moonshotai": Service(
76 "https://api.moonshot.ai/v1", lambda client: MoonshotAIProvider(openai_client=client)
77 ),
78 "ollama": Service(OLLAMA_ENDPOINT, lambda client: OllamaProvider(openai_client=client)),
79 "openai_compatible": Service(None, _openai),
80}
83def _endpoint(service: Service, config: ProviderConfig) -> str:
84 endpoint = config.base_url or service.endpoint
85 if endpoint is None:
86 raise ValueError("A custom OpenAI-compatible model needs its address")
87 return endpoint
90def client(
91 service: Service, config: ProviderConfig, http_client: httpx.AsyncClient | None = None
92) -> AsyncOpenAI:
93 return AsyncOpenAI(
94 # A local model may take no key; the client still needs a value to send.
95 api_key=config.api_key.get_secret_value() or "none",
96 base_url=_endpoint(service, config),
97 max_retries=0,
98 timeout=config.timeout,
99 http_client=http_client,
100 )
103def chat_model(service: Service, config: ProviderConfig, client: AsyncOpenAI) -> OpenAIChatModel:
104 """The model the decoder reads with, which the assistant also chats with."""
105 return OpenAIChatModel(config.model, provider=service.provider(client), profile=service.profile)
108def build_decoder(
109 service: Service, config: ProviderConfig, client: AsyncOpenAI
110) -> PydanticAIDecoder:
111 model = chat_model(service, config, client)
112 agent = reading_agent(
113 model,
114 {"temperature": 0, "max_tokens": 3000},
115 )
116 learner = Agent(
117 model,
118 output_type=PromptedOutput(PlaybookProposal),
119 name="playbook_learner",
120 instructions=LEARN_INSTRUCTIONS,
121 retries=1,
122 # A long free-form draft can loop at temperature 0; a little temperature keeps it moving.
123 model_settings={"temperature": 0.2, "max_tokens": 8000},
124 )
125 return PydanticAIDecoder(
126 agent, learner, client, config.timeout, connection_errors=(APIConnectionError,)
127 )
130async def create_decoder(
131 name: ModelProvider,
132 config: ProviderConfig,
133 *,
134 diagnostics: PayloadCapture | None = None,
135) -> ManagedDecoder:
136 service = SERVICES[name]
137 _endpoint(service, config)
138 http_client = None
139 if diagnostics is not None: 139 ↛ 140line 139 didn't jump to line 140 because the condition on line 139 was never true
140 http_client = httpx.AsyncClient(
141 transport=DiagnosticHTTPTransport(
142 httpx.AsyncHTTPTransport(retries=0), diagnostics, provider=name
143 ),
144 timeout=config.timeout,
145 follow_redirects=False,
146 )
147 opened = client(service, config, http_client)
148 try:
149 return build_decoder(service, config, opened)
150 except BaseException:
151 await close_logged(opened.close, resource="provider_client", log=log)
152 raise
155def factories() -> dict[ModelProvider, DecoderFactory]:
156 return {name: partial(create_decoder, name) for name in SERVICES}