acosmi/models/adapters/
mod.rs1pub mod anthropic;
22pub mod openai;
23
24use super::types::{ChatRequest, ChatResponse, ManagedModel, ModelCapabilities, StreamEvent};
25use crate::shared::errors::Result;
26use serde_json::{Map, Value};
27
28#[derive(Debug, Clone, Copy, PartialEq, Eq)]
30#[repr(i32)]
31pub enum ProviderFormat {
32 Anthropic = 0,
34 OpenAI = 1,
36}
37
38#[derive(Debug, Clone, Copy, PartialEq, Eq)]
41pub enum Adapter {
42 Anthropic,
44 OpenAI,
46}
47
48impl Adapter {
49 pub fn format(&self) -> ProviderFormat {
51 match self {
52 Adapter::Anthropic => ProviderFormat::Anthropic,
53 Adapter::OpenAI => ProviderFormat::OpenAI,
54 }
55 }
56
57 pub fn endpoint_suffix(&self) -> &'static str {
59 match self {
60 Adapter::Anthropic => "/anthropic",
61 Adapter::OpenAI => "/chat",
62 }
63 }
64
65 pub fn build_request_body(
67 &self,
68 caps: &ModelCapabilities,
69 req: &ChatRequest,
70 ) -> Map<String, Value> {
71 match self {
72 Adapter::Anthropic => anthropic::build_request_body(caps, req),
73 Adapter::OpenAI => openai::build_request_body(caps, req),
74 }
75 }
76
77 pub fn parse_response(&self, body: &[u8]) -> Result<ChatResponse> {
79 match self {
80 Adapter::Anthropic => anthropic::parse_response(body),
81 Adapter::OpenAI => openai::parse_response(body),
82 }
83 }
84
85 pub fn parse_stream_line(&self, event_type: &str, data: &str) -> Result<(StreamEvent, bool)> {
88 match self {
89 Adapter::Anthropic => Ok(anthropic::parse_stream_line(event_type, data)),
90 Adapter::OpenAI => openai::parse_stream_line(event_type, data),
91 }
92 }
93}
94
95pub fn get_adapter(provider: &str) -> Adapter {
100 match provider.to_lowercase().as_str() {
101 "anthropic" | "acosmi" => Adapter::Anthropic,
102 _ => Adapter::OpenAI,
103 }
104}
105
106pub fn get_adapter_for_model(m: &ManagedModel) -> Adapter {
127 let mut has_anthropic = false;
128 let mut has_openai = false;
129 if let Some(formats) = &m.supported_formats {
130 for f in formats {
131 match f.trim().to_lowercase().as_str() {
132 "anthropic" => has_anthropic = true,
133 "openai" => has_openai = true,
134 _ => {}
135 }
136 }
137 }
138 let declared = has_anthropic || has_openai;
139
140 let pref = m
141 .preferred_format
142 .as_deref()
143 .unwrap_or("")
144 .trim()
145 .to_lowercase();
146 match pref.as_str() {
148 "anthropic" if !declared || has_anthropic => return Adapter::Anthropic,
149 "openai" if !declared || has_openai => return Adapter::OpenAI,
150 _ => {}
151 }
152
153 if has_anthropic {
154 return Adapter::Anthropic;
155 }
156 if has_openai {
157 return Adapter::OpenAI;
158 }
159
160 get_adapter(&m.provider.to_lowercase())
162}
163
164#[cfg(test)]
165mod tests {
166 use super::*;
167
168 fn model(
169 provider: &str,
170 supported: Option<Vec<&str>>,
171 preferred: Option<&str>,
172 ) -> ManagedModel {
173 ManagedModel {
174 provider: provider.to_string(),
175 supported_formats: supported.map(|v| v.iter().map(|s| s.to_string()).collect()),
176 preferred_format: preferred.map(|s| s.to_string()),
177 ..Default::default()
178 }
179 }
180
181 #[test]
182 fn route_preferred_anthropic_supported() {
183 let m = model(
184 "deepseek",
185 Some(vec!["anthropic", "openai"]),
186 Some("anthropic"),
187 );
188 assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
189 }
190
191 #[test]
192 fn route_preferred_conflicts_supported_falls_through() {
193 let m = model("acosmi", Some(vec!["openai"]), Some("anthropic"));
195 assert_eq!(get_adapter_for_model(&m), Adapter::OpenAI);
196 }
197
198 #[test]
199 fn route_preferred_openai_conflicts_falls_through() {
200 let m = model("anthropic", Some(vec!["anthropic"]), Some("openai"));
201 assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
202 }
203
204 #[test]
205 fn route_preferred_when_supported_undeclared_is_trusted() {
206 let m = model("deepseek", None, Some("anthropic"));
208 assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
209 }
210
211 #[test]
212 fn route_supported_only_anthropic() {
213 let m = model("deepseek", Some(vec!["anthropic"]), None);
214 assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
215 }
216
217 #[test]
218 fn route_fallback_to_provider_name() {
219 assert_eq!(
221 get_adapter_for_model(&model("anthropic", None, None)),
222 Adapter::Anthropic
223 );
224 assert_eq!(
225 get_adapter_for_model(&model("acosmi", None, None)),
226 Adapter::Anthropic
227 );
228 assert_eq!(
229 get_adapter_for_model(&model("deepseek", None, None)),
230 Adapter::OpenAI
231 );
232 }
233
234 #[test]
235 fn endpoint_suffix_and_format() {
236 assert_eq!(Adapter::Anthropic.endpoint_suffix(), "/anthropic");
237 assert_eq!(Adapter::OpenAI.endpoint_suffix(), "/chat");
238 assert_eq!(Adapter::Anthropic.format(), ProviderFormat::Anthropic);
239 assert_eq!(Adapter::OpenAI.format(), ProviderFormat::OpenAI);
240 }
241}