pub mod anthropic;
pub mod openai;
use super::types::{ChatRequest, ChatResponse, ManagedModel, ModelCapabilities, StreamEvent};
use crate::shared::errors::Result;
use serde_json::{Map, Value};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(i32)]
pub enum ProviderFormat {
Anthropic = 0,
OpenAI = 1,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Adapter {
Anthropic,
OpenAI,
}
impl Adapter {
pub fn format(&self) -> ProviderFormat {
match self {
Adapter::Anthropic => ProviderFormat::Anthropic,
Adapter::OpenAI => ProviderFormat::OpenAI,
}
}
pub fn endpoint_suffix(&self) -> &'static str {
match self {
Adapter::Anthropic => "/anthropic",
Adapter::OpenAI => "/chat",
}
}
pub fn build_request_body(
&self,
caps: &ModelCapabilities,
req: &ChatRequest,
) -> Map<String, Value> {
match self {
Adapter::Anthropic => anthropic::build_request_body(caps, req),
Adapter::OpenAI => openai::build_request_body(caps, req),
}
}
pub fn parse_response(&self, body: &[u8]) -> Result<ChatResponse> {
match self {
Adapter::Anthropic => anthropic::parse_response(body),
Adapter::OpenAI => openai::parse_response(body),
}
}
pub fn parse_stream_line(&self, event_type: &str, data: &str) -> Result<(StreamEvent, bool)> {
match self {
Adapter::Anthropic => Ok(anthropic::parse_stream_line(event_type, data)),
Adapter::OpenAI => openai::parse_stream_line(event_type, data),
}
}
}
pub fn get_adapter(provider: &str) -> Adapter {
match provider.to_lowercase().as_str() {
"anthropic" | "acosmi" => Adapter::Anthropic,
_ => Adapter::OpenAI,
}
}
pub fn get_adapter_for_model(m: &ManagedModel) -> Adapter {
let mut has_anthropic = false;
let mut has_openai = false;
if let Some(formats) = &m.supported_formats {
for f in formats {
match f.trim().to_lowercase().as_str() {
"anthropic" => has_anthropic = true,
"openai" => has_openai = true,
_ => {}
}
}
}
let declared = has_anthropic || has_openai;
let pref = m
.preferred_format
.as_deref()
.unwrap_or("")
.trim()
.to_lowercase();
match pref.as_str() {
"anthropic" if !declared || has_anthropic => return Adapter::Anthropic,
"openai" if !declared || has_openai => return Adapter::OpenAI,
_ => {}
}
if has_anthropic {
return Adapter::Anthropic;
}
if has_openai {
return Adapter::OpenAI;
}
get_adapter(&m.provider.to_lowercase())
}
#[cfg(test)]
mod tests {
use super::*;
fn model(
provider: &str,
supported: Option<Vec<&str>>,
preferred: Option<&str>,
) -> ManagedModel {
ManagedModel {
provider: provider.to_string(),
supported_formats: supported.map(|v| v.iter().map(|s| s.to_string()).collect()),
preferred_format: preferred.map(|s| s.to_string()),
..Default::default()
}
}
#[test]
fn route_preferred_anthropic_supported() {
let m = model(
"deepseek",
Some(vec!["anthropic", "openai"]),
Some("anthropic"),
);
assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
}
#[test]
fn route_preferred_conflicts_supported_falls_through() {
let m = model("acosmi", Some(vec!["openai"]), Some("anthropic"));
assert_eq!(get_adapter_for_model(&m), Adapter::OpenAI);
}
#[test]
fn route_preferred_openai_conflicts_falls_through() {
let m = model("anthropic", Some(vec!["anthropic"]), Some("openai"));
assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
}
#[test]
fn route_preferred_when_supported_undeclared_is_trusted() {
let m = model("deepseek", None, Some("anthropic"));
assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
}
#[test]
fn route_supported_only_anthropic() {
let m = model("deepseek", Some(vec!["anthropic"]), None);
assert_eq!(get_adapter_for_model(&m), Adapter::Anthropic);
}
#[test]
fn route_fallback_to_provider_name() {
assert_eq!(
get_adapter_for_model(&model("anthropic", None, None)),
Adapter::Anthropic
);
assert_eq!(
get_adapter_for_model(&model("acosmi", None, None)),
Adapter::Anthropic
);
assert_eq!(
get_adapter_for_model(&model("deepseek", None, None)),
Adapter::OpenAI
);
}
#[test]
fn endpoint_suffix_and_format() {
assert_eq!(Adapter::Anthropic.endpoint_suffix(), "/anthropic");
assert_eq!(Adapter::OpenAI.endpoint_suffix(), "/chat");
assert_eq!(Adapter::Anthropic.format(), ProviderFormat::Anthropic);
assert_eq!(Adapter::OpenAI.format(), ProviderFormat::OpenAI);
}
}