1use crate::config::{Config, ProviderConfig, ProviderKind};
2use crate::error::{LiteLLMError, Result};
3use crate::providers::{anthropic, gemini, openai_compat};
4use crate::registry::Registry;
5use crate::router::{resolve_model, ResolvedModel};
6use crate::stream::ChatStream;
7use crate::types::{
8 ChatRequest, ChatResponse, EmbeddingRequest, EmbeddingResponse, ImageEditRequest, ImageRequest,
9 ImageResponse, VideoRequest, VideoResponse,
10};
11use reqwest::Client;
12
13#[derive(Debug, Clone)]
14pub struct LiteLLM {
15 config: Config,
16 client: Client,
17 registry: Registry,
18}
19
20impl LiteLLM {
21 pub fn new() -> Result<Self> {
22 let registry = Registry::load_embedded()?;
23 Ok(Self {
24 config: Config::default(),
25 client: Client::builder()
26 .timeout(std::time::Duration::from_secs(60))
27 .build()
28 .map_err(LiteLLMError::from)?,
29 registry,
30 })
31 }
32
33 pub fn with_default_provider(mut self, provider: impl Into<String>) -> Self {
34 self.config.default_provider = Some(provider.into());
35 self
36 }
37
38 pub fn with_provider(mut self, name: impl Into<String>, config: ProviderConfig) -> Self {
39 self.config.providers.insert(name.into(), config);
40 self
41 }
42
43 pub fn with_client(mut self, client: Client) -> Self {
44 self.client = client;
45 self
46 }
47
48 pub fn registry(&self) -> &Registry {
49 &self.registry
50 }
51
52 pub async fn completion(&self, mut req: ChatRequest) -> Result<ChatResponse> {
53 let resolved = resolve_model(&req.model, &self.config)?;
54 req.model = resolved.model.clone();
55 dispatch_chat(&self.client, resolved, req).await
56 }
57
58 pub async fn stream_completion(&self, mut req: ChatRequest) -> Result<ChatStream> {
59 let resolved = resolve_model(&req.model, &self.config)?;
60 req.model = resolved.model.clone();
61 match resolved.config.kind {
62 ProviderKind::OpenAICompatible => {
63 openai_compat::chat_stream(&self.client, &resolved.config, req).await
64 }
65 ProviderKind::OpenAIResponses => {
66 openai_compat::responses_chat_stream(&self.client, &resolved.config, req).await
67 }
68 ProviderKind::Anthropic => {
69 anthropic::chat_stream(&self.client, &resolved.config, req).await
70 }
71 _ => Err(LiteLLMError::Unsupported(
72 "streaming not supported for provider".into(),
73 )),
74 }
75 }
76
77 pub async fn embedding(&self, mut req: EmbeddingRequest) -> Result<EmbeddingResponse> {
78 let resolved = resolve_model(&req.model, &self.config)?;
79 req.model = resolved.model.clone();
80 match resolved.config.kind {
81 ProviderKind::OpenAICompatible => {
82 openai_compat::embeddings(&self.client, &resolved.config, req).await
83 }
84 ProviderKind::OpenAIResponses => Err(LiteLLMError::Unsupported(
85 "embeddings are not part of the Responses transport".into(),
86 )),
87 _ => Err(LiteLLMError::Unsupported(
88 "embeddings not supported for provider".into(),
89 )),
90 }
91 }
92
93 pub async fn image_generation(&self, mut req: ImageRequest) -> Result<ImageResponse> {
94 let resolved = resolve_model(&req.model, &self.config)?;
95 req.model = resolved.model.clone();
96 match resolved.config.kind {
97 ProviderKind::OpenAICompatible => {
98 openai_compat::image_generation(&self.client, &resolved.config, req).await
99 }
100 ProviderKind::OpenAIResponses => Err(LiteLLMError::Unsupported(
101 "image generation is not part of the Responses transport".into(),
102 )),
103 ProviderKind::Gemini => {
104 gemini::image_generation(&self.client, &resolved.config, req).await
105 }
106 _ => Err(LiteLLMError::Unsupported(
107 "image generation not supported for provider".into(),
108 )),
109 }
110 }
111
112 pub async fn image_editing(&self, mut req: ImageEditRequest) -> Result<ImageResponse> {
113 let resolved = resolve_model(&req.model, &self.config)?;
114 req.model = resolved.model.clone();
115 match resolved.config.kind {
116 ProviderKind::OpenAICompatible | ProviderKind::OpenAIResponses => Err(
117 LiteLLMError::Unsupported("image editing not supported for provider".into()),
118 ),
119 ProviderKind::Gemini => {
120 gemini::image_editing(&self.client, &resolved.config, req).await
121 }
122 _ => Err(LiteLLMError::Unsupported(
123 "image editing not supported for provider".into(),
124 )),
125 }
126 }
127
128 pub async fn video_generation(&self, mut req: VideoRequest) -> Result<VideoResponse> {
129 let resolved = resolve_model(&req.model, &self.config)?;
130 req.model = resolved.model.clone();
131 match resolved.config.kind {
132 ProviderKind::OpenAICompatible => {
133 openai_compat::video_generation(&self.client, &resolved.config, req).await
134 }
135 ProviderKind::OpenAIResponses => Err(LiteLLMError::Unsupported(
136 "video generation is not part of the Responses transport".into(),
137 )),
138 ProviderKind::Gemini => {
139 gemini::video_generation(&self.client, &resolved.config, req).await
140 }
141 _ => Err(LiteLLMError::Unsupported(
142 "video generation not supported for provider".into(),
143 )),
144 }
145 }
146
147 pub fn estimate_cost(&self, model: &str, input_tokens: u32, output_tokens: u32) -> Option<f64> {
148 self.registry
149 .estimate_cost(model, input_tokens, output_tokens)
150 }
151}
152
153async fn dispatch_chat(
154 client: &Client,
155 resolved: ResolvedModel,
156 req: ChatRequest,
157) -> Result<ChatResponse> {
158 match resolved.config.kind {
159 ProviderKind::OpenAICompatible => openai_compat::chat(client, &resolved.config, req).await,
160 ProviderKind::OpenAIResponses => {
161 openai_compat::responses_chat(client, &resolved.config, req).await
162 }
163 ProviderKind::Anthropic => anthropic::chat(client, &resolved.config, req).await,
164 ProviderKind::Gemini => gemini::chat(client, &resolved.config, req).await,
165 }
166}