Merge pull request #41690 from BerriAI/litellm_extract_providers

refactor(rust): extract provider translations

litellm-rust/Cargo.lock

@@ -2016,6 +2016,7 @@ dependencies = [
  "litellm-auth-azure",
  "litellm-auth-gcp",
  "litellm-framing",
+ "litellm-providers",
  "mime_guess",
  "moka",
  "rand 0.8.7",
@@ -2052,6 +2053,18 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "litellm-providers"
+version = "0.1.0"
+dependencies = [
+ "litellm-auth",
+ "litellm-auth-aws",
+ "rstest",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.19",
+]
+
 [[package]]
 name = "litellm-python-bridge"
 version = "0.1.0"

litellm-rust/Cargo.toml

@@ -16,6 +16,7 @@ litellm-auth = { path = "crates/auth" }
 litellm-auth-aws = { path = "crates/auth-aws" }
 litellm-auth-azure = { path = "crates/auth-azure" }
 litellm-auth-gcp = { path = "crates/auth-gcp" }
+litellm-providers = { path = "crates/providers" }
 litellm-cache = { path = "crates/cache" }
 litellm-cache-memory = { path = "crates/cache-memory" }
 litellm-token-counter = { path = "crates/token-counter" }

litellm-rust/crates/core/Cargo.toml

@@ -15,6 +15,7 @@ litellm-auth.workspace = true
 litellm-auth-aws.workspace = true
 litellm-auth-azure.workspace = true
 litellm-auth-gcp.workspace = true
+litellm-providers.workspace = true
 litellm-framing.workspace = true
 moka.workspace = true
 mime_guess = "2.0.5"

litellm-rust/crates/core/src/audio_transcription/error.rs

@@ -24,3 +24,23 @@ pub enum Error {
     #[error(transparent)]
     Aws(#[from] litellm_auth_aws::Error),
 }
+
+impl From<litellm_providers::audio_transcription::Error> for Error {
+    fn from(error: litellm_providers::audio_transcription::Error) -> Self {
+        match error {
+            litellm_providers::audio_transcription::Error::InvalidType { expected, actual } => {
+                Self::InvalidType { expected, actual }
+            }
+            litellm_providers::audio_transcription::Error::MissingField(field) => {
+                Self::MissingField(field)
+            }
+            litellm_providers::audio_transcription::Error::InvalidRequest(message) => {
+                Self::InvalidRequest(message)
+            }
+            litellm_providers::audio_transcription::Error::InvalidResponse(message) => {
+                Self::InvalidResponse(message)
+            }
+            litellm_providers::audio_transcription::Error::Auth(error) => Self::Auth(error),
+        }
+    }
+}

litellm-rust/crates/core/src/audio_transcription/handler.rs

@@ -47,8 +47,8 @@ async fn signed_headers(
     use std::collections::BTreeMap;
     use std::time::SystemTime;
 
-    use crate::llms::base_llm::audio_transcription::transformation::AudioTranscriptionAuth;
     use litellm_auth_aws::{aws_auth_config, resolve_credentials, sign_bedrock_post};
+    use litellm_providers::base_llm::audio_transcription::transformation::AudioTranscriptionAuth;
 
     let AudioTranscriptionAuth::AwsSigV4 { region, .. } = &request.auth else {
         return Ok(request.upstream_headers.clone());

litellm-rust/crates/core/src/audio_transcription/mod.rs

@@ -3,7 +3,7 @@ pub use error::Error;
 mod client;
 mod handler;
 mod prepare;
-pub mod types;
+pub use litellm_providers::audio_transcription::types;
 
 pub use handler::execute_audio_transcription_provider_call;
 pub use prepare::prepare_audio_transcription_provider_call;

litellm-rust/crates/core/src/audio_transcription/prepare.rs

@@ -4,10 +4,10 @@ use crate::http_utils::{has_header, string_headers};
 use crate::litellm_core_utils::get_llm_provider_logic::{
     CustomLlmProvider, get_custom_llm_provider,
 };
-use crate::llms::base_llm::audio_transcription::transformation::{
+use litellm_providers::base_llm::audio_transcription::transformation::{
     AudioTranscriptionAuth, BaseAudioTranscriptionConfig,
 };
-use crate::llms::bedrock::audio_transcription::BEDROCK_AUDIO_TRANSCRIPTION_CONFIG;
+use litellm_providers::bedrock::audio_transcription::BEDROCK_AUDIO_TRANSCRIPTION_CONFIG;
 
 fn provider_config(provider: &str) -> Option<&'static dyn BaseAudioTranscriptionConfig> {
     if provider == "bedrock" {

litellm-rust/crates/core/src/chat_completions/common_utils.rs

@@ -2,8 +2,8 @@ use serde_json::{Map, Value};
 
 use super::Error;
 use crate::http_utils::string_headers as shared_string_headers;
-use crate::llms::anthropic::chat::transformation::ANTHROPIC_CHAT_COMPLETIONS_CONFIG;
-use crate::llms::base_llm::chat::transformation::BaseConfig;
+use litellm_providers::anthropic::chat::transformation::ANTHROPIC_CHAT_COMPLETIONS_CONFIG;
+use litellm_providers::base_llm::chat::transformation::BaseConfig;
 
 const HEADER_CONTEXT: &str = "chat completions";
 
@@ -11,7 +11,7 @@ pub(super) fn chat_completions_provider_config(provider: &str) -> Option<&'stati
     match provider {
         "anthropic" => Some(&ANTHROPIC_CHAT_COMPLETIONS_CONFIG),
         "bedrock" => Some(
-            &crate::llms::bedrock::chat::converse_transformation::BEDROCK_CHAT_COMPLETIONS_CONFIG,
+            &litellm_providers::bedrock::chat::converse_transformation::BEDROCK_CHAT_COMPLETIONS_CONFIG,
         ),
         _ => None,
     }

litellm-rust/crates/core/src/chat_completions/error.rs

@@ -24,3 +24,19 @@ pub enum Error {
     #[error(transparent)]
     Aws(#[from] litellm_auth_aws::Error),
 }
+
+impl From<litellm_providers::chat::Error> for Error {
+    fn from(error: litellm_providers::chat::Error) -> Self {
+        match error {
+            litellm_providers::chat::Error::MissingField(field) => Self::MissingField(field),
+            litellm_providers::chat::Error::InvalidRequest(message) => {
+                Self::InvalidRequest(message)
+            }
+            litellm_providers::chat::Error::InvalidResponse(message) => {
+                Self::InvalidResponse(message)
+            }
+            litellm_providers::chat::Error::Unsupported(reason) => Self::Unsupported(reason),
+            litellm_providers::chat::Error::Auth(error) => Self::Auth(error),
+        }
+    }
+}

litellm-rust/crates/core/src/chat_completions/handler.rs

@@ -8,7 +8,7 @@ use super::types::{
     ResolvedChatCompletionsRequest,
 };
 use crate::http_utils::{http_request, truncate_error_body};
-use crate::llms::base_llm::chat::transformation::ChatCompletionsAuth;
+use litellm_providers::base_llm::chat::transformation::ChatCompletionsAuth;
 
 pub(super) async fn execute_chat_completions_provider_call(
     request: ResolvedChatCompletionsRequest<'_>,
@@ -59,6 +59,7 @@ pub(super) async fn execute_chat_completions_provider_call(
     request
         .config
         .transform_response(&request.model, ProviderChatResponseData { body })
+        .map_err(Error::from)
         .map_err(as_response_error)
 }
 

litellm-rust/crates/core/src/chat_completions/mod.rs

@@ -10,12 +10,11 @@ mod error;
 pub use error::Error;
 mod client;
 mod common_utils;
-pub mod conversation;
+pub use litellm_providers::chat::{conversation, response_utils};
 pub(crate) mod handler;
 mod prepare;
-pub mod response_utils;
 pub mod streaming;
-pub mod types;
+pub use litellm_providers::chat::types;
 
 use handler::execute_chat_completions_provider_call;
 use prepare::{parse_messages, resolve_provider_config, resolve_request};

litellm-rust/crates/core/src/chat_completions/prepare.rs

@@ -10,7 +10,7 @@ use crate::http_utils::has_header;
 use crate::litellm_core_utils::get_llm_provider_logic::{
     CustomLlmProvider, get_custom_llm_provider,
 };
-use crate::llms::base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth};
+use litellm_providers::base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth};
 
 pub(super) fn resolve_provider_config<'a>(
     model: &'a str,

litellm-rust/crates/core/src/chat_completions/tests.rs

@@ -3,7 +3,7 @@ use serde_json::{Map, Value, json};
 use super::Error;
 use super::prepare::{prepare_provider_request, resolve_request};
 use super::types::{ChatCompletionsRequest, ProviderChatCompletionsRequest};
-use crate::llms::base_llm::chat::transformation::ChatCompletionsAuth;
+use litellm_providers::base_llm::chat::transformation::ChatCompletionsAuth;
 
 fn prepare_chat_completions_call(
     request: ChatCompletionsRequest<'_>,

litellm-rust/crates/core/src/litellm_core_utils/get_llm_provider_logic.rs

@@ -1,36 +1,4 @@
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct CustomLlmProvider<'a> {
-    pub model: &'a str,
-    pub custom_llm_provider: &'a str,
-}
-
-pub fn get_custom_llm_provider<'a>(
-    model: &'a str,
-    custom_llm_provider: Option<&'a str>,
-) -> Option<CustomLlmProvider<'a>> {
-    if let Some(custom_llm_provider) = custom_llm_provider.filter(|provider| !provider.is_empty()) {
-        return Some(CustomLlmProvider {
-            model: strip_custom_llm_provider_prefix(model, custom_llm_provider),
-            custom_llm_provider,
-        });
-    }
-
-    let (custom_llm_provider, model) = model.split_once('/')?;
-    if custom_llm_provider.is_empty() || model.is_empty() {
-        return None;
-    }
-    Some(CustomLlmProvider {
-        model,
-        custom_llm_provider,
-    })
-}
-
-fn strip_custom_llm_provider_prefix<'a>(model: &'a str, custom_llm_provider: &str) -> &'a str {
-    model
-        .strip_prefix(custom_llm_provider)
-        .and_then(|model| model.strip_prefix('/'))
-        .unwrap_or(model)
-}
+pub use litellm_providers::provider_resolution::{CustomLlmProvider, get_custom_llm_provider};
 
 #[cfg(test)]
 mod tests {

litellm-rust/crates/core/src/llms/anthropic/chat/mod.rs

@@ -1,2 +1 @@
 pub mod streaming;
-pub mod transformation;

litellm-rust/crates/core/src/llms/anthropic/chat/streaming.rs

@@ -2,16 +2,16 @@ use std::collections::HashMap;
 
 use serde_json::Value;
 
+use super::super::experimental_pass_through::messages::streaming::{
+    AnthropicContentBlock, AnthropicContentBlockDelta, AnthropicMessagesStreamEvent,
+    AnthropicStreamUsage,
+};
 use crate::chat_completions::Error;
 use crate::chat_completions::streaming::StreamTransformer;
 use crate::chat_completions::types::{
     ChatCompletionChunk, ChatCompletionThinkingBlock, ChatCompletionToolCallChunk,
     ChatCompletionsUsage,
 };
-use crate::llms::anthropic::experimental_pass_through::messages::streaming::{
-    AnthropicContentBlock, AnthropicContentBlockDelta, AnthropicMessagesStreamEvent,
-    AnthropicStreamUsage,
-};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum AnthropicJsonChunkType {

litellm-rust/crates/core/src/llms/anthropic/experimental_pass_through/messages/batches.rs

@@ -3,9 +3,9 @@ use serde_json::Value;
 use time::OffsetDateTime;
 use url::Url;
 
-use crate::llms::anthropic::experimental_pass_through::messages::transformation::resolve_anthropic_api_base;
 use crate::messages::Error;
 use crate::messages::types::AnthropicMessagesResponse;
+use litellm_providers::anthropic::experimental_pass_through::messages::transformation::resolve_anthropic_api_base;
 
 const BATCHES_PATH_SUFFIX: &str = "/v1/messages/batches";
 

litellm-rust/crates/core/src/llms/anthropic/experimental_pass_through/messages/mod.rs

@@ -1,4 +1,3 @@
 pub mod batches;
 pub mod count_tokens;
 pub mod streaming;
-pub mod transformation;

litellm-rust/crates/core/src/llms/azure_ai/mod.rs

@@ -1,2 +1 @@
-pub mod anthropic;
 pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/base_llm/mod.rs

@@ -1,4 +1 @@
-pub mod anthropic_messages;
-pub mod audio_transcription;
-pub mod chat;
 pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/mod.rs

@@ -1,7 +1,6 @@
 pub mod anthropic;
 pub mod azure_ai;
 pub mod base_llm;
-pub mod bedrock;
 pub(crate) mod cohere;
 pub(crate) mod mistral;
 pub mod openai;

litellm-rust/crates/core/src/messages/common_utils.rs

@@ -3,9 +3,9 @@ use serde_json::{Map, Value};
 use super::Error;
 use crate::http_utils::string_headers as shared_string_headers;
 pub(super) use crate::http_utils::{has_bearer_auth, has_header, truncate_error_body};
-use crate::llms::anthropic::experimental_pass_through::messages::transformation::ANTHROPIC_MESSAGES_CONFIG;
-use crate::llms::azure_ai::anthropic::messages_transformation::AZURE_ANTHROPIC_MESSAGES_CONFIG;
-use crate::llms::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
+use litellm_providers::anthropic::experimental_pass_through::messages::transformation::ANTHROPIC_MESSAGES_CONFIG;
+use litellm_providers::azure_ai::anthropic::messages_transformation::AZURE_ANTHROPIC_MESSAGES_CONFIG;
+use litellm_providers::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
 
 const HEADER_CONTEXT: &str = "messages";
 

litellm-rust/crates/core/src/messages/error.rs

@@ -28,6 +28,22 @@ pub enum Error {
     InvalidBedrockBase64(String),
 }
 
+impl From<litellm_providers::messages::Error> for Error {
+    fn from(error: litellm_providers::messages::Error) -> Self {
+        match error {
+            litellm_providers::messages::Error::MissingField(field) => Self::MissingField(field),
+            litellm_providers::messages::Error::InvalidRequest(message) => {
+                Self::InvalidRequest(message)
+            }
+            litellm_providers::messages::Error::InvalidResponse(message) => {
+                Self::InvalidResponse(message)
+            }
+            litellm_providers::messages::Error::Unsupported(reason) => Self::Unsupported(reason),
+            litellm_providers::messages::Error::Auth(error) => Self::Auth(error),
+        }
+    }
+}
+
 impl Error {
     pub fn is_request(&self) -> bool {
         match self {

litellm-rust/crates/core/src/messages/handler.rs

@@ -40,6 +40,7 @@ pub(super) async fn execute_messages_provider_call(
     request
         .config
         .transform_anthropic_messages_response(&request.model, response)
+        .map_err(Error::from)
 }
 
 pub(super) async fn execute_messages_provider_stream(

litellm-rust/crates/core/src/messages/mod.rs

@@ -13,7 +13,7 @@ mod client;
 mod common_utils;
 mod handler;
 mod prepare;
-pub mod types;
+pub use litellm_providers::messages::types;
 
 use handler::{execute_messages_provider_call, execute_messages_provider_stream};
 use types::{AnthropicMessagesResponse, MessagesRequest};

litellm-rust/crates/core/src/messages/prepare.rs

@@ -6,7 +6,7 @@ use super::types::{MessagesRequest, ProviderMessagesRequest};
 use crate::litellm_core_utils::get_llm_provider_logic::{
     CustomLlmProvider, get_custom_llm_provider,
 };
-use crate::llms::base_llm::anthropic_messages::transformation::{
+use litellm_providers::base_llm::anthropic_messages::transformation::{
     BaseAnthropicMessagesConfig, MessagesAuthStrategy,
 };
 

litellm-rust/crates/providers/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "litellm-providers"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+litellm-auth.workspace = true
+litellm-auth-aws.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
+
+[dev-dependencies]
+rstest.workspace = true

litellm-rust/crates/providers/src/anthropic/chat/tests.rs

@@ -1,7 +1,7 @@
 use serde_json::json;
 
 use super::*;
-use crate::chat_completions::Error;
+use crate::chat::Error;
 
 fn messages(value: Value) -> Vec<ChatMessage> {
     serde_json::from_value(value).expect("valid messages")

litellm-rust/crates/providers/src/anthropic/chat/transformation.rs

@@ -1,19 +1,19 @@
 use serde_json::{Map, Value, json};
 
-use crate::chat_completions::Error;
-use crate::chat_completions::conversation::{Conversation, build_conversation};
-use crate::chat_completions::response_utils::{finish_reason_for, unix_now, usage_from_parts};
-use crate::chat_completions::types::{
-    ChatCompletionsChoice, ChatCompletionsChoiceMessage, ChatCompletionsResponse, ChatMessage,
-    ProviderChatRequestData, ProviderChatResponseData,
-};
-use crate::constants::ANTHROPIC_OAUTH_TOKEN_PREFIX;
-use crate::llms::anthropic::experimental_pass_through::messages::transformation::{
+use crate::anthropic::ANTHROPIC_OAUTH_TOKEN_PREFIX;
+use crate::anthropic::experimental_pass_through::messages::transformation::{
     complete_anthropic_url, resolve_anthropic_api_key,
 };
-use crate::llms::base_llm::chat::transformation::{
+use crate::base_llm::chat::transformation::{
     BaseConfig, ChatCompletionsAuth, Unsupported, unsupported_message, unsupported_param,
 };
+use crate::chat::Error;
+use crate::chat::conversation::{Conversation, build_conversation};
+use crate::chat::response_utils::{finish_reason_for, unix_now, usage_from_parts};
+use crate::chat::types::{
+    ChatCompletionsChoice, ChatCompletionsChoiceMessage, ChatCompletionsResponse, ChatMessage,
+    ProviderChatRequestData, ProviderChatResponseData,
+};
 
 /// Anthropic parameter names, post `map_openai_params`, that the Rust path can
 /// place verbatim in the Messages body.

litellm-rust/crates/providers/src/anthropic/experimental_pass_through/messages/transformation.rs

@@ -1,4 +1,4 @@
-use crate::llms::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
+use crate::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
 use crate::messages::Error;
 
 const ANTHROPIC_API_KEY_ENV: &str = "ANTHROPIC_API_KEY";

litellm-rust/crates/providers/src/anthropic/experimental_pass_through/mod.rs

@@ -0,0 +1 @@
+pub mod messages;

litellm-rust/crates/providers/src/anthropic/mod.rs

@@ -0,0 +1,4 @@
+pub mod chat;
+pub mod experimental_pass_through;
+
+pub const ANTHROPIC_OAUTH_TOKEN_PREFIX: &str = "sk-ant-oat";

litellm-rust/crates/providers/src/audio_transcription/mod.rs

@@ -0,0 +1,31 @@
+use thiserror::Error;
+
+#[derive(Clone, Debug, PartialEq, Eq, Error)]
+pub enum Error {
+    #[error("expected {expected}, got {actual}")]
+    InvalidType {
+        expected: &'static str,
+        actual: &'static str,
+    },
+    #[error("missing required field: {0}")]
+    MissingField(&'static str),
+    #[error("invalid request: {0}")]
+    InvalidRequest(String),
+    #[error("invalid response: {0}")]
+    InvalidResponse(String),
+    #[error(transparent)]
+    Auth(#[from] litellm_auth::Error),
+}
+
+pub fn json_type_name(value: &serde_json::Value) -> &'static str {
+    match value {
+        serde_json::Value::Null => "null",
+        serde_json::Value::Bool(_) => "boolean",
+        serde_json::Value::Number(_) => "number",
+        serde_json::Value::String(_) => "string",
+        serde_json::Value::Array(_) => "array",
+        serde_json::Value::Object(_) => "object",
+    }
+}
+
+pub mod types;

litellm-rust/crates/providers/src/audio_transcription/types.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 
-use crate::llms::base_llm::audio_transcription::transformation::{
+use crate::base_llm::audio_transcription::transformation::{
     AudioTranscriptionAuth, BaseAudioTranscriptionConfig,
 };
 
@@ -20,15 +20,15 @@ pub struct AudioTranscriptionRequest<'a> {
 
 #[derive(Clone)]
 pub struct ProviderAudioTranscriptionRequest {
-    pub(super) model: String,
-    pub(super) custom_llm_provider: String,
-    pub(super) config: &'static dyn BaseAudioTranscriptionConfig,
-    pub(super) url: String,
-    pub(super) body: Value,
-    pub(super) upstream_headers: Vec<(String, String)>,
-    pub(super) auth: AudioTranscriptionAuth,
-    pub(super) optional_params: Map<String, Value>,
-    pub(super) timeout: Option<Duration>,
+    pub model: String,
+    pub custom_llm_provider: String,
+    pub config: &'static dyn BaseAudioTranscriptionConfig,
+    pub url: String,
+    pub body: Value,
+    pub upstream_headers: Vec<(String, String)>,
+    pub auth: AudioTranscriptionAuth,
+    pub optional_params: Map<String, Value>,
+    pub timeout: Option<Duration>,
 }
 
 impl ProviderAudioTranscriptionRequest {

litellm-rust/crates/providers/src/azure_ai/anthropic/messages_transformation.rs

@@ -1,9 +1,9 @@
 use serde_json::{Map, Value};
 
-use crate::llms::anthropic::experimental_pass_through::messages::transformation::{
+use crate::anthropic::experimental_pass_through::messages::transformation::{
     ANTHROPIC_MESSAGES_CONFIG, AnthropicMessagesConfig, non_empty,
 };
-use crate::llms::base_llm::anthropic_messages::transformation::{
+use crate::base_llm::anthropic_messages::transformation::{
     BaseAnthropicMessagesConfig, MessagesAuthStrategy,
 };
 use crate::messages::Error;

litellm-rust/crates/providers/src/azure_ai/mod.rs

@@ -0,0 +1 @@
+pub mod anthropic;

litellm-rust/crates/providers/src/base_llm/audio_transcription/mod.rs

@@ -0,0 +1 @@
+pub mod transformation;

litellm-rust/crates/providers/src/base_llm/chat/mod.rs

@@ -0,0 +1 @@
+pub mod transformation;

litellm-rust/crates/providers/src/base_llm/chat/transformation.rs

@@ -1,7 +1,7 @@
 use serde_json::{Map, Value};
 
-use crate::chat_completions::Error;
-use crate::chat_completions::types::{
+use crate::chat::Error;
+use crate::chat::types::{
     ChatCompletionsResponse, ChatMessage, ChatMessageContent, ProviderChatRequestData,
     ProviderChatResponseData,
 };

litellm-rust/crates/providers/src/base_llm/mod.rs

@@ -0,0 +1,3 @@
+pub mod anthropic_messages;
+pub mod audio_transcription;
+pub mod chat;

litellm-rust/crates/providers/src/bedrock/audio_transcription/mod.rs

@@ -1,11 +1,11 @@
 use serde_json::{Map, Value, json};
 
 use crate::audio_transcription::Error;
+use crate::audio_transcription::json_type_name;
 use crate::audio_transcription::types::{
     AudioTranscriptionRequestData, AudioTranscriptionResponseData,
 };
-use crate::http_utils::json_type_name;
-use crate::llms::base_llm::audio_transcription::transformation::{
+use crate::base_llm::audio_transcription::transformation::{
     AudioTranscriptionAuth, BaseAudioTranscriptionConfig,
 };
 use litellm_auth_aws::constants::{BEDROCK_RUNTIME_ENDPOINT_TEMPLATE, BEDROCK_SERVICE};

litellm-rust/crates/providers/src/bedrock/chat/converse_transformation.rs

@@ -1,16 +1,16 @@
 use serde_json::{Map, Value, json};
 
-use crate::chat_completions::Error;
-use crate::chat_completions::conversation::{Conversation, TurnRole, build_conversation};
-use crate::chat_completions::response_utils::{finish_reason_for, unix_now, usage_from_parts};
-use crate::chat_completions::types::{
+use crate::base_llm::chat::transformation::{
+    BaseConfig, ChatCompletionsAuth, Unsupported, unsupported_message, unsupported_param,
+};
+use crate::chat::Error;
+use crate::chat::conversation::{Conversation, TurnRole, build_conversation};
+use crate::chat::response_utils::{finish_reason_for, unix_now, usage_from_parts};
+use crate::chat::types::{
     ChatCompletionsChoice, ChatCompletionsChoiceMessage, ChatCompletionsResponse,
     ChatCompletionsUsage, ChatMessage, ChatMessageContent, ProviderChatRequestData,
     ProviderChatResponseData,
 };
-use crate::llms::base_llm::chat::transformation::{
-    BaseConfig, ChatCompletionsAuth, Unsupported, unsupported_message, unsupported_param,
-};
 use litellm_auth_aws::constants::{AWS_BEARER_TOKEN_BEDROCK, BEDROCK_RUNTIME_ENDPOINT_TEMPLATE};
 use litellm_auth_aws::{bedrock_model_id_and_region, resolve_bedrock_region};
 

litellm-rust/crates/providers/src/bedrock/chat/tests.rs

@@ -1,7 +1,7 @@
 use serde_json::json;
 
 use super::*;
-use crate::chat_completions::Error;
+use crate::chat::Error;
 
 fn messages(value: Value) -> Vec<ChatMessage> {
     serde_json::from_value(value).expect("valid messages")

litellm-rust/crates/providers/src/chat/conversation.rs

@@ -11,7 +11,7 @@
 //! accepts; anything richer is declined upstream by the capability gate.
 
 use super::types::{ChatMessage, ChatMessageContent};
-use crate::constants::EMPTY_TEXT_PLACEHOLDER;
+use crate::chat::EMPTY_TEXT_PLACEHOLDER;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum TurnRole {

litellm-rust/crates/providers/src/chat/mod.rs

@@ -0,0 +1,21 @@
+use thiserror::Error;
+
+pub const EMPTY_TEXT_PLACEHOLDER: &str = " ";
+
+#[derive(Clone, Debug, PartialEq, Eq, Error)]
+pub enum Error {
+    #[error("missing required field: {0}")]
+    MissingField(&'static str),
+    #[error("invalid request: {0}")]
+    InvalidRequest(String),
+    #[error("invalid response: {0}")]
+    InvalidResponse(String),
+    #[error("unsupported: {0}")]
+    Unsupported(&'static str),
+    #[error(transparent)]
+    Auth(#[from] litellm_auth::Error),
+}
+
+pub mod conversation;
+pub mod response_utils;
+pub mod types;

litellm-rust/crates/providers/src/chat/types.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 
-use crate::llms::base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth};
+use crate::base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth};
 
 /// A `/chat/completions` call as it crosses into the core.
 ///
@@ -22,26 +22,26 @@ pub struct ChatCompletionsRequest<'a> {
     pub timeout: Option<Duration>,
 }
 
-pub(super) struct ResolvedChatCompletionsRequest<'a> {
-    pub(super) model: String,
-    pub(super) config: &'static dyn BaseConfig,
-    pub(super) messages: Vec<ChatMessage>,
-    pub(super) optional_params: Map<String, Value>,
-    pub(super) api_key: Option<&'a str>,
-    pub(super) api_base: Option<&'a str>,
-    pub(super) extra_headers: Option<Map<String, Value>>,
-    pub(super) timeout: Option<Duration>,
+pub struct ResolvedChatCompletionsRequest<'a> {
+    pub model: String,
+    pub config: &'static dyn BaseConfig,
+    pub messages: Vec<ChatMessage>,
+    pub optional_params: Map<String, Value>,
+    pub api_key: Option<&'a str>,
+    pub api_base: Option<&'a str>,
+    pub extra_headers: Option<Map<String, Value>>,
+    pub timeout: Option<Duration>,
 }
 
-pub(super) struct ProviderChatCompletionsRequest {
-    pub(super) model: String,
-    pub(super) config: &'static dyn BaseConfig,
-    pub(super) url: String,
-    pub(super) body: Value,
-    pub(super) upstream_headers: Vec<(String, String)>,
-    pub(super) auth: ChatCompletionsAuth,
-    pub(super) optional_params: Map<String, Value>,
-    pub(super) timeout: Option<Duration>,
+pub struct ProviderChatCompletionsRequest {
+    pub model: String,
+    pub config: &'static dyn BaseConfig,
+    pub url: String,
+    pub body: Value,
+    pub upstream_headers: Vec<(String, String)>,
+    pub auth: ChatCompletionsAuth,
+    pub optional_params: Map<String, Value>,
+    pub timeout: Option<Duration>,
 }
 
 /// The provider-shaped request body a config produces. Named rather than a bare

litellm-rust/crates/providers/src/lib.rs

@@ -0,0 +1,8 @@
+pub mod anthropic;
+pub mod audio_transcription;
+pub mod azure_ai;
+pub mod base_llm;
+pub mod bedrock;
+pub mod chat;
+pub mod messages;
+pub mod provider_resolution;

litellm-rust/crates/providers/src/messages/mod.rs

@@ -0,0 +1,17 @@
+use thiserror::Error;
+
+#[derive(Clone, Debug, PartialEq, Eq, Error)]
+pub enum Error {
+    #[error("missing required field: {0}")]
+    MissingField(&'static str),
+    #[error("invalid request: {0}")]
+    InvalidRequest(String),
+    #[error("invalid response: {0}")]
+    InvalidResponse(String),
+    #[error("unsupported: {0}")]
+    Unsupported(&'static str),
+    #[error(transparent)]
+    Auth(#[from] litellm_auth::Error),
+}
+
+pub mod types;

litellm-rust/crates/providers/src/messages/types.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 
-use crate::llms::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
+use crate::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
 
 pub struct MessagesRequest<'a> {
     pub model: &'a str,
@@ -15,14 +15,14 @@ pub struct MessagesRequest<'a> {
     pub timeout: Option<Duration>,
 }
 
-pub(super) struct ProviderMessagesRequest {
-    pub(super) provider: String,
-    pub(super) model: String,
-    pub(super) config: &'static dyn BaseAnthropicMessagesConfig,
-    pub(super) url: String,
-    pub(super) body: Value,
-    pub(super) upstream_headers: Vec<(String, String)>,
-    pub(super) timeout: Option<Duration>,
+pub struct ProviderMessagesRequest {
+    pub provider: String,
+    pub model: String,
+    pub config: &'static dyn BaseAnthropicMessagesConfig,
+    pub url: String,
+    pub body: Value,
+    pub upstream_headers: Vec<(String, String)>,
+    pub timeout: Option<Duration>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

litellm-rust/crates/providers/src/provider_resolution.rs

@@ -0,0 +1,33 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CustomLlmProvider<'a> {
+    pub model: &'a str,
+    pub custom_llm_provider: &'a str,
+}
+
+pub fn get_custom_llm_provider<'a>(
+    model: &'a str,
+    custom_llm_provider: Option<&'a str>,
+) -> Option<CustomLlmProvider<'a>> {
+    if let Some(custom_llm_provider) = custom_llm_provider.filter(|provider| !provider.is_empty()) {
+        return Some(CustomLlmProvider {
+            model: strip_custom_llm_provider_prefix(model, custom_llm_provider),
+            custom_llm_provider,
+        });
+    }
+
+    let (custom_llm_provider, model) = model.split_once('/')?;
+    if custom_llm_provider.is_empty() || model.is_empty() {
+        return None;
+    }
+    Some(CustomLlmProvider {
+        model,
+        custom_llm_provider,
+    })
+}
+
+fn strip_custom_llm_provider_prefix<'a>(model: &'a str, custom_llm_provider: &str) -> &'a str {
+    model
+        .strip_prefix(custom_llm_provider)
+        .and_then(|model| model.strip_prefix('/'))
+        .unwrap_or(model)
+}