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

1"""Every model service that speaks OpenAI's chat interface, read through one adapter. 

2 

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.""" 

7 

8import logging 

9from collections.abc import Callable 

10from dataclasses import dataclass 

11from functools import partial 

12 

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 

27 

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 

32 

33from .pydantic_ai import PydanticAIDecoder, reading_agent 

34from .registry import DecoderFactory, ManagedDecoder 

35from .transport import DiagnosticHTTPTransport 

36 

37log = logging.getLogger(__name__) 

38 

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) 

41 

42 

43@dataclass(frozen=True) 

44class Service: 

45 endpoint: str | None 

46 provider: Callable[[AsyncOpenAI], Provider[AsyncOpenAI]] 

47 profile: ModelProfileSpec | None = None 

48 

49 

50def _openai(client: AsyncOpenAI) -> Provider[AsyncOpenAI]: 

51 return OpenAIProvider(openai_client=client) 

52 

53 

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} 

81 

82 

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 

88 

89 

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 ) 

101 

102 

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) 

106 

107 

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 ) 

128 

129 

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 

153 

154 

155def factories() -> dict[ModelProvider, DecoderFactory]: 

156 return {name: partial(create_decoder, name) for name in SERVICES}