chore(rust): merge main into litellm_gcs_native_cache

Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

.circleci/scripts/run_integration.sh

@@ -121,6 +121,10 @@ start_proxy() {
       "LITELLM_MODEL_COST_MAP_URL=$INTEGRATION_UPSTREAM_URL/_cost_map"
       "MODEL_COST_MAP_MIN_MODEL_COUNT=1"
       "MODEL_COST_MAP_MAX_SHRINK_RATIO=0"
+      "GEMINI_API_BASE=$INTEGRATION_UPSTREAM_URL"
+      "ANTHROPIC_API_BASE=$INTEGRATION_UPSTREAM_URL"
+      "GEMINI_API_KEY=sk-scripted-provider"
+      "ANTHROPIC_API_KEY=sk-scripted-provider"
     )
   else
     cost_map_env=("LITELLM_LOCAL_MODEL_COST_MAP=True")

.github/scripts/verify_linux_native_wheel.py

@@ -205,7 +205,7 @@ def main(
     native_module: Final = load_native_module(native_path)
     native_module_loads: Final = native_module is not None
     panic_test_hook_absent: Final = native_module is not None and not hasattr(native_module, "_panic_for_test")
-    native_size_limit: Final = 25_000_000
+    native_size_limit: Final = 30_000_000
     native_size_within_limit: Final = native_member.file_size <= native_size_limit
     validations: Final = (
         (f"Python tag is {EXPECTED_PYTHON_TAG}", python_tag == EXPECTED_PYTHON_TAG),
@@ -222,7 +222,7 @@ def main(
         ("Python extension entry point is present", extension_entry_point_present),
         ("Native module loads", native_module_loads),
         ("Production module omits the panic test hook", panic_test_hook_absent),
-        ("Native extension does not exceed 25 MB", native_size_within_limit),
+        ("Native extension does not exceed 30 MB", native_size_within_limit),
         ("Wheel contents are valid", not unexpected_members),
     )
 
@@ -267,7 +267,7 @@ def main(
             ),
             (
                 not native_size_within_limit,
-                f"native extension exceeds 20 MB: {native_member.file_size / 1_000_000:.2f} MB",
+                f"native extension exceeds 30 MB: {native_member.file_size / 1_000_000:.2f} MB",
             ),
             (bool(unexpected_members), f"wheel contains unexpected build artifacts: {', '.join(unexpected_members)}"),
         )

README.md

@@ -307,6 +307,7 @@ For MCP OAuth, an upstream may advertise dynamic client registration but refuse
 | [Deepgram (`deepgram`)](https://docs.litellm.ai/docs/providers/deepgram) | ✅ | ✅ | ✅ |  |  | ✅ |  |  |  |  |
 | [DeepInfra (`deepinfra`)](https://docs.litellm.ai/docs/providers/deepinfra) | ✅ | ✅ | ✅ |  |  |  |  |  |  |  |
 | [Deepseek (`deepseek`)](https://docs.litellm.ai/docs/providers/deepseek) | ✅ | ✅ | ✅ |  |  |  |  |  |  |  |
+| [Eden AI (`edenai`)](https://docs.litellm.ai/docs/providers/edenai) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |  |  |  |
 | [ElevenLabs (`elevenlabs`)](https://docs.litellm.ai/docs/providers/elevenlabs) | ✅ | ✅ | ✅ |  |  | ✅ | ✅ |  |  |  |
 | [Empower (`empower`)](https://docs.litellm.ai/docs/providers/empower) | ✅ | ✅ | ✅ |  |  |  |  |  |  |  |
 | [Fal AI (`fal_ai`)](https://docs.litellm.ai/docs/providers/fal_ai) | ✅ | ✅ | ✅ |  | ✅ |  |  |  |  |  |

litellm-rust/Cargo.lock

@@ -927,6 +927,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crc16"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "338089f42c427b86394a5ee60ff321da23a5c89c9d89514c829687b26359fcff"
+
 [[package]]
 name = "crc32fast"
 version = "1.5.1"
@@ -3725,9 +3731,11 @@ checksum = "2acbc41a996f7652b2ddd9dfd98cc4ff602cfd742ae35382f07f608405ab50ed"
 dependencies = [
  "arcstr",
  "combine",
+ "crc16",
  "itoa",
  "num-bigint 0.5.1",
  "percent-encoding",
+ "rand 0.10.2",
  "rustls 0.23.42",
  "rustls-native-certs",
  "ryu",

litellm-rust/Cargo.toml

@@ -76,7 +76,7 @@ veil = "0.3.0"
 
 [profile.release]
 opt-level = 3
-lto = "fat"
+lto = "thin"
 codegen-units = 1
 panic = "unwind"
 debug = false

litellm-rust/crates/cache-redis/Cargo.toml

@@ -7,7 +7,7 @@ repository.workspace = true
 
 [dependencies]
 litellm-cache.workspace = true
-redis = { version = "1.7.0", features = ["tls-rustls"] }
+redis = { version = "1.7.0", features = ["cluster", "tls-rustls"] }
 r2d2 = "0.8.10"
 tokio.workspace = true
 

litellm-rust/crates/cache-redis/src/cache.rs

@@ -9,8 +9,14 @@ use litellm_cache::{
 };
 use redis::Commands;
 
+use crate::topology::RedisTopology;
+
+mod connection;
 mod operations;
 
+pub(crate) use connection::ConnectionRef;
+use connection::{ClusterConnectionManager, ConnectionManager};
+
 pub use operations::{
     RedisArg, RedisLpopOperation, RedisLpopResult, RedisRpushOperation, RedisScript,
 };
@@ -19,40 +25,6 @@ const DEFAULT_TTL: Duration = Duration::from_secs(600);
 const REDIS_TIMEOUT: Duration = Duration::from_secs(5);
 const REDIS_POOL_SIZE: u32 = 16;
 
-struct PooledConnection {
-    connection: redis::Connection,
-    failed: bool,
-}
-
-/// Pools connections without a checkout PING, which would double every operation's round trips.
-/// A timed-out command leaves its reply on the socket while redis still reports the connection
-/// open, so any connection whose operation failed is discarded instead of being reused.
-struct ConnectionManager(redis::Client);
-
-impl r2d2::ManageConnection for ConnectionManager {
-    type Connection = PooledConnection;
-    type Error = redis::RedisError;
-
-    fn connect(&self) -> Result<PooledConnection, redis::RedisError> {
-        let connection = self.0.get_connection()?;
-        connection.set_read_timeout(Some(REDIS_TIMEOUT))?;
-        connection.set_write_timeout(Some(REDIS_TIMEOUT))?;
-        Ok(PooledConnection {
-            connection,
-            failed: false,
-        })
-    }
-
-    fn is_valid(&self, connection: &mut PooledConnection) -> Result<(), redis::RedisError> {
-        redis::cmd("PING").query::<String>(&mut connection.connection)?;
-        Ok(())
-    }
-
-    fn has_broken(&self, connection: &mut PooledConnection) -> bool {
-        connection.failed || !redis::ConnectionLike::is_open(&connection.connection)
-    }
-}
-
 const INCREMENT_SCRIPT: &str = concat!(
     "local value = redis.call('INCRBYFLOAT', KEYS[1], ARGV[1]); ",
     "if redis.call('TTL', KEYS[1]) == -1 then ",
@@ -70,42 +42,10 @@ const CLAIM_ATTEMPTS: usize = 8;
 
 enum Connections<C> {
     Pool(r2d2::Pool<ConnectionManager>),
+    Cluster(r2d2::Pool<ClusterConnectionManager>),
     Fixed(Mutex<C>),
 }
 
-struct ConnectionRef<'a>(&'a mut dyn redis::ConnectionLike);
-
-impl redis::ConnectionLike for ConnectionRef<'_> {
-    fn req_packed_command(&mut self, cmd: &[u8]) -> redis::RedisResult<redis::Value> {
-        self.0.req_packed_command(cmd)
-    }
-
-    fn req_packed_commands(
-        &mut self,
-        cmd: &[u8],
-        offset: usize,
-        count: usize,
-    ) -> redis::RedisResult<Vec<redis::Value>> {
-        self.0.req_packed_commands(cmd, offset, count)
-    }
-
-    fn get_db(&self) -> i64 {
-        self.0.get_db()
-    }
-
-    fn supports_pipelining(&self) -> bool {
-        self.0.supports_pipelining()
-    }
-
-    fn check_connection(&mut self) -> bool {
-        self.0.check_connection()
-    }
-
-    fn is_open(&self) -> bool {
-        self.0.is_open()
-    }
-}
-
 impl<C> Connections<C>
 where
     C: redis::ConnectionLike + Send + 'static,
@@ -117,13 +57,19 @@ where
         match self {
             Self::Pool(pool) => {
                 let mut pooled = pool.get().map_err(|_| Error::Unavailable)?;
-                let result = operation(&mut ConnectionRef(&mut pooled.connection));
+                let result = operation(&mut ConnectionRef::Node(&mut pooled.connection));
+                pooled.failed = matches!(result, Err(Error::Unavailable));
+                result
+            }
+            Self::Cluster(pool) => {
+                let mut pooled = pool.get().map_err(|_| Error::Unavailable)?;
+                let result = operation(&mut ConnectionRef::Cluster(&mut pooled.connection));
                 pooled.failed = matches!(result, Err(Error::Unavailable));
                 result
             }
             Self::Fixed(connection) => {
                 let mut connection = connection.lock().map_err(|_| Error::Unavailable)?;
-                operation(&mut ConnectionRef(&mut *connection))
+                operation(&mut ConnectionRef::Node(&mut *connection))
             }
         }
     }
@@ -134,27 +80,46 @@ pub struct RedisCache<S, C = redis::Connection> {
     default_ttl: Duration,
     codec: S,
     namespace: Option<String>,
+    topology: RedisTopology,
 }
 
 impl<S: CacheCodec> RedisCache<S> {
     pub fn new(url: &str, default_ttl: Option<Duration>, codec: S) -> Result<Self, Error> {
-        let client = redis::Client::open(url).map_err(|_| Error::Unavailable)?;
-        let pool = r2d2::Pool::builder()
-            .max_size(REDIS_POOL_SIZE)
-            .min_idle(Some(0))
-            .connection_timeout(REDIS_TIMEOUT)
-            .test_on_check_out(false)
-            .build(ConnectionManager(client))
-            .map_err(|_| Error::Unavailable)?;
+        Self::connect(url, &RedisTopology::Standalone, default_ttl, codec)
+    }
+
+    pub fn connect(
+        url: &str,
+        topology: &RedisTopology,
+        default_ttl: Option<Duration>,
+        codec: S,
+    ) -> Result<Self, Error> {
+        let connections = match topology {
+            RedisTopology::Standalone => Connections::Pool(pool(ConnectionManager::open(url)?)?),
+            RedisTopology::Cluster { startup_nodes } => {
+                Connections::Cluster(pool(ClusterConnectionManager::open(url, startup_nodes)?)?)
+            }
+        };
         Ok(Self {
-            connections: Arc::new(Connections::Pool(pool)),
+            connections: Arc::new(connections),
             default_ttl: default_ttl.unwrap_or(DEFAULT_TTL),
             codec,
             namespace: None,
+            topology: topology.clone(),
         })
     }
 }
 
+fn pool<M: r2d2::ManageConnection>(manager: M) -> Result<r2d2::Pool<M>, Error> {
+    r2d2::Pool::builder()
+        .max_size(REDIS_POOL_SIZE)
+        .min_idle(Some(0))
+        .connection_timeout(REDIS_TIMEOUT)
+        .test_on_check_out(false)
+        .build(manager)
+        .map_err(|_| Error::Unavailable)
+}
+
 impl<S, C> RedisCache<S, C>
 where
     S: CacheCodec,
@@ -166,6 +131,7 @@ where
             default_ttl: default_ttl.unwrap_or(DEFAULT_TTL),
             codec,
             namespace: None,
+            topology: RedisTopology::Standalone,
         }
     }
 
@@ -180,6 +146,10 @@ where
         self.namespace.as_deref()
     }
 
+    pub fn topology(&self) -> &RedisTopology {
+        &self.topology
+    }
+
     fn namespaced_key(&self, key: &str) -> String {
         namespaced_key(self.namespace.as_deref(), key)
     }
@@ -200,26 +170,14 @@ where
     }
 
     fn flush_matching(connection: &mut ConnectionRef<'_>, pattern: &str) -> Result<(), Error> {
-        let mut cursor = 0u64;
-        loop {
-            let (next_cursor, keys): (u64, Vec<String>) = redis::cmd("SCAN")
-                .cursor_arg(cursor)
-                .arg("MATCH")
-                .arg(pattern)
-                .arg("COUNT")
-                .arg(1000)
-                .query(connection)
-                .map_err(|_| Error::Unavailable)?;
+        connection.scan(pattern, 1000, |connection, keys| {
             if !keys.is_empty() {
                 connection
                     .del::<_, usize>(keys)
                     .map_err(|_| Error::Unavailable)?;
             }
-            if next_cursor == 0 {
-                return Ok(());
-            }
-            cursor = next_cursor;
-        }
+            Ok(true)
+        })
     }
 
     fn decode_response(&self, value: redis::Value) -> Result<Option<S::Value>, Error> {
@@ -350,19 +308,19 @@ where
             })
             .collect::<Result<Vec<_>, _>>()?;
         let ttl = Self::ttl_seconds(self.get_ttl(&context).unwrap_or(self.default_ttl));
+        if entries.is_empty() {
+            return Ok(());
+        }
         Self::run_blocking(Arc::clone(&self.connections), move |connection| {
-            let mut pipeline = redis::pipe();
-            for (key, payload) in entries {
-                pipeline
-                    .cmd("SETEX")
-                    .arg(key)
-                    .arg(ttl)
-                    .arg(payload)
-                    .ignore();
-            }
-            pipeline
-                .query::<()>(connection)
-                .map_err(|_| Error::Unavailable)
+            let commands = entries
+                .into_iter()
+                .map(|(key, payload)| {
+                    let mut command = redis::cmd("SETEX");
+                    command.arg(key).arg(ttl).arg(payload);
+                    command
+                })
+                .collect();
+            connection.pipeline(commands).map(drop)
         })
         .await
     }
@@ -373,7 +331,7 @@ where
 
     async fn test_connection(&self) -> Result<CacheConnectionResult, Error> {
         match Self::run_blocking(Arc::clone(&self.connections), |connection| {
-            Ok(match redis::cmd("PING").query::<String>(connection) {
+            Ok(match connection.ping() {
                 Ok(_) => CacheConnectionResult {
                     status: CacheConnectionStatus::Success,
                     message: "Redis cache connection test successful".into(),

litellm-rust/crates/cache-redis/src/cache/connection.rs

@@ -0,0 +1,392 @@
+use std::collections::HashMap;
+
+use litellm_cache::Error;
+use redis::{
+    ConnectionAddr, ConnectionInfo, ConnectionLike, IntoConnectionInfo,
+    cluster::{ClusterClient, ClusterClientBuilder, ClusterConnection, NodeAddress},
+    cluster_routing::{
+        MultipleNodeRoutingInfo, ResponsePolicy, RoutingInfo, SingleNodeRoutingInfo, Slot,
+    },
+};
+
+use super::REDIS_TIMEOUT;
+use crate::topology::RedisNode;
+
+pub(super) struct PooledConnection<C> {
+    pub(super) connection: C,
+    pub(super) failed: bool,
+}
+
+/// Pools connections without a checkout PING, which would double every operation's round trips.
+/// A timed-out command leaves its reply on the socket while redis still reports the connection
+/// open, so any connection whose operation failed is discarded instead of being reused.
+pub(super) struct ConnectionManager(redis::Client);
+
+impl ConnectionManager {
+    pub(super) fn open(url: &str) -> Result<Self, Error> {
+        redis::Client::open(url)
+            .map(Self)
+            .map_err(|_| Error::Unavailable)
+    }
+}
+
+impl r2d2::ManageConnection for ConnectionManager {
+    type Connection = PooledConnection<redis::Connection>;
+    type Error = redis::RedisError;
+
+    fn connect(&self) -> Result<Self::Connection, redis::RedisError> {
+        let connection = self.0.get_connection()?;
+        connection.set_read_timeout(Some(REDIS_TIMEOUT))?;
+        connection.set_write_timeout(Some(REDIS_TIMEOUT))?;
+        Ok(PooledConnection {
+            connection,
+            failed: false,
+        })
+    }
+
+    fn is_valid(&self, connection: &mut Self::Connection) -> Result<(), redis::RedisError> {
+        redis::cmd("PING").query::<String>(&mut connection.connection)?;
+        Ok(())
+    }
+
+    fn has_broken(&self, connection: &mut Self::Connection) -> bool {
+        connection.failed || !redis::ConnectionLike::is_open(&connection.connection)
+    }
+}
+
+pub(super) struct ClusterConnectionManager(ClusterClient);
+
+impl ClusterConnectionManager {
+    pub(super) fn open(url: &str, startup_nodes: &[RedisNode]) -> Result<Self, Error> {
+        if startup_nodes.is_empty() {
+            return Err(Error::Unavailable);
+        }
+        let info = url.into_connection_info().map_err(|_| Error::Unavailable)?;
+        let nodes = startup_nodes
+            .iter()
+            .map(|node| node_info(&info, node))
+            .collect::<Result<Vec<_>, _>>()?;
+        ClusterClientBuilder::new(nodes)
+            .connection_timeout(REDIS_TIMEOUT)
+            .response_timeout(REDIS_TIMEOUT)
+            .build()
+            .map(Self)
+            .map_err(|_| Error::Unavailable)
+    }
+}
+
+fn node_info(info: &ConnectionInfo, node: &RedisNode) -> Result<ConnectionInfo, Error> {
+    let addr = match info.addr() {
+        ConnectionAddr::Tcp(..) => ConnectionAddr::Tcp(node.host.clone(), node.port),
+        ConnectionAddr::TcpTls {
+            insecure,
+            tls_params,
+            ..
+        } => ConnectionAddr::TcpTls {
+            host: node.host.clone(),
+            port: node.port,
+            insecure: *insecure,
+            tls_params: tls_params.clone(),
+        },
+        _ => return Err(Error::Unavailable),
+    };
+    Ok(info.clone().set_addr(addr))
+}
+
+impl r2d2::ManageConnection for ClusterConnectionManager {
+    type Connection = PooledConnection<ClusterConnection>;
+    type Error = redis::RedisError;
+
+    fn connect(&self) -> Result<Self::Connection, redis::RedisError> {
+        let connection = self.0.get_connection()?;
+        connection.set_read_timeout(Some(REDIS_TIMEOUT))?;
+        connection.set_write_timeout(Some(REDIS_TIMEOUT))?;
+        Ok(PooledConnection {
+            connection,
+            failed: false,
+        })
+    }
+
+    fn is_valid(&self, connection: &mut Self::Connection) -> Result<(), redis::RedisError> {
+        redis::cmd("PING").query::<String>(&mut connection.connection)?;
+        Ok(())
+    }
+
+    fn has_broken(&self, connection: &mut Self::Connection) -> bool {
+        connection.failed || !redis::ConnectionLike::is_open(&connection.connection)
+    }
+}
+
+pub(crate) enum ConnectionRef<'a> {
+    Node(&'a mut dyn redis::ConnectionLike),
+    Cluster(&'a mut ClusterConnection),
+}
+
+impl redis::ConnectionLike for ConnectionRef<'_> {
+    fn req_packed_command(&mut self, cmd: &[u8]) -> redis::RedisResult<redis::Value> {
+        match self {
+            Self::Node(connection) => connection.req_packed_command(cmd),
+            Self::Cluster(connection) => connection.req_packed_command(cmd),
+        }
+    }
+
+    fn req_packed_commands(
+        &mut self,
+        cmd: &[u8],
+        offset: usize,
+        count: usize,
+    ) -> redis::RedisResult<Vec<redis::Value>> {
+        match self {
+            Self::Node(connection) => connection.req_packed_commands(cmd, offset, count),
+            Self::Cluster(connection) => connection.req_packed_commands(cmd, offset, count),
+        }
+    }
+
+    fn get_db(&self) -> i64 {
+        match self {
+            Self::Node(connection) => connection.get_db(),
+            Self::Cluster(connection) => redis::ConnectionLike::get_db(*connection),
+        }
+    }
+
+    fn supports_pipelining(&self) -> bool {
+        match self {
+            Self::Node(connection) => connection.supports_pipelining(),
+            Self::Cluster(connection) => redis::ConnectionLike::supports_pipelining(*connection),
+        }
+    }
+
+    fn check_connection(&mut self) -> bool {
+        match self {
+            Self::Node(connection) => connection.check_connection(),
+            Self::Cluster(connection) => connection.check_connection(),
+        }
+    }
+
+    fn is_open(&self) -> bool {
+        match self {
+            Self::Node(connection) => connection.is_open(),
+            Self::Cluster(connection) => redis::ConnectionLike::is_open(*connection),
+        }
+    }
+}
+
+impl ConnectionRef<'_> {
+    pub(crate) fn pipeline(
+        &mut self,
+        commands: Vec<redis::Cmd>,
+    ) -> Result<Vec<redis::Value>, Error> {
+        match self {
+            Self::Node(connection) => {
+                let mut pipeline = redis::pipe();
+                for command in &commands {
+                    pipeline.add_command(command.clone());
+                }
+                pipeline
+                    .query::<Vec<redis::Value>>(*connection)
+                    .map_err(|_| Error::Unavailable)
+            }
+            Self::Cluster(connection) => {
+                let mut replies: Vec<Option<redis::Value>> = vec![None; commands.len()];
+                for indices in slot_groups(&commands).into_values() {
+                    let mut pipeline = redis::pipe();
+                    for index in &indices {
+                        pipeline.add_command(commands[*index].clone());
+                    }
+                    let values = connection
+                        .req_packed_commands(&pipeline.get_packed_pipeline(), 0, indices.len())
+                        .map_err(|_| Error::Unavailable)?;
+                    if values.len() != indices.len() {
+                        return Err(Error::Unavailable);
+                    }
+                    for (index, value) in indices.into_iter().zip(values) {
+                        replies[index] = Some(value);
+                    }
+                }
+                replies
+                    .into_iter()
+                    .collect::<Option<Vec<_>>>()
+                    .ok_or(Error::Unavailable)
+            }
+        }
+    }
+
+    pub(crate) fn scan(
+        &mut self,
+        pattern: &str,
+        count: usize,
+        mut visit: impl FnMut(&mut Self, Vec<String>) -> Result<bool, Error>,
+    ) -> Result<(), Error> {
+        let pages = match self {
+            Self::Node(connection) => {
+                let page = scan_command(0, pattern, count)
+                    .query::<ScanPage>(*connection)
+                    .map_err(|_| Error::Unavailable)?;
+                vec![(None, page)]
+            }
+            Self::Cluster(connection) => connection
+                .route_command(
+                    &scan_command(0, pattern, count),
+                    RoutingInfo::MultiNode((
+                        MultipleNodeRoutingInfo::AllMasters,
+                        Some(ResponsePolicy::Special),
+                    )),
+                )
+                .map_err(|_| Error::Unavailable)
+                .and_then(primary_pages)?
+                .into_iter()
+                .map(|(node, page)| (Some(node), page))
+                .collect(),
+        };
+        for (node, (mut cursor, mut keys)) in pages {
+            loop {
+                if !visit(self, keys)? {
+                    return Ok(());
+                }
+                if cursor == 0 {
+                    break;
+                }
+                (cursor, keys) = self.scan_page(node.as_ref(), cursor, pattern, count)?;
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn ping(&mut self) -> Result<bool, redis::RedisError> {
+        let command = redis::cmd("PING");
+        match self {
+            Self::Node(connection) => command
+                .query::<String>(*connection)
+                .map(|response| response == "PONG"),
+            Self::Cluster(connection) => connection
+                .route_command(
+                    &command,
+                    RoutingInfo::MultiNode((
+                        MultipleNodeRoutingInfo::AllNodes,
+                        Some(ResponsePolicy::AllSucceeded),
+                    )),
+                )
+                .map(|_| true),
+        }
+    }
+
+    pub(crate) fn node_text(&mut self, command: &redis::Cmd) -> Result<String, Error> {
+        match self {
+            Self::Node(connection) => command.query(*connection).map_err(|_| Error::Unavailable),
+            Self::Cluster(connection) => {
+                let value = connection
+                    .route_command(
+                        command,
+                        RoutingInfo::MultiNode((
+                            MultipleNodeRoutingInfo::AllNodes,
+                            Some(ResponsePolicy::Special),
+                        )),
+                    )
+                    .map_err(|_| Error::Unavailable)?;
+                let redis::Value::Map(entries) = value else {
+                    return Err(Error::Unavailable);
+                };
+                let mut replies = entries
+                    .into_iter()
+                    .map(|(node, reply)| {
+                        Ok((
+                            redis::from_redis_value::<String>(node)
+                                .map_err(|_| Error::Unavailable)?,
+                            redis::from_redis_value::<String>(reply)
+                                .map_err(|_| Error::Unavailable)?,
+                        ))
+                    })
+                    .collect::<Result<Vec<(String, String)>, Error>>()?;
+                replies.sort();
+                Ok(replies
+                    .into_iter()
+                    .map(|(_, reply)| reply)
+                    .collect::<Vec<_>>()
+                    .join("\n"))
+            }
+        }
+    }
+
+    pub(crate) fn flushall(&mut self) -> Result<(), Error> {
+        let command = redis::cmd("FLUSHALL");
+        match self {
+            Self::Node(connection) => command.query(*connection).map_err(|_| Error::Unavailable),
+            Self::Cluster(connection) => connection
+                .route_command(
+                    &command,
+                    RoutingInfo::MultiNode((
+                        MultipleNodeRoutingInfo::AllMasters,
+                        Some(ResponsePolicy::AllSucceeded),
+                    )),
+                )
+                .map(|_| ())
+                .map_err(|_| Error::Unavailable),
+        }
+    }
+
+    fn scan_page(
+        &mut self,
+        node: Option<&NodeAddress>,
+        cursor: u64,
+        pattern: &str,
+        count: usize,
+    ) -> Result<ScanPage, Error> {
+        let command = scan_command(cursor, pattern, count);
+        match (self, node) {
+            (Self::Node(connection), None) => {
+                command.query(*connection).map_err(|_| Error::Unavailable)
+            }
+            (Self::Cluster(connection), Some(node)) => connection
+                .route_command(
+                    &command,
+                    RoutingInfo::SingleNode(SingleNodeRoutingInfo::ByAddress {
+                        host: node.host().to_string(),
+                        port: node.port(),
+                    }),
+                )
+                .map_err(|_| Error::Unavailable)
+                .and_then(|value| redis::from_redis_value(value).map_err(|_| Error::Unavailable)),
+            _ => Err(Error::Unavailable),
+        }
+    }
+}
+
+type ScanPage = (u64, Vec<String>);
+
+fn primary_pages(value: redis::Value) -> Result<Vec<(NodeAddress, ScanPage)>, Error> {
+    let redis::Value::Map(entries) = value else {
+        return Err(Error::Unavailable);
+    };
+    entries
+        .into_iter()
+        .map(|(node, page)| {
+            let node = redis::from_redis_value::<String>(node).map_err(|_| Error::Unavailable)?;
+            let node = NodeAddress::try_from(node.as_str()).map_err(|_| Error::Unavailable)?;
+            let page = redis::from_redis_value::<ScanPage>(page).map_err(|_| Error::Unavailable)?;
+            Ok((node, page))
+        })
+        .collect()
+}
+
+fn scan_command(cursor: u64, pattern: &str, count: usize) -> redis::Cmd {
+    let mut command = redis::cmd("SCAN");
+    command
+        .cursor_arg(cursor)
+        .arg("MATCH")
+        .arg(pattern)
+        .arg("COUNT")
+        .arg(count);
+    command
+}
+
+fn slot_groups(commands: &[redis::Cmd]) -> HashMap<Slot, Vec<usize>> {
+    let mut groups: HashMap<Slot, Vec<usize>> = HashMap::new();
+    for (index, command) in commands.iter().enumerate() {
+        let key = match command.args_iter().nth(1) {
+            Some(redis::Arg::Simple(key)) => key,
+            _ => b"",
+        };
+        groups.entry(Slot::for_key(key)).or_default().push(index);
+    }
+    groups
+}

litellm-rust/crates/cache-redis/src/cache/operations.rs

@@ -183,20 +183,13 @@ where
     }
 
     pub fn sync_ping(&self) -> Result<bool, Error> {
-        self.connections.execute(|connection| {
-            redis::cmd("PING")
-                .query::<String>(connection)
-                .map(|response| response == "PONG")
-                .map_err(|_| Error::Unavailable)
-        })
+        self.connections
+            .execute(|connection| connection.ping().map_err(|_| Error::Unavailable))
     }
 
     pub async fn ping(&self) -> Result<bool, Error> {
         Self::run_blocking(Arc::clone(&self.connections), |connection| {
-            redis::cmd("PING")
-                .query::<String>(connection)
-                .map(|response| response == "PONG")
-                .map_err(|_| Error::Unavailable)
+            connection.ping().map_err(|_| Error::Unavailable)
         })
         .await
     }
@@ -216,24 +209,13 @@ where
     pub async fn async_scan_iter(&self, pattern: &str, count: usize) -> Result<Vec<String>, Error> {
         let pattern = format!("{}*", self.namespaced_key(pattern));
         Self::run_blocking(Arc::clone(&self.connections), move |connection| {
-            let mut cursor = 0u64;
             let mut matches = Vec::new();
-            loop {
-                let (next_cursor, keys): (u64, Vec<String>) = redis::cmd("SCAN")
-                    .cursor_arg(cursor)
-                    .arg("MATCH")
-                    .arg(&pattern)
-                    .arg("COUNT")
-                    .arg(count)
-                    .query(connection)
-                    .map_err(|_| Error::Unavailable)?;
+            connection.scan(&pattern, count, |_, keys| {
                 matches.extend(keys);
-                if matches.len() >= count || next_cursor == 0 {
-                    matches.truncate(count);
-                    return Ok(matches);
-                }
-                cursor = next_cursor;
-            }
+                Ok(matches.len() < count)
+            })?;
+            matches.truncate(count);
+            Ok(matches)
         })
         .await
     }
@@ -250,13 +232,18 @@ where
         let key = self.namespaced_key(key);
         let ttl = Self::ttl_seconds(ttl.unwrap_or(self.default_ttl));
         Self::run_blocking(Arc::clone(&self.connections), move |connection| {
-            let mut pipeline = redis::pipe();
-            pipeline.cmd("SADD").arg(&key).arg(values);
-            pipeline.cmd("EXPIRE").arg(&key).arg(ttl).ignore();
-            pipeline
-                .query::<(usize,)>(connection)
-                .map(|(added,)| added)
-                .map_err(|_| Error::Unavailable)
+            let mut sadd = redis::cmd("SADD");
+            sadd.arg(&key).arg(values);
+            let mut expire = redis::cmd("EXPIRE");
+            expire.arg(&key).arg(ttl);
+            let replies = connection.pipeline(vec![sadd, expire])?;
+            replies
+                .into_iter()
+                .next()
+                .map(redis::from_redis_value::<usize>)
+                .transpose()
+                .map_err(|_| Error::Unavailable)?
+                .ok_or(Error::Unavailable)
         })
         .await
     }
@@ -293,11 +280,19 @@ where
             return Ok(Vec::new());
         }
         Self::run_blocking(Arc::clone(&self.connections), move |connection| {
-            let mut pipeline = redis::pipe();
-            for (key, values) in operations {
-                pipeline.cmd("RPUSH").arg(key).arg(values);
-            }
-            pipeline.query(connection).map_err(|_| Error::Unavailable)
+            let commands = operations
+                .into_iter()
+                .map(|(key, values)| {
+                    let mut command = redis::cmd("RPUSH");
+                    command.arg(key).arg(values);
+                    command
+                })
+                .collect();
+            connection
+                .pipeline(commands)?
+                .into_iter()
+                .map(|value| redis::from_redis_value(value).map_err(|_| Error::Unavailable))
+                .collect()
         })
         .await
     }
@@ -339,16 +334,18 @@ where
             .map(|(_, count)| count.is_some())
             .collect::<Vec<_>>();
         let values = Self::run_blocking(Arc::clone(&self.connections), move |connection| {
-            let mut pipeline = redis::pipe();
-            for (key, count) in operations {
-                let command = pipeline.cmd("LPOP").arg(key);
-                if let Some(count) = count {
-                    command.arg(count);
-                }
-            }
-            pipeline
-                .query::<Vec<redis::Value>>(connection)
-                .map_err(|_| Error::Unavailable)
+            let commands = operations
+                .into_iter()
+                .map(|(key, count)| {
+                    let mut command = redis::cmd("LPOP");
+                    command.arg(key);
+                    if let Some(count) = count {
+                        command.arg(count);
+                    }
+                    command
+                })
+                .collect();
+            connection.pipeline(commands)
         })
         .await?;
         values
@@ -381,28 +378,17 @@ where
     }
 
     pub fn client_list(&self) -> Result<String, Error> {
-        self.connections.execute(|connection| {
-            redis::cmd("CLIENT")
-                .arg("LIST")
-                .query(connection)
-                .map_err(|_| Error::Unavailable)
-        })
+        self.connections
+            .execute(|connection| connection.node_text(redis::cmd("CLIENT").arg("LIST")))
     }
 
     pub fn info(&self) -> Result<String, Error> {
-        self.connections.execute(|connection| {
-            redis::cmd("INFO")
-                .query(connection)
-                .map_err(|_| Error::Unavailable)
-        })
+        self.connections
+            .execute(|connection| connection.node_text(&redis::cmd("INFO")))
     }
 
     pub fn flushall(&self) -> Result<(), Error> {
-        self.connections.execute(|connection| {
-            redis::cmd("FLUSHALL")
-                .query(connection)
-                .map_err(|_| Error::Unavailable)
-        })
+        self.connections.execute(|connection| connection.flushall())
     }
 }
 
@@ -441,14 +427,27 @@ where
             return Ok(Vec::new());
         }
         Self::run_blocking(Arc::clone(&self.connections), move |connection| {
-            let mut pipeline = redis::pipe();
+            let mut commands = Vec::with_capacity(operations.len() * 2);
+            let mut increments = Vec::with_capacity(operations.len());
             for (key, amount, ttl) in operations {
-                pipeline.cmd("INCRBYFLOAT").arg(&key).arg(amount);
+                let mut increment = redis::cmd("INCRBYFLOAT");
+                increment.arg(&key).arg(amount);
+                increments.push(commands.len());
+                commands.push(increment);
                 if let Some(ttl) = ttl {
-                    pipeline.cmd("EXPIRE").arg(key).arg(ttl).ignore();
+                    let mut expire = redis::cmd("EXPIRE");
+                    expire.arg(key).arg(ttl);
+                    commands.push(expire);
                 }
             }
-            pipeline.query(connection).map_err(|_| Error::Unavailable)
+            let mut replies = connection.pipeline(commands)?;
+            increments
+                .into_iter()
+                .map(|index| {
+                    redis::from_redis_value(std::mem::take(&mut replies[index]))
+                        .map_err(|_| Error::Unavailable)
+                })
+                .collect()
         })
         .await
     }

litellm-rust/crates/cache-redis/tests/cluster.rs

@@ -0,0 +1,492 @@
+//! Contract tests against a real Redis Cluster. Set `LITELLM_TEST_REDIS_CLUSTER_NODES` to a
+//! comma separated `host:port` list (for example `127.0.0.1:7000,127.0.0.1:7001`) to run them.
+
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use litellm_cache::{
+    BaseCache, BatchCache, BatchEntry, CacheConnectionStatus, CacheScript, ClaimCache,
+    CounterCache, DeleteCache, Error, ExactCacheContext, FlushCache, IncrementOperation, JsonCodec,
+    ScriptCache,
+};
+use litellm_cache_redis::{
+    RedisArg, RedisCache, RedisLpopOperation, RedisLpopResult, RedisNode, RedisRpushOperation,
+    RedisTopology,
+};
+use redis::cluster_routing::Slot;
+
+type Cache = RedisCache<JsonCodec<serde_json::Value>>;
+
+fn topology() -> Option<RedisTopology> {
+    let nodes = std::env::var("LITELLM_TEST_REDIS_CLUSTER_NODES").ok()?;
+    let startup_nodes = nodes
+        .split(',')
+        .map(|node| {
+            let (host, port) = node.trim().rsplit_once(':').expect("host:port");
+            RedisNode {
+                host: host.to_string(),
+                port: port.parse().expect("port"),
+            }
+        })
+        .collect();
+    Some(RedisTopology::Cluster { startup_nodes })
+}
+
+fn namespace(label: &str) -> String {
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    format!("cluster-test:{label}:{nanos}")
+}
+
+fn cluster_url() -> String {
+    std::env::var("LITELLM_TEST_REDIS_CLUSTER_URL")
+        .unwrap_or_else(|_| "redis://127.0.0.1:7000".into())
+}
+
+fn cluster_cache(label: &str) -> Option<Cache> {
+    let topology = topology()?;
+    Some(
+        Cache::connect(
+            &cluster_url(),
+            &topology,
+            Some(Duration::from_secs(120)),
+            JsonCodec::new(),
+        )
+        .expect("cluster connection")
+        .with_namespace(Some(namespace(label))),
+    )
+}
+
+fn counter_cache(label: &str) -> Option<RedisCache<JsonCodec<f64>>> {
+    let topology = topology()?;
+    Some(
+        RedisCache::connect(
+            &cluster_url(),
+            &topology,
+            Some(Duration::from_secs(60)),
+            JsonCodec::new(),
+        )
+        .expect("cluster connection")
+        .with_namespace(Some(namespace(label))),
+    )
+}
+
+fn multi_slot_keys(count: usize) -> Vec<String> {
+    let keys: Vec<String> = (0..count).map(|index| format!("key-{index}")).collect();
+    let slots: std::collections::HashSet<Slot> = keys.iter().map(Slot::for_key).collect();
+    assert!(slots.len() > 1, "keys must span multiple slots");
+    keys
+}
+
+macro_rules! cluster_or_skip {
+    ($label:expr) => {
+        match cluster_cache($label) {
+            Some(cache) => cache,
+            None => return,
+        }
+    };
+}
+
+#[test]
+fn constructor_rejects_clusters_without_startup_nodes() {
+    let error = Cache::connect(
+        "redis://127.0.0.1:7000",
+        &RedisTopology::Cluster {
+            startup_nodes: Vec::new(),
+        },
+        None,
+        JsonCodec::new(),
+    )
+    .err();
+    assert!(matches!(error, Some(Error::Unavailable)));
+}
+
+#[test]
+fn constructor_rejects_unix_socket_urls_for_clusters() {
+    let error = Cache::connect(
+        "redis+unix:///tmp/redis.sock",
+        &RedisTopology::Cluster {
+            startup_nodes: vec![RedisNode {
+                host: "127.0.0.1".into(),
+                port: 7000,
+            }],
+        },
+        None,
+        JsonCodec::new(),
+    )
+    .err();
+    assert!(matches!(error, Some(Error::Unavailable)));
+}
+
+#[test]
+fn single_key_operations_round_trip_with_ttl_rounding() {
+    let cache = cluster_or_skip!("single");
+    let context = ExactCacheContext {
+        ttl: Some(Duration::from_millis(1500)),
+    };
+    let keys = multi_slot_keys(12);
+    for (index, key) in keys.iter().enumerate() {
+        cache
+            .set_cache(key, serde_json::json!({ "index": index }), &context)
+            .unwrap();
+    }
+    for (index, key) in keys.iter().enumerate() {
+        assert_eq!(
+            cache.get_cache(key, &context).unwrap(),
+            Some(serde_json::json!({ "index": index }))
+        );
+    }
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let ttl = runtime.block_on(cache.async_get_ttl(&keys[0])).unwrap();
+    assert_eq!(ttl, Some(2));
+    cache.delete_cache(&keys[0]).unwrap();
+    assert_eq!(cache.get_cache(&keys[0], &context).unwrap(), None);
+    assert!(cache.sync_ping().unwrap());
+}
+
+#[tokio::test]
+async fn batch_reads_span_slots_and_preserve_order_with_malformed_entries() {
+    let cache = cluster_or_skip!("batch");
+    let context = ExactCacheContext::default();
+    let keys = multi_slot_keys(40);
+    for (index, key) in keys.iter().enumerate() {
+        if index % 5 == 0 {
+            continue;
+        }
+        cache
+            .async_set_cache(key, serde_json::json!(index), context.clone())
+            .await
+            .unwrap();
+    }
+    let mut raw = redis::cluster::ClusterClient::new(vec![cluster_url()])
+        .unwrap()
+        .get_connection()
+        .unwrap();
+    let malformed = format!("{}:{}", cache.namespace().unwrap(), keys[1]);
+    redis::cmd("SET")
+        .arg(&malformed)
+        .arg("not json")
+        .exec(&mut raw)
+        .unwrap();
+
+    let entries = cache
+        .async_batch_get_cache(keys.clone(), context.clone())
+        .await
+        .unwrap();
+    assert_eq!(entries.len(), keys.len());
+    for (index, entry) in entries.iter().enumerate() {
+        let expected = if index == 1 {
+            BatchEntry::Invalid
+        } else if index % 5 == 0 {
+            BatchEntry::Miss
+        } else {
+            BatchEntry::Hit(serde_json::json!(index))
+        };
+        assert_eq!(*entry, expected, "entry {index}");
+    }
+    let sync_entries = cache.batch_get_cache(&keys, &context).unwrap();
+    assert_eq!(sync_entries, entries);
+
+    cache.delete_cache_keys(keys.clone()).await.unwrap();
+    let entries = cache.async_batch_get_cache(keys, context).await.unwrap();
+    assert!(entries.iter().all(|entry| *entry == BatchEntry::Miss));
+}
+
+#[tokio::test]
+async fn pipelines_group_by_slot_and_return_results_in_submission_order() {
+    let cache = cluster_or_skip!("pipeline");
+    let keys = multi_slot_keys(30);
+    let entries = keys
+        .iter()
+        .enumerate()
+        .map(|(index, key)| (key.clone(), serde_json::json!(index)))
+        .collect();
+    cache
+        .async_set_cache_pipeline(entries, ExactCacheContext::default())
+        .await
+        .unwrap();
+    let hits = cache
+        .async_batch_get_cache(keys.clone(), ExactCacheContext::default())
+        .await
+        .unwrap();
+    assert!(
+        hits.iter()
+            .enumerate()
+            .all(|(index, entry)| *entry == BatchEntry::Hit(serde_json::json!(index)))
+    );
+
+    let queues: Vec<String> = keys.iter().map(|key| format!("queue:{key}")).collect();
+    let pushed = cache
+        .async_rpush_pipeline(
+            queues
+                .iter()
+                .enumerate()
+                .map(|(index, key)| RedisRpushOperation {
+                    key: key.clone(),
+                    values: (0..=index)
+                        .map(|value| RedisArg::Integer(value as i64))
+                        .collect(),
+                })
+                .collect(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(pushed, (1..=keys.len()).collect::<Vec<_>>());
+    let popped = cache
+        .async_lpop_pipeline(
+            queues
+                .iter()
+                .enumerate()
+                .map(|(index, key)| RedisLpopOperation {
+                    key: key.clone(),
+                    count: (index % 2 == 0).then_some(2),
+                })
+                .collect(),
+        )
+        .await
+        .unwrap();
+    for (index, result) in popped.into_iter().enumerate() {
+        match result {
+            RedisLpopResult::Value(value) => {
+                assert_eq!(index % 2, 1, "queue {index}");
+                assert_eq!(value, b"0");
+            }
+            RedisLpopResult::Values(values) => {
+                assert_eq!(index % 2, 0, "queue {index}");
+                let expected: Vec<Vec<u8>> = (0..=index)
+                    .take(2)
+                    .map(|value| value.to_string().into_bytes())
+                    .collect();
+                assert_eq!(values, expected);
+            }
+            other => panic!("queue {index}: {other:?}"),
+        }
+    }
+
+    let counters: Vec<String> = keys.iter().map(|key| format!("counter:{key}")).collect();
+    let Some(counter) = counter_cache("counter") else {
+        return;
+    };
+    let totals = counter
+        .async_increment_pipeline(
+            counters
+                .iter()
+                .enumerate()
+                .map(|(index, key)| IncrementOperation {
+                    key: key.clone(),
+                    amount: index as f64 + 0.5,
+                    ttl: (index % 3 == 0).then_some(Duration::from_secs(30)),
+                })
+                .collect(),
+        )
+        .await
+        .unwrap();
+    let expected: Vec<f64> = (0..keys.len()).map(|index| index as f64 + 0.5).collect();
+    assert_eq!(totals, expected);
+    assert_eq!(counter.async_get_ttl(&counters[0]).await.unwrap(), Some(30));
+    assert_eq!(counter.async_get_ttl(&counters[1]).await.unwrap(), None);
+    counter.async_flush_cache().await.unwrap();
+    cache.async_flush_cache().await.unwrap();
+}
+
+#[tokio::test]
+async fn scan_and_scoped_flush_cover_every_primary() {
+    let cache = cluster_or_skip!("flush");
+    let other = cluster_or_skip!("other");
+    let context = ExactCacheContext::default();
+    let keys = multi_slot_keys(60);
+    for key in &keys {
+        cache
+            .async_set_cache(key, serde_json::json!(true), context.clone())
+            .await
+            .unwrap();
+        other
+            .async_set_cache(key, serde_json::json!(true), context.clone())
+            .await
+            .unwrap();
+    }
+    let mut scanned = cache.async_scan_iter("key-", 1000).await.unwrap();
+    scanned.sort();
+    let mut expected: Vec<String> = keys
+        .iter()
+        .map(|key| format!("{}:{key}", cache.namespace().unwrap()))
+        .collect();
+    expected.sort();
+    assert_eq!(scanned, expected);
+    assert_eq!(cache.async_scan_iter("key-", 7).await.unwrap().len(), 7);
+
+    cache.flush_cache().unwrap();
+    let flushed = cache
+        .async_batch_get_cache(keys.clone(), context.clone())
+        .await
+        .unwrap();
+    assert!(flushed.iter().all(|entry| *entry == BatchEntry::Miss));
+    let kept = other.async_batch_get_cache(keys, context).await.unwrap();
+    assert!(
+        kept.iter()
+            .all(|entry| *entry == BatchEntry::Hit(serde_json::json!(true)))
+    );
+    other.async_flush_cache().await.unwrap();
+}
+
+fn ping_calls_per_node(startup: &redis::Client) -> Vec<(String, u64)> {
+    let mut connection = startup.get_connection().unwrap();
+    let nodes: String = redis::cmd("CLUSTER")
+        .arg("NODES")
+        .query(&mut connection)
+        .unwrap();
+    let mut counts: Vec<(String, u64)> = nodes
+        .lines()
+        .map(|line| {
+            let address = line.split_whitespace().nth(1).unwrap();
+            let address = address.split('@').next().unwrap();
+            let mut node = redis::Client::open(format!("redis://{address}"))
+                .unwrap()
+                .get_connection()
+                .unwrap();
+            let stats: String = redis::cmd("INFO")
+                .arg("commandstats")
+                .query(&mut node)
+                .unwrap();
+            let calls = stats
+                .lines()
+                .find_map(|stat| stat.strip_prefix("cmdstat_ping:calls="))
+                .and_then(|rest| rest.split(',').next())
+                .map_or(0, |calls| calls.parse().unwrap());
+            (address.to_string(), calls)
+        })
+        .collect();
+    counts.sort();
+    counts
+}
+
+#[tokio::test]
+async fn ping_reaches_every_node() {
+    let cache = cluster_or_skip!("ping");
+    let startup = redis::Client::open(cluster_url()).unwrap();
+    let before = ping_calls_per_node(&startup);
+    assert!(before.len() >= 2, "{before:?}");
+    assert!(cache.ping().await.unwrap());
+    let after = ping_calls_per_node(&startup);
+    for ((node, calls_before), (_, calls_after)) in before.iter().zip(&after) {
+        assert!(calls_after > calls_before, "{node} was not pinged");
+    }
+    assert!(cache.sync_ping().unwrap());
+    let result = cache.test_connection().await.unwrap();
+    assert_eq!(result.status, CacheConnectionStatus::Success);
+}
+
+#[tokio::test]
+async fn counters_claims_scripts_and_sets_work_on_the_cluster() {
+    let Some(counter) = counter_cache("counter") else {
+        return;
+    };
+    let context = ExactCacheContext::default();
+    assert_eq!(
+        counter
+            .increment_cache("spend", 1.5, context.clone())
+            .unwrap(),
+        1.5
+    );
+    assert_eq!(
+        counter
+            .async_increment("spend", 2.0, context.clone())
+            .await
+            .unwrap(),
+        3.5
+    );
+    assert_eq!(
+        counter
+            .increment_with_floor("budget", -3, Duration::from_secs(30))
+            .unwrap(),
+        0
+    );
+    assert_eq!(
+        counter
+            .async_increment_with_floor("budget", 7, Duration::from_secs(30))
+            .await
+            .unwrap(),
+        7
+    );
+    assert_eq!(counter.async_set_max("peak", 4.0, None).await.unwrap(), 4.0);
+    assert_eq!(counter.async_set_max("peak", 2.0, None).await.unwrap(), 4.0);
+    counter.flush_cache().unwrap();
+
+    let cache = cluster_or_skip!("claim");
+    let owner = serde_json::json!("owner-a");
+    let rival = serde_json::json!("owner-b");
+    assert_eq!(
+        cache
+            .claim_cache("lock", owner.clone(), &[], context.clone())
+            .unwrap(),
+        owner
+    );
+    assert_eq!(
+        cache
+            .async_claim_cache("lock", rival.clone(), vec![owner.clone()], context.clone())
+            .await
+            .unwrap(),
+        owner
+    );
+    assert_eq!(
+        cache
+            .claim_cache("lock", rival.clone(), &[], context.clone())
+            .unwrap(),
+        owner
+    );
+    assert_eq!(
+        cache
+            .async_claim_cache("lock", rival.clone(), vec![rival.clone()], context.clone())
+            .await
+            .unwrap(),
+        rival
+    );
+
+    let script = cache
+        .async_register_script("return redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[2])".into());
+    let reply = script
+        .invoke(
+            vec!["scripted".into()],
+            vec![RedisArg::Bytes(b"payload".to_vec()), RedisArg::Integer(5)],
+        )
+        .await
+        .unwrap();
+    assert_eq!(reply, redis::Value::Okay);
+    assert_eq!(cache.async_get_ttl("scripted").await.unwrap(), Some(5));
+    let evaluated: redis::Value = cache
+        .async_eval(
+            "return redis.call('GET', KEYS[1])".into(),
+            vec!["scripted".into()],
+            Vec::new(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(evaluated, redis::Value::BulkString(b"payload".to_vec()));
+
+    assert_eq!(
+        cache
+            .async_set_cache_sadd(
+                "members",
+                vec![
+                    RedisArg::Bytes(b"a".to_vec()),
+                    RedisArg::Bytes(b"b".to_vec())
+                ],
+                Some(Duration::from_secs(9)),
+            )
+            .await
+            .unwrap(),
+        2
+    );
+    assert_eq!(cache.async_get_ttl("members").await.unwrap(), Some(9));
+
+    let result = cache.test_connection().await.unwrap();
+    assert_eq!(result.status, CacheConnectionStatus::Success);
+    assert!(cache.ping().await.unwrap());
+    let info = cache.info().unwrap();
+    assert!(info.matches("redis_version").count() > 1, "{info}");
+    assert!(cache.client_list().unwrap().contains("id="));
+    cache.async_flush_cache().await.unwrap();
+    assert_eq!(cache.async_get_ttl("members").await.unwrap(), None);
+    assert_eq!(cache.get_cache("lock", &context).unwrap(), None);
+}

litellm-rust/crates/python-bridge/src/cache/config.rs

@@ -1,10 +1,11 @@
 use std::time::Duration;
 
 use litellm_cache::CacheType;
+use litellm_cache_redis::{RedisNode, RedisTopology};
 use pyo3::{
     exceptions::{PyTypeError, PyValueError},
     prelude::*,
-    types::{PyAny, PyDict, PyString},
+    types::{PyAny, PyDict, PyList, PyString},
 };
 
 use super::{native::NativeResponseCache, request::duration};
@@ -70,6 +71,7 @@ pub(super) struct RedisCacheConfig {
     pub(super) default_ttl: Duration,
     pub(super) namespace: Option<String>,
     pub(super) flush_size: usize,
+    pub(super) topology: RedisTopology,
     pub(super) connection: RedisConnectionConfig,
 }
 
@@ -80,6 +82,17 @@ pub(super) struct GcsCacheConfig {
     pub(super) path_service_account: Option<String>,
 }
 
+struct RedisClientProjection<'py> {
+    topology: RedisTopology,
+    host: String,
+    port: u16,
+    pool_size: usize,
+    resolved: Bound<'py, PyDict>,
+    tls: Option<RedisTlsConfig>,
+}
+
+const REDIS_PY_DEFAULT_MAX_CONNECTIONS: usize = 1 << 31;
+
 pub(super) enum CacheBackendConfig {
     Memory(MemoryCacheConfig),
     Redis(Box<RedisCacheConfig>),
@@ -198,6 +211,9 @@ impl NativeCacheConfig {
             CacheBackendConfig::Redis(_) if service.kind() != "redis" => {
                 Some("facade and native backend types must match")
             }
+            CacheBackendConfig::Redis(config) if service.topology() != Some(&config.topology) => {
+                Some("facade and native backend topologies must match")
+            }
             CacheBackendConfig::Redis(config) => (service.namespace()
                 != config.namespace.as_deref())
             .then_some("facade and native backend namespaces must match"),
@@ -264,9 +280,6 @@ fn project_redis(
     backend: &Bound<'_, PyAny>,
 ) -> PyResult<Result<RedisCacheConfig, UnsupportedCacheConfig>> {
     let source = backend.getattr("redis_kwargs")?.cast_into::<PyDict>()?;
-    if has_value(&source, "startup_nodes")? {
-        return Ok(Err(UnsupportedCacheConfig::RedisTopology));
-    }
     if has_value(&source, "sentinel_nodes")? {
         return Ok(Err(UnsupportedCacheConfig::RedisTopology));
     }
@@ -306,26 +319,25 @@ fn project_redis(
     }
 
     let client = backend.getattr("redis_client")?;
-    let pool = client.getattr("connection_pool")?;
-    if !instance_class_is(&pool, "redis.connection", "ConnectionPool")? {
-        return Ok(Err(UnsupportedCacheConfig::RedisConnection));
-    }
-    let resolved = pool.getattr("connection_kwargs")?.cast_into::<PyDict>()?;
-    for key in ["credential_provider", "redis_connect_func"] {
-        if has_value(&resolved, key)? {
-            return Ok(Err(UnsupportedCacheConfig::RedisCredentials));
-        }
-    }
-    let connection_class = resolved
-        .get_item("connection_class")?
-        .unwrap_or(pool.getattr("connection_class")?);
-    let tls = if class_is(&connection_class, "redis.connection", "Connection")? {
-        None
-    } else if class_is(&connection_class, "redis.connection", "SSLConnection")? {
-        Some(project_tls(&resolved)?)
+    let projection = if has_value(&source, "startup_nodes")? {
+        project_cluster_client(&source, &client)?
     } else {
-        return Ok(Err(UnsupportedCacheConfig::RedisConnection));
+        project_standalone_client(&client)?
     };
+    let RedisClientProjection {
+        topology,
+        host,
+        port,
+        pool_size,
+        resolved,
+        tls,
+    } = match projection {
+        Ok(projection) => projection,
+        Err(reason) => return Ok(Err(reason)),
+    };
+    if has_value(&resolved, "credential_provider")? {
+        return Ok(Err(UnsupportedCacheConfig::RedisCredentials));
+    }
 
     let protocol = match optional_i64(&resolved, "protocol")?.unwrap_or(2) {
         2 => RedisProtocol::Resp2,
@@ -338,15 +350,15 @@ fn project_redis(
         default_ttl: duration(backend.getattr("default_ttl")?.extract::<f64>()?)?,
         namespace: optional_attribute_string(backend, "namespace")?,
         flush_size: backend.getattr("redis_flush_size")?.extract::<usize>()?,
+        topology,
         connection: RedisConnectionConfig {
-            host: required_string(&resolved, "host")?,
-            port: u16::try_from(required_i64(&resolved, "port")?)
-                .map_err(|_| PyValueError::new_err("invalid Redis port"))?,
+            host,
+            port,
             database: optional_i64(&resolved, "db")?.unwrap_or(0),
             username: optional_dict_string(&resolved, "username")?,
             password: optional_dict_string(&resolved, "password")?,
             protocol,
-            pool_size: pool.getattr("max_connections")?.extract::<usize>()?,
+            pool_size,
             read_timeout: optional_dict_duration(&resolved, "socket_timeout")?,
             connect_timeout: optional_dict_duration(&resolved, "socket_connect_timeout")?,
             socket_keepalive: optional_bool(&resolved, "socket_keepalive")?,
@@ -357,6 +369,128 @@ fn project_redis(
     }))
 }
 
+#[inline(never)]
+fn project_standalone_client<'py>(
+    client: &Bound<'py, PyAny>,
+) -> PyResult<Result<RedisClientProjection<'py>, UnsupportedCacheConfig>> {
+    let pool = client.getattr("connection_pool")?;
+    if !instance_class_is(&pool, "redis.connection", "ConnectionPool")? {
+        return Ok(Err(UnsupportedCacheConfig::RedisConnection));
+    }
+    let resolved = pool.getattr("connection_kwargs")?.cast_into::<PyDict>()?;
+    if has_value(&resolved, "redis_connect_func")? {
+        return Ok(Err(UnsupportedCacheConfig::RedisCredentials));
+    }
+    let connection_class = resolved
+        .get_item("connection_class")?
+        .unwrap_or(pool.getattr("connection_class")?);
+    let tls = if class_is(&connection_class, "redis.connection", "Connection")? {
+        None
+    } else if class_is(&connection_class, "redis.connection", "SSLConnection")? {
+        Some(project_tls(&resolved)?)
+    } else {
+        return Ok(Err(UnsupportedCacheConfig::RedisConnection));
+    };
+    Ok(Ok(RedisClientProjection {
+        topology: RedisTopology::Standalone,
+        host: required_string(&resolved, "host")?,
+        port: port(required_i64(&resolved, "port")?)?,
+        pool_size: pool.getattr("max_connections")?.extract::<usize>()?,
+        resolved,
+        tls,
+    }))
+}
+
+#[inline(never)]
+fn project_cluster_client<'py>(
+    source: &Bound<'py, PyDict>,
+    client: &Bound<'py, PyAny>,
+) -> PyResult<Result<RedisClientProjection<'py>, UnsupportedCacheConfig>> {
+    let Some(startup_nodes) = startup_nodes(source)? else {
+        return Ok(Err(UnsupportedCacheConfig::RedisTopology));
+    };
+    if !instance_class_is(client, "redis.cluster", "RedisCluster")? {
+        return Ok(Err(UnsupportedCacheConfig::RedisConnection));
+    }
+    let nodes = client.getattr("nodes_manager")?;
+    if !class_is(
+        &nodes.getattr("connection_pool_class")?,
+        "redis.connection",
+        "ConnectionPool",
+    )? {
+        return Ok(Err(UnsupportedCacheConfig::RedisConnection));
+    }
+    let resolved = nodes.getattr("connection_kwargs")?.cast_into::<PyDict>()?;
+    if let Some(connect) = resolved.get_item("redis_connect_func")?
+        && !connect.is_none()
+    {
+        let own_hook = connect
+            .getattr("__self__")
+            .is_ok_and(|owner| owner.is(client))
+            && connect
+                .getattr("__func__")
+                .and_then(|function| Ok(function.is(&client.get_type().getattr("on_connect")?)))
+                .unwrap_or(false);
+        if !own_hook {
+            return Ok(Err(UnsupportedCacheConfig::RedisCredentials));
+        }
+    }
+    let tls = if optional_bool(&resolved, "ssl")?.unwrap_or(false) {
+        Some(project_tls(&resolved)?)
+    } else {
+        None
+    };
+    let first = &startup_nodes[0];
+    Ok(Ok(RedisClientProjection {
+        host: first.host.clone(),
+        port: first.port,
+        pool_size: optional_i64(&resolved, "max_connections")?
+            .map(|value| {
+                usize::try_from(value).map_err(|_| PyValueError::new_err("invalid Redis pool size"))
+            })
+            .transpose()?
+            .unwrap_or(REDIS_PY_DEFAULT_MAX_CONNECTIONS),
+        topology: RedisTopology::Cluster { startup_nodes },
+        resolved,
+        tls,
+    }))
+}
+
+#[inline(never)]
+fn startup_nodes(source: &Bound<'_, PyDict>) -> PyResult<Option<Vec<RedisNode>>> {
+    let Some(nodes) = source.get_item("startup_nodes")? else {
+        return Ok(None);
+    };
+    let Ok(nodes) = nodes.cast_into::<PyList>() else {
+        return Ok(None);
+    };
+    if nodes.is_empty() {
+        return Ok(None);
+    }
+    let mut parsed = Vec::with_capacity(nodes.len());
+    for node in nodes.iter() {
+        let Ok(node) = node.cast_into::<PyDict>() else {
+            return Ok(None);
+        };
+        if node.len() != 2 || !has_value(&node, "host")? || !has_value(&node, "port")? {
+            return Ok(None);
+        }
+        let (Ok(host), Ok(port)) = (
+            required_string(&node, "host"),
+            required_i64(&node, "port").and_then(port),
+        ) else {
+            return Ok(None);
+        };
+        parsed.push(RedisNode { host, port });
+    }
+    Ok(Some(parsed))
+}
+
+#[inline(never)]
+fn port(value: i64) -> PyResult<u16> {
+    u16::try_from(value).map_err(|_| PyValueError::new_err("invalid Redis port"))
+}
+
 #[inline(never)]
 fn project_tls(values: &Bound<'_, PyDict>) -> PyResult<RedisTlsConfig> {
     Ok(RedisTlsConfig {
@@ -525,12 +659,27 @@ mod tests {
 
     use pyo3::{prelude::*, types::PyDict};
 
+    use litellm_cache_redis::{RedisNode, RedisTopology};
+
     use super::{
         CacheBackendConfig, CacheConfigProjection, CertificateRequirement, GcsCacheConfig,
         NativeCacheConfig, RedisProtocol, UnsupportedCacheConfig,
     };
     use crate::cache::native::NativeResponseCache;
 
+    fn cluster_facade<'py>(py: Python<'py>, startup_nodes: &str, hook: &str) -> Bound<'py, PyAny> {
+        facade(
+            py,
+            &format!(
+                "RedisCluster = type('RedisCluster', (), {{'__module__': 'redis.cluster', 'on_connect': lambda self, connection: None}})\n\
+                 client = RedisCluster()\n\
+                 client.nodes_manager = SimpleNamespace(connection_pool_class=ConnectionPool, connection_kwargs={{'password': 'secret', 'redis_connect_func': {hook}, 'protocol': 3, 'ssl': True, 'ssl_cert_reqs': 'none'}})\n\
+                 backend = SimpleNamespace(default_ttl=120, namespace='team', redis_flush_size=100, redis_kwargs={{'startup_nodes': {startup_nodes}, 'password': 'secret'}}, redis_client=client)\n\
+                 facade = SimpleNamespace(type='redis', mode='default-on', ttl=None, namespace='team', supported_call_types=None, redis_flush_size=100, semantic_cache_scope='key', cache=backend)"
+            ),
+        )
+    }
+
     fn facade<'py>(py: Python<'py>, body: &str) -> Bound<'py, PyAny> {
         let locals = PyDict::new(py);
         py.run(
@@ -714,4 +863,87 @@ mod tests {
             assert_eq!(reason.message(), "native Redis credentials require Python");
         });
     }
+
+    #[test]
+    fn projects_cluster_startup_nodes_as_redis_topology() {
+        Python::initialize();
+        Python::attach(|py| {
+            let facade = cluster_facade(
+                py,
+                "[{'host': 'node-a', 'port': 7000}, {'host': 'node-b', 'port': 7001}]",
+                "client.on_connect",
+            );
+            let CacheConfigProjection::Native(config) =
+                NativeCacheConfig::project(&facade).unwrap()
+            else {
+                panic!("cluster startup nodes should project natively");
+            };
+            let CacheBackendConfig::Redis(redis) = &config.backend else {
+                panic!("expected Redis configuration");
+            };
+            let expected = RedisTopology::Cluster {
+                startup_nodes: vec![
+                    RedisNode {
+                        host: "node-a".into(),
+                        port: 7000,
+                    },
+                    RedisNode {
+                        host: "node-b".into(),
+                        port: 7001,
+                    },
+                ],
+            };
+            assert_eq!(redis.topology, expected);
+            assert_eq!(redis.connection.host, "node-a");
+            assert_eq!(redis.connection.port, 7000);
+            assert_eq!(redis.connection.password.as_deref(), Some("secret"));
+            assert_eq!(redis.connection.protocol, RedisProtocol::Resp3);
+            assert_eq!(
+                redis
+                    .connection
+                    .tls
+                    .as_ref()
+                    .unwrap()
+                    .certificate_requirement,
+                CertificateRequirement::None
+            );
+        });
+    }
+
+    #[test]
+    fn malformed_startup_nodes_and_foreign_connect_hooks_stay_on_python() {
+        Python::initialize();
+        Python::attach(|py| {
+            for (startup_nodes, hook, message) in [
+                (
+                    "[{'host': 'node-a', 'port': 7000, 'server_type': 'primary'}]",
+                    "client.on_connect",
+                    "native Redis topology is not implemented",
+                ),
+                (
+                    "[{'host': 'node-a', 'port': 'seven'}]",
+                    "client.on_connect",
+                    "native Redis topology is not implemented",
+                ),
+                (
+                    "[]",
+                    "client.on_connect",
+                    "native Redis topology is not implemented",
+                ),
+                (
+                    "[{'host': 'node-a', 'port': 7000}]",
+                    "lambda connection: None",
+                    "native Redis credentials require Python",
+                ),
+            ] {
+                let facade = cluster_facade(py, startup_nodes, hook);
+                let CacheConfigProjection::Unsupported(reason) =
+                    NativeCacheConfig::project(&facade).unwrap()
+                else {
+                    panic!("{startup_nodes} with {hook} must stay on Python");
+                };
+                assert_eq!(reason.message(), message, "{startup_nodes} with {hook}");
+            }
+        });
+    }
 }

litellm-rust/crates/python-bridge/src/cache/facade.rs

@@ -1,3 +1,4 @@
+use litellm_cache_redis::RedisTopology;
 use litellm_host_python::from_py;
 use pyo3::{
     PyTraverseError, PyVisit,
@@ -29,9 +30,28 @@ struct RedisPoolGuard {
     reference: Py<PyAny>,
     connection_class: Py<PyAny>,
     connection_kwargs: Py<PyAny>,
-    max_connections: usize,
+    max_connections: Option<usize>,
+    attributes: RedisPoolAttributes,
 }
 
+struct RedisPoolAttributes {
+    pool: &'static str,
+    connection_class: &'static str,
+    max_connections: Option<&'static str>,
+}
+
+const STANDALONE_POOL: RedisPoolAttributes = RedisPoolAttributes {
+    pool: "connection_pool",
+    connection_class: "connection_class",
+    max_connections: Some("max_connections"),
+};
+
+const CLUSTER_POOL: RedisPoolAttributes = RedisPoolAttributes {
+    pool: "nodes_manager",
+    connection_class: "connection_pool_class",
+    max_connections: None,
+};
+
 pub(super) struct FacadeGuard {
     outer: ObjectGuard,
     backend: ObjectGuard,
@@ -138,31 +158,40 @@ impl ObjectGuard {
 }
 
 impl RedisPoolGuard {
-    fn capture(backend: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let pool = backend
-            .getattr("redis_client")?
-            .getattr("connection_pool")?;
+    fn capture(backend: &Bound<'_, PyAny>, attributes: RedisPoolAttributes) -> PyResult<Self> {
+        let pool = backend.getattr("redis_client")?.getattr(attributes.pool)?;
         Ok(Self {
             reference: pool.clone().unbind(),
-            connection_class: pool.getattr("connection_class")?.unbind(),
+            connection_class: pool.getattr(attributes.connection_class)?.unbind(),
             connection_kwargs: pool
                 .getattr("connection_kwargs")?
                 .call_method0("copy")?
                 .unbind(),
-            max_connections: pool.getattr("max_connections")?.extract::<usize>()?,
+            max_connections: Self::max_connections(&pool, &attributes)?,
+            attributes,
         })
     }
 
+    fn max_connections(
+        pool: &Bound<'_, PyAny>,
+        attributes: &RedisPoolAttributes,
+    ) -> PyResult<Option<usize>> {
+        attributes
+            .max_connections
+            .map(|name| pool.getattr(name)?.extract::<usize>())
+            .transpose()
+    }
+
     fn matches(&self, py: Python<'_>, backend: &Bound<'_, PyAny>) -> PyResult<bool> {
         let pool = backend
             .getattr("redis_client")?
-            .getattr("connection_pool")?;
+            .getattr(self.attributes.pool)?;
         Ok(self.reference.bind(py).is(&pool)
             && self
                 .connection_class
                 .bind(py)
-                .is(&pool.getattr("connection_class")?)
-            && self.max_connections == pool.getattr("max_connections")?.extract::<usize>()?
+                .is(&pool.getattr(self.attributes.connection_class)?)
+            && self.max_connections == Self::max_connections(&pool, &self.attributes)?
             && self
                 .connection_kwargs
                 .bind(py)
@@ -189,10 +218,16 @@ impl FacadeGuard {
                 "only exact built-in Cache facades can be registered",
             ));
         }
-        let (module, name, cache_kind) = match kind {
-            "memory" => ("litellm.caching.in_memory_cache", "InMemoryCache", "local"),
-            "redis" => ("litellm.caching.redis_cache", "RedisCache", "redis"),
-            "gcs" => ("litellm.caching.gcs_cache", "GCSCache", "gcs"),
+        let cluster = matches!(service.topology(), Some(RedisTopology::Cluster { .. }));
+        let (module, name, cache_kind) = match (kind, cluster) {
+            ("memory", _) => ("litellm.caching.in_memory_cache", "InMemoryCache", "local"),
+            ("redis", false) => ("litellm.caching.redis_cache", "RedisCache", "redis"),
+            ("redis", true) => (
+                "litellm.caching.redis_cluster_cache",
+                "RedisClusterCache",
+                "redis",
+            ),
+            ("gcs", _) => ("litellm.caching.gcs_cache", "GCSCache", "gcs"),
             _ => unreachable!(),
         };
         let backend = facade.getattr("cache")?;
@@ -241,9 +276,11 @@ impl FacadeGuard {
                     "path_service_account",
                 ],
             )?,
-            redis_pool: (kind == "redis")
-                .then(|| RedisPoolGuard::capture(&backend))
-                .transpose()?,
+            redis_pool: match (kind, cluster) {
+                ("redis", false) => Some(RedisPoolGuard::capture(&backend, STANDALONE_POOL)?),
+                ("redis", true) => Some(RedisPoolGuard::capture(&backend, CLUSTER_POOL)?),
+                _ => None,
+            },
         })
     }
 

litellm-rust/crates/python-bridge/src/cache/handle.rs

@@ -1,3 +1,4 @@
+use litellm_cache_redis::{RedisNode, RedisTopology};
 use litellm_host_python::release_gil;
 use pyo3::{PyTraverseError, PyVisit, exceptions::PyRuntimeError, prelude::*};
 
@@ -36,16 +37,28 @@ impl CacheTestHandle {
     }
 
     #[staticmethod]
-    #[pyo3(signature = (url, *, ttl_seconds=60.0, namespace=None))]
+    #[pyo3(signature = (url, *, ttl_seconds=60.0, namespace=None, startup_nodes=None))]
     fn redis(
         py: Python<'_>,
         url: String,
         ttl_seconds: f64,
         namespace: Option<String>,
+        startup_nodes: Option<Vec<(String, u16)>>,
     ) -> PyResult<Self> {
         let ttl = Some(duration(ttl_seconds)?);
-        let service = release_gil(py, move || NativeResponseCache::redis(&url, ttl, namespace))
-            .map_err(cache_error)?;
+        let topology = match startup_nodes {
+            None => RedisTopology::Standalone,
+            Some(nodes) => RedisTopology::Cluster {
+                startup_nodes: nodes
+                    .into_iter()
+                    .map(|(host, port)| RedisNode { host, port })
+                    .collect(),
+            },
+        };
+        let service = release_gil(py, move || {
+            NativeResponseCache::redis(&url, &topology, ttl, namespace)
+        })
+        .map_err(cache_error)?;
         Ok(Self {
             service,
             guard: None,

litellm-rust/crates/python-bridge/src/cache/native.rs

@@ -3,7 +3,7 @@ use std::{sync::Arc, time::Duration};
 use litellm_cache::{CacheCodec, CacheConnectionResult, Error};
 use litellm_cache_gcs::{GcsCache, GcsConfig, StaticTokenSource};
 use litellm_cache_memory::InMemoryCache;
-use litellm_cache_redis::RedisCache;
+use litellm_cache_redis::{RedisCache, RedisTopology};
 use litellm_cache_response::{
     CacheEntry, PartialHits, ResponseCache, ResponseCacheCodec, ResponseCacheRequest, WriteBuffer,
 };
@@ -36,10 +36,12 @@ impl NativeResponseCache {
 
     pub fn redis(
         url: &str,
+        topology: &RedisTopology,
         ttl: Option<Duration>,
         namespace: Option<String>,
     ) -> Result<Self, Error> {
-        let backend = RedisCache::new(url, ttl, ResponseCacheCodec)?.with_namespace(namespace);
+        let backend =
+            RedisCache::connect(url, topology, ttl, ResponseCacheCodec)?.with_namespace(namespace);
         Ok(Self::Redis {
             cache: Arc::new(ResponseCache::new(Arc::new(backend))),
             buffer: None,
@@ -84,6 +86,13 @@ impl NativeResponseCache {
         }
     }
 
+    pub fn topology(&self) -> Option<&RedisTopology> {
+        match self {
+            Self::Memory(_) | Self::Gcs(_) => None,
+            Self::Redis { cache, .. } => Some(cache.backend().topology()),
+        }
+    }
+
     pub fn capacity(&self) -> Option<usize> {
         match self {
             Self::Memory(cache) => Some(cache.backend().max_size_in_memory()),

litellm/__init__.py

@@ -689,6 +689,7 @@ recraft_models: Set = set()
 cometapi_models: Set = set()
 oci_models: Set = set()
 vercel_ai_gateway_models: Set = set()
+edenai_models: Set = set()  # mutable-ok: filled from the price map at import, like the sibling provider sets
 volcengine_models: Set = set()
 wandb_models: Set = set(WANDB_MODELS)
 ovhcloud_models: Set = set()
@@ -763,6 +764,8 @@ def _populate_provider_model_sets(model_cost_map: Dict) -> None:
             openrouter_models.add(key)
         elif value.get("litellm_provider") == "vercel_ai_gateway":
             vercel_ai_gateway_models.add(key)
+        elif value.get("litellm_provider") == "edenai":
+            edenai_models.add(key)
         elif value.get("litellm_provider") == "datarobot":
             datarobot_models.add(key)
         elif value.get("litellm_provider") == "vertex_ai-text-models":
@@ -1111,6 +1114,7 @@ model_list = list(
     | oci_models
     | heroku_models
     | vercel_ai_gateway_models
+    | edenai_models
     | volcengine_models
     | wandb_models
     | ovhcloud_models
@@ -1139,6 +1143,7 @@ def _build_models_by_provider() -> dict:
         "baseten": baseten_models,
         "openrouter": openrouter_models,
         "vercel_ai_gateway": vercel_ai_gateway_models,
+        "edenai": edenai_models,
         "datarobot": datarobot_models,
         "vertex_ai": vertex_chat_models
         | vertex_text_models
@@ -2117,6 +2122,30 @@ if TYPE_CHECKING:
     from .llms.vercel_ai_gateway.chat.transformation import (
         VercelAIGatewayConfig as VercelAIGatewayConfig,
     )
+    from .llms.edenai.chat.transformation import (
+        EdenAIChatConfig as EdenAIChatConfig,
+    )
+    from .llms.edenai.responses.transformation import (
+        EdenAIResponsesAPIConfig as EdenAIResponsesAPIConfig,
+    )
+    from .llms.edenai.messages.transformation import (
+        EdenAIAnthropicMessagesConfig as EdenAIAnthropicMessagesConfig,
+    )
+    from .llms.edenai.embedding.transformation import (
+        EdenAIEmbeddingConfig as EdenAIEmbeddingConfig,
+    )
+    from .llms.edenai.audio_transcription.transformation import (
+        EdenAIAudioTranscriptionConfig as EdenAIAudioTranscriptionConfig,
+    )
+    from .llms.edenai.text_to_speech.transformation import (
+        EdenAITextToSpeechConfig as EdenAITextToSpeechConfig,
+    )
+    from .llms.edenai.image_generation.transformation import (
+        EdenAIImageGenerationConfig as EdenAIImageGenerationConfig,
+    )
+    from .llms.edenai.videos.transformation import (
+        EdenAIVideoConfig as EdenAIVideoConfig,
+    )
     from .llms.ovhcloud.chat.transformation import (
         OVHCloudChatConfig as OVHCloudChatConfig,
     )

litellm/_lazy_imports_registry.py

@@ -327,6 +327,14 @@ LLM_CONFIG_NAMES: Final = (
     "InceptionChatConfig",
     "HyperbolicChatConfig",
     "VercelAIGatewayConfig",
+    "EdenAIChatConfig",
+    "EdenAIResponsesAPIConfig",
+    "EdenAIAnthropicMessagesConfig",
+    "EdenAIEmbeddingConfig",
+    "EdenAIAudioTranscriptionConfig",
+    "EdenAITextToSpeechConfig",
+    "EdenAIImageGenerationConfig",
+    "EdenAIVideoConfig",
     "OVHCloudChatConfig",
     "OVHCloudEmbeddingConfig",
     "CometAPIEmbeddingConfig",
@@ -1232,6 +1240,17 @@ _LLM_CONFIGS_IMPORT_MAP: Final = {
         ".llms.vercel_ai_gateway.chat.transformation",
         "VercelAIGatewayConfig",
     ),
+    "EdenAIChatConfig": (".llms.edenai.chat.transformation", "EdenAIChatConfig"),
+    "EdenAIResponsesAPIConfig": (".llms.edenai.responses.transformation", "EdenAIResponsesAPIConfig"),
+    "EdenAIAnthropicMessagesConfig": (".llms.edenai.messages.transformation", "EdenAIAnthropicMessagesConfig"),
+    "EdenAIEmbeddingConfig": (".llms.edenai.embedding.transformation", "EdenAIEmbeddingConfig"),
+    "EdenAIAudioTranscriptionConfig": (
+        ".llms.edenai.audio_transcription.transformation",
+        "EdenAIAudioTranscriptionConfig",
+    ),
+    "EdenAITextToSpeechConfig": (".llms.edenai.text_to_speech.transformation", "EdenAITextToSpeechConfig"),
+    "EdenAIImageGenerationConfig": (".llms.edenai.image_generation.transformation", "EdenAIImageGenerationConfig"),
+    "EdenAIVideoConfig": (".llms.edenai.videos.transformation", "EdenAIVideoConfig"),
     "OVHCloudChatConfig": (".llms.ovhcloud.chat.transformation", "OVHCloudChatConfig"),
     "OVHCloudEmbeddingConfig": (
         ".llms.ovhcloud.embedding.transformation",

litellm/anthropic_beta_headers_config.json

@@ -11,6 +11,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": "context-management-2025-06-27",
+    "dangerous-tool-use-2026-09-03": "dangerous-tool-use-2026-09-03",
     "effort-2025-11-24": "effort-2025-11-24",
     "fast-mode-2026-02-01": "fast-mode-2026-02-01",
     "files-api-2025-04-14": "files-api-2025-04-14",
@@ -44,6 +45,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": "context-management-2025-06-27",
+    "dangerous-tool-use-2026-09-03": null,
     "effort-2025-11-24": "effort-2025-11-24",
     "fast-mode-2026-02-01": null,
     "files-api-2025-04-14": "files-api-2025-04-14",
@@ -76,6 +78,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": null,
+    "dangerous-tool-use-2026-09-03": null,
     "effort-2025-11-24": "effort-2025-11-24",
     "fast-mode-2026-02-01": null,
     "files-api-2025-04-14": null,
@@ -109,6 +112,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": "context-management-2025-06-27",
+    "dangerous-tool-use-2026-09-03": "dangerous-tool-use-2026-09-03",
     "effort-2025-11-24": "effort-2025-11-24",
     "fast-mode-2026-02-01": null,
     "files-api-2025-04-14": null,
@@ -143,6 +147,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": "context-management-2025-06-27",
+    "dangerous-tool-use-2026-09-03": "dangerous-tool-use-2026-09-03",
     "effort-2025-11-24": "effort-2025-11-24",
     "fast-mode-2026-02-01": null,
     "files-api-2025-04-14": null,
@@ -177,6 +182,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": "context-management-2025-06-27",
+    "dangerous-tool-use-2026-09-03": "dangerous-tool-use-2026-09-03",
     "effort-2025-11-24": null,
     "fast-mode-2026-02-01": null,
     "files-api-2025-04-14": null,
@@ -210,6 +216,7 @@
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
     "context-management-2025-06-27": "context-management-2025-06-27",
+    "dangerous-tool-use-2026-09-03": null,
     "effort-2025-11-24": "effort-2025-11-24",
     "fast-mode-2026-02-01": "fast-mode-2026-02-01",
     "files-api-2025-04-14": "files-api-2025-04-14",

litellm/caching/redis_cache.py

@@ -80,6 +80,8 @@ class _AsyncRedisCommands(Protocol):
 
     def ttl(self, name: str) -> Awaitable[int]: ...
 
+    def expire(self, name: str, time: int) -> Awaitable[bool]: ...
+
     def rpush(self, name: str, *values: str | bytes | float) -> Awaitable[int]: ...
 
     def lpop(self, name: str, count: int | None = None) -> Awaitable[object]: ...
@@ -1948,6 +1950,14 @@ class RedisCache(BaseCache):
             _record_swallowed_redis_failure(self._circuit_breaker, e)
             return None
 
+    @_redis_circuit_breaker_guard
+    async def async_refresh_ttl(self, key: str, ttl: int | None = None) -> bool:
+        """EXPIRE an existing key without touching its value. False when the key is absent."""
+        _used_ttl: Final = self.get_ttl(ttl=ttl)
+        if _used_ttl is None:
+            return False
+        return await self._async_commands().expire(self.check_and_fix_namespace(key=key), _used_ttl)
+
     @_redis_circuit_breaker_guard
     async def async_rpush(
         self,

litellm/constants.py

@@ -750,6 +750,7 @@ LITELLM_CHAT_PROVIDERS: Final = [
     "inception",
     "vercel_ai_gateway",
     "wandb",
+    "edenai",
     "ovhcloud",
     "lemonade",
     "docker_model_runner",
@@ -925,6 +926,7 @@ openai_compatible_endpoints: Final[list] = [
     "https://api.hyperbolic.xyz/v1",
     "https://ai-gateway.helicone.ai/",
     "https://ai-gateway.vercel.sh/v1",
+    "https://api.edenai.run/v3",
     "https://api.inference.wandb.ai/v1",
     "https://api.clarifai.com/v2/ext/openai/v1",
     "https://api.libertai.io/v1",
@@ -994,6 +996,7 @@ openai_compatible_providers: Final[list] = [
     "hyperbolic",
     "vercel_ai_gateway",
     "aiml",
+    "edenai",
     "wandb",
     "cometapi",
     "clarifai",

litellm/images/main.py

@@ -388,6 +388,7 @@ def image_generation(
             litellm.LlmProviders.DASHSCOPE,
             litellm.LlmProviders.QWENCLOUD,
             litellm.LlmProviders.QWEN_AI_PLATFORM,
+            litellm.LlmProviders.EDENAI,
         ):
             if image_generation_config is None:
                 raise ValueError(f"image generation config is not supported for {custom_llm_provider}")

litellm/integrations/otel/model/payloads.py

@@ -427,7 +427,7 @@ class LLMCallSpanData:
         # plain ``.get`` — no repeated ``isinstance`` guards.
         raw_response: Final = payload.get("response")
         response: Final = cast(Mapping[str, object], raw_response if isinstance(raw_response, dict) else {})
-        choices_out: Final = _dicts(response.get("choices")) or _responses_choices(response)
+        choices_out: Final = _dicts(response.get("choices")) or _responses_choices(response) or _ocr_choices(response)
         # ``finish_reasons`` is metadata, not content, so derive it from
         # ``choices_out`` before gating. The raw message/choice bodies are only
         # retained when content capture is enabled (see ``capture_span_content``);
@@ -752,6 +752,22 @@ def _responses_choices(response: Mapping[str, object]) -> tuple[_Choice, ...]:
     return (choice,)
 
 
+def _ocr_choices(response: Mapping[str, object]) -> tuple[_Choice, ...]:
+    markdowns: Final = tuple(
+        text for page in _dicts(response.get("pages")) if (text := as_str(page.get("markdown"))) is not None
+    )
+    if not markdowns:
+        return ()
+    message: Final[_AssistantMessage] = {
+        "role": "assistant",
+        "content": "\n\n".join(markdowns),
+        "refusal": None,
+        "tool_calls": None,
+    }
+    choice: Final[_Choice] = {"message": message, "finish_reason": None}
+    return (choice,)
+
+
 def _responses_parts_text(parts: tuple[Mapping[str, object], ...], part_type: str, field: str) -> str | None:
     texts: Final = tuple(
         text for part in parts if part.get("type") == part_type if (text := as_str(part.get(field))) is not None

litellm/litellm_core_utils/core_helpers.py

@@ -4,7 +4,8 @@ import copy
 import logging
 import re
 from collections.abc import Iterable, Mapping
-from typing import TYPE_CHECKING, Any, Final, Literal
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any, Final, Literal, Protocol
 
 import httpx
 from pydantic import TypeAdapter, ValidationError
@@ -703,3 +704,24 @@ def redact_nested_match_and_regex_keys(
     except Exception:
         return payload
     return redacted
+
+
+RESPONSE_COST_HEADER: Final = "llm_provider-x-litellm-response-cost"
+_NO_HEADERS: Final[Mapping[str, object]] = MappingProxyType({})
+
+
+class _CarriesHiddenParams(Protocol):
+    _hidden_params: dict[str, object]  # mutable-ok: the responses billed here keep hidden params in a plain dict
+
+
+def set_response_cost_in_hidden_params(response: _CarriesHiddenParams, cost: float | None) -> None:
+    """Record a provider-reported cost where the cost calculator looks before the price map."""
+    if cost is None:
+        return
+    hidden_params: Final = response._hidden_params  # pyright: ignore[reportPrivateUsage]  # no public accessor
+    additional_headers: Final[object] = hidden_params.get("additional_headers")
+    merged: Final[dict[str, object]] = {  # mutable-ok: assigned into the plain-dict hidden params
+        **(additional_headers if isinstance(additional_headers, Mapping) else _NO_HEADERS),
+        RESPONSE_COST_HEADER: cost,
+    }
+    hidden_params["additional_headers"] = merged  # rebind-ok: the caller's record is the point

litellm/litellm_core_utils/get_llm_provider_logic.py

@@ -362,6 +362,9 @@ def get_llm_provider(
                     elif endpoint == "https://ai-gateway.vercel.sh/v1":
                         custom_llm_provider = "vercel_ai_gateway"
                         dynamic_api_key = get_secret_str("VERCEL_AI_GATEWAY_API_KEY")
+                    elif endpoint == "https://api.edenai.run/v3":
+                        custom_llm_provider = "edenai"  # rebind-ok: api_base detection resolves the provider in place
+                        dynamic_api_key = get_secret_str("EDENAI_API_KEY")
                     elif endpoint == "https://api.inference.wandb.ai/v1":
                         custom_llm_provider = "wandb"
                         dynamic_api_key = get_secret_str("WANDB_API_KEY")
@@ -853,6 +856,9 @@ def _get_openai_compatible_provider_info(
             api_base,
             dynamic_api_key,
         ) = litellm.VercelAIGatewayConfig()._get_openai_compatible_provider_info(api_base, api_key)
+    elif custom_llm_provider == "edenai":
+        api_base = litellm.EdenAIChatConfig.get_api_base(api_base)  # rebind-ok: chain resolves in place
+        dynamic_api_key = litellm.EdenAIChatConfig.get_api_key(api_key)  # rebind-ok: chain resolves in place
     elif custom_llm_provider == "aiml":
         (
             api_base,

litellm/litellm_core_utils/litellm_logging.py

@@ -69,7 +69,11 @@ from litellm.litellm_core_utils.classifier_logging import (
     classifier_input_snapshot,
     is_classifier_call,
 )
-from litellm.litellm_core_utils.core_helpers import is_expected_client_error, reconstruct_model_name
+from litellm.litellm_core_utils.core_helpers import (
+    is_expected_client_error,
+    reconstruct_model_name,
+    set_response_cost_in_hidden_params,
+)
 from litellm.litellm_core_utils.get_litellm_params import get_litellm_params
 from litellm.litellm_core_utils.internal_call_metadata import (
     MODEL_ACCESS_GROUP_METADATA_KEY,
@@ -3918,6 +3922,7 @@ class Logging(LiteLLMLoggingBaseClass):
         ):
             ## return unified Usage object
             if isinstance(result.response.usage, ResponseAPIUsage):
+                set_response_cost_in_hidden_params(result.response, result.response.usage.cost)
                 transformed_usage: Final = ResponseAPILoggingUtils._transform_response_api_usage_to_chat_usage(
                     result.response.usage
                 )

litellm/llms/base_llm/videos/transformation.py

@@ -272,6 +272,19 @@ class BaseVideoConfig(ABC):
     ) -> VideoObject:
         pass
 
+    async def async_transform_video_status_retrieve_response(
+        self,
+        raw_response: httpx.Response,
+        logging_obj: LiteLLMLoggingObj,
+        custom_llm_provider: str | None = None,
+    ) -> VideoObject:
+        """Async transform video status retrieve response."""
+        return self.transform_video_status_retrieve_response(
+            raw_response=raw_response,
+            logging_obj=logging_obj,
+            custom_llm_provider=custom_llm_provider,
+        )
+
     def transform_video_create_character_request(
         self,
         name: str,

litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py

@@ -533,6 +533,9 @@ class AmazonAnthropicClaudeMessagesConfig(
         if anthropic_model_info.is_eager_input_streaming_used(tools):
             beta_set.add(ANTHROPIC_FINE_GRAINED_TOOL_STREAMING_BETA_HEADER)
 
+        if anthropic_messages_optional_request_params.get("safeguards") is not None:
+            beta_set.add(ANTHROPIC_BETA_HEADER_VALUES.DANGEROUS_TOOL_USE_2026_09_03.value)
+
         self._filter_context_management_for_bedrock_invoke(
             anthropic_messages_request=anthropic_messages_request,
             beta_set=beta_set,

litellm/llms/custom_httpx/llm_http_handler.py

@@ -8881,7 +8881,7 @@ class BaseLLMHTTPHandler:
                     url=url,
                     headers=headers,
                 )
-            return video_status_provider_config.transform_video_status_retrieve_response(
+            return await video_status_provider_config.async_transform_video_status_retrieve_response(
                 raw_response=response,
                 logging_obj=logging_obj,
                 custom_llm_provider=custom_llm_provider,

litellm/llms/edenai/audio_transcription/transformation.py

@@ -0,0 +1,91 @@
+"""
+Support for OpenAI's `/v1/audio/transcriptions` endpoint on Eden AI, served at `/v3/audio/transcriptions`
+with the real per-request cost at the top level of the JSON body.
+
+Docs: https://www.edenai.co/docs/api-reference/audio/audio-transcriptions
+"""
+
+from collections.abc import Mapping
+from typing import Final
+
+import httpx
+
+from litellm.litellm_core_utils.audio_utils.utils import process_audio_file
+from litellm.litellm_core_utils.core_helpers import set_response_cost_in_hidden_params
+from litellm.llms.base_llm.audio_transcription.transformation import AudioTranscriptionRequestData
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.openai.transcriptions.whisper_transformation import OpenAIWhisperAudioTranscriptionConfig
+from litellm.types.llms.openai import AllMessageValues
+from litellm.types.utils import FileTypes, TranscriptionResponse
+from litellm.utils import convert_to_model_response_object
+
+from ..common_utils import EdenAIException, authorized_headers, endpoint_url, reported_cost
+
+
+def _form_fields(model: str, optional_params: Mapping[str, object]) -> dict[str, object]:  # mutable-ok: httpx form data
+    """LiteLLM parks non-OpenAI params, `model` included, under `extra_body` for the OpenAI SDK; a
+    multipart body carries them as top-level text fields instead."""
+    extras: Final = optional_params.get("extra_body")
+    nested: Final = extras.items() if isinstance(extras, Mapping) else ()
+    fields: Final = (*optional_params.items(), *nested, ("model", model))
+    return {key: value for key, value in fields if key != "extra_body"}  # mutable-ok: httpx form data
+
+
+class EdenAIAudioTranscriptionConfig(OpenAIWhisperAudioTranscriptionConfig):
+    @property
+    def has_native_transcription_endpoint(self) -> bool:
+        return True
+
+    def get_complete_url(
+        self,
+        api_base: str | None,
+        api_key: str | None,
+        model: str,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        stream: bool | None = None,
+    ) -> str:
+        return endpoint_url(api_base, "audio/transcriptions")
+
+    def validate_environment(
+        self,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        messages: list[AllMessageValues],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return authorized_headers(headers, api_key, model)
+
+    def transform_audio_transcription_request(
+        self,
+        model: str,
+        audio_file: FileTypes,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+    ) -> AudioTranscriptionRequestData:
+        """Eden reports `duration` and `cost` on every body, so the Whisper default of `verbose_json`,
+        which the gpt-4o-transcribe models reject, is not needed for cost tracking."""
+        audio: Final = process_audio_file(audio_file)
+        files: Final = {"file": (audio.filename, audio.file_content, audio.content_type)}  # mutable-ok: httpx contract
+        return AudioTranscriptionRequestData(data=_form_fields(model, optional_params), files=files)
+
+    def transform_audio_transcription_response(self, raw_response: httpx.Response) -> TranscriptionResponse:
+        if "application/json" not in raw_response.headers.get("content-type", ""):
+            return TranscriptionResponse(text=raw_response.text)
+        body: Final = raw_response.json()
+        response: Final[TranscriptionResponse] = convert_to_model_response_object(
+            response_object=body, model_response_object=TranscriptionResponse(), response_type="audio_transcription"
+        )
+        set_response_cost_in_hidden_params(response, reported_cost(body))
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)

litellm/llms/edenai/chat/transformation.py

@@ -0,0 +1,145 @@
+"""
+Support for OpenAI's `/v1/chat/completions` endpoint on Eden AI.
+
+Eden AI is an OpenAI-compatible gateway (one key across 1000+ models), so requests go through the
+shared HTTP handler untouched. Every Eden response reports the real per-request cost at the top
+level of the body; the only translation here lifts that number into LiteLLM's cost tracking.
+
+Docs: https://www.edenai.co/docs
+"""
+
+from collections.abc import AsyncIterator, Iterator, Mapping
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Final
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+import litellm
+from litellm.litellm_core_utils.core_helpers import set_response_cost_in_hidden_params
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.openai.chat.gpt_transformation import OpenAIChatCompletionStreamingHandler, OpenAIGPTConfig
+from litellm.types.llms.openai import AllMessageValues
+from litellm.types.utils import ModelResponse, ModelResponseStream, Usage
+
+from ..common_utils import EdenAIException, reported_cost, resolve_api_base, resolve_api_key
+
+if TYPE_CHECKING:
+    import tiktoken
+
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+_OPTIONAL_MAPPING: Final[TypeAdapter[Mapping[str, object] | None]] = TypeAdapter(Mapping[str, object] | None)
+
+
+class _EdenAIModel(BaseModel):
+    id: str
+
+
+class _EdenAIModelCatalog(BaseModel):
+    data: tuple[_EdenAIModel, ...]
+
+
+def _stream_options_with_usage(request: Mapping[str, object]) -> Mapping[str, object]:
+    current: Final = _OPTIONAL_MAPPING.validate_python(request.get("stream_options")) or MappingProxyType({})
+    return MappingProxyType({**current, "include_usage": True})
+
+
+class EdenAIChatCompletionStreamingHandler(OpenAIChatCompletionStreamingHandler):
+    def chunk_parser(self, chunk: dict[str, object]) -> ModelResponseStream:  # mutable-ok: inherited contract
+        parsed: Final = super().chunk_parser(chunk)
+        cost: Final = reported_cost(chunk)
+        usage: Final[object] = getattr(parsed, "usage", None)
+        if cost is not None and isinstance(usage, Usage):
+            usage.cost = cost
+        return parsed
+
+
+class EdenAIChatConfig(OpenAIGPTConfig):
+    def get_supported_openai_params(self, model: str) -> list[str]:  # mutable-ok: inherited contract
+        reasoning: Final[tuple[str, ...]] = (
+            ("reasoning_effort",)
+            if litellm.supports_reasoning(model=model, custom_llm_provider=litellm.LlmProviders.EDENAI.value)
+            else ()
+        )
+        return [*super().get_supported_openai_params(model), *reasoning]  # mutable-ok: inherited contract
+
+    @staticmethod
+    def get_api_key(api_key: str | None = None) -> str | None:
+        return resolve_api_key(api_key)
+
+    @staticmethod
+    def get_api_base(api_base: str | None = None) -> str:
+        return resolve_api_base(api_base)
+
+    def transform_request(
+        self,
+        model: str,
+        messages: list[AllMessageValues],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        headers: dict[str, object],  # mutable-ok: inherited contract
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        request: Final[dict[str, object]] = super().transform_request(  # mutable-ok: inherited contract
+            model, messages, optional_params, litellm_params, headers
+        )
+        if not request.get("stream"):
+            return request
+        return {**request, "stream_options": dict(_stream_options_with_usage(request))}  # mutable-ok: JSON body
+
+    def transform_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        model_response: ModelResponse,
+        logging_obj: "LiteLLMLoggingObj",
+        request_data: dict[str, object],  # mutable-ok: inherited contract
+        messages: list[AllMessageValues],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        encoding: "tiktoken.Encoding | None",
+        api_key: str | None = None,
+        json_mode: bool | None = None,
+    ) -> ModelResponse:
+        response: Final = super().transform_response(
+            model=model,
+            raw_response=raw_response,
+            model_response=model_response,
+            logging_obj=logging_obj,
+            request_data=request_data,
+            messages=messages,
+            optional_params=optional_params,
+            litellm_params=litellm_params,
+            encoding=encoding,
+            api_key=api_key,
+            json_mode=json_mode,
+        )
+        set_response_cost_in_hidden_params(response, reported_cost(raw_response.content))
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)
+
+    def get_model_response_iterator(
+        self,
+        streaming_response: Iterator[str] | AsyncIterator[str] | ModelResponse,
+        sync_stream: bool,
+        json_mode: bool | None = False,
+    ) -> EdenAIChatCompletionStreamingHandler:
+        return EdenAIChatCompletionStreamingHandler(
+            streaming_response=streaming_response, sync_stream=sync_stream, json_mode=json_mode
+        )
+
+    def get_models(
+        self, api_key: str | None = None, api_base: str | None = None
+    ) -> list[str]:  # mutable-ok: inherited contract
+        response: Final = litellm.module_level_client.get(url=f"{self.get_api_base(api_base)}/models")
+        if not response.is_success:
+            raise EdenAIException(status_code=response.status_code, message=response.text, headers=response.headers)
+        catalog: Final = _EdenAIModelCatalog.model_validate(response.json())
+        return [f"edenai/{model.id}" for model in catalog.data]  # mutable-ok: inherited contract

litellm/llms/edenai/common_utils.py

@@ -0,0 +1,80 @@
+"""
+Pieces shared by every Eden AI endpoint: credentials, the exception class, and the per-request
+`cost` Eden reports at the top level of each response body, or in a header when the body is binary.
+"""
+
+from collections.abc import Container, Mapping
+from types import MappingProxyType
+from typing import Final
+
+from pydantic import AliasChoices, BaseModel, Field, ValidationError
+
+import litellm
+from litellm.exceptions import AuthenticationError
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.secret_managers.main import get_secret_str
+from litellm.types.utils import LlmProviders
+
+EDENAI_API_BASE: Final = "https://api.edenai.run/v3"
+EDENAI_COST_HEADER: Final = "x-edenai-cost"
+
+
+class EdenAIException(BaseLLMException):
+    pass
+
+
+class _EdenAIExtras(BaseModel):
+    cost: float | None = Field(default=None, validation_alias=AliasChoices("cost", EDENAI_COST_HEADER))
+
+
+def resolve_api_base(api_base: str | None) -> str:
+    return api_base or get_secret_str("EDENAI_API_BASE") or EDENAI_API_BASE
+
+
+def resolve_api_key(api_key: str | None) -> str | None:
+    return api_key or get_secret_str("EDENAI_API_KEY")
+
+
+def require_api_key(api_key: str | None, model: str) -> str:
+    resolved: Final = resolve_api_key(api_key or litellm.api_key)
+    if resolved is None:
+        raise AuthenticationError(
+            message="Missing Eden AI API key: set EDENAI_API_KEY or pass api_key",
+            llm_provider=LlmProviders.EDENAI.value,
+            model=model,
+        )
+    return resolved
+
+
+def reported_cost(payload: object) -> float | None:
+    try:
+        extras: Final = (
+            _EdenAIExtras.model_validate_json(payload)
+            if isinstance(payload, bytes)
+            else _EdenAIExtras.model_validate(payload)
+        )
+    except ValidationError:
+        return None
+    return extras.cost
+
+
+def authorized_headers(
+    headers: Mapping[str, object], api_key: str | None, model: str
+) -> dict[str, object]:  # mutable-ok: header contract
+    return {**headers, "Authorization": f"Bearer {require_api_key(api_key, model)}"}  # mutable-ok: header contract
+
+
+def json_headers(
+    headers: Mapping[str, object], api_key: str | None, model: str
+) -> dict[str, object]:  # mutable-ok: header contract
+    """The shared HTTP handler sends some JSON bodies as raw content, so the type must be set here."""
+    authorized: Final = authorized_headers(headers, api_key, model)
+    return {**authorized, "Content-Type": "application/json"}  # mutable-ok: header contract
+
+
+def endpoint_url(api_base: str | None, path: str) -> str:
+    return f"{resolve_api_base(api_base).rstrip('/')}/{path}"
+
+
+def pick(params: Mapping[str, object], keys: Container[str]) -> Mapping[str, object]:
+    return MappingProxyType({key: value for key, value in params.items() if key in keys})

litellm/llms/edenai/embedding/transformation.py

@@ -0,0 +1,97 @@
+"""
+Support for OpenAI's `/v1/embeddings` endpoint on Eden AI, served at `/v3/embeddings` with the real
+per-request cost at the top level of the body.
+
+Docs: https://www.edenai.co/docs/v3/llms/embeddings
+"""
+
+from typing import TYPE_CHECKING, Final
+
+import httpx
+
+from litellm.litellm_core_utils.core_helpers import set_response_cost_in_hidden_params
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.base_llm.embedding.transformation import BaseEmbeddingConfig
+from litellm.types.llms.openai import AllEmbeddingInputValues, AllMessageValues
+from litellm.types.utils import EmbeddingResponse
+from litellm.utils import convert_to_model_response_object
+
+from ..common_utils import EdenAIException, endpoint_url, json_headers, pick, reported_cost
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+_SUPPORTED_PARAMS: Final = ("dimensions", "encoding_format", "user")
+
+
+class EdenAIEmbeddingConfig(BaseEmbeddingConfig):
+    def get_supported_openai_params(self, model: str) -> list[str]:  # mutable-ok: inherited contract
+        return list(_SUPPORTED_PARAMS)  # mutable-ok: inherited contract
+
+    def map_openai_params(
+        self,
+        non_default_params: dict[str, object],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        drop_params: bool,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return {**optional_params, **pick(non_default_params, _SUPPORTED_PARAMS)}  # mutable-ok: inherited contract
+
+    def validate_environment(
+        self,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        messages: list[AllMessageValues],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return json_headers(headers, api_key, model)
+
+    def get_complete_url(
+        self,
+        api_base: str | None,
+        api_key: str | None,
+        model: str,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        stream: bool | None = None,
+    ) -> str:
+        return endpoint_url(api_base, "embeddings")
+
+    def transform_embedding_request(
+        self,
+        model: str,
+        input: AllEmbeddingInputValues,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        headers: dict[str, object],  # mutable-ok: inherited contract
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return {"model": model, "input": input, **optional_params}  # mutable-ok: inherited contract
+
+    def transform_embedding_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        model_response: EmbeddingResponse,
+        logging_obj: "LiteLLMLoggingObj",
+        api_key: str | None,
+        request_data: dict[str, object],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+    ) -> EmbeddingResponse:
+        body: Final = raw_response.json()
+        logging_obj.post_call(original_response=body)
+        response: Final[EmbeddingResponse] = convert_to_model_response_object(
+            response_object=body, model_response_object=model_response, response_type="embedding"
+        )
+        set_response_cost_in_hidden_params(response, reported_cost(body))
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)

litellm/llms/edenai/image_generation/transformation.py

@@ -0,0 +1,115 @@
+"""
+Support for OpenAI's `/v1/images/generations` endpoint on Eden AI, served at `/v3/images/generations`
+for every image model in the catalog with the real per-request cost at the top level of the body.
+
+Docs: https://www.edenai.co/docs/v3/llms/image-generation
+"""
+
+from typing import TYPE_CHECKING, Final
+
+import httpx
+
+from litellm.litellm_core_utils.core_helpers import set_response_cost_in_hidden_params
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.base_llm.image_generation.transformation import BaseImageGenerationConfig
+from litellm.types.llms.openai import AllMessageValues, OpenAIImageGenerationOptionalParams
+from litellm.types.utils import ImageResponse
+from litellm.utils import convert_to_model_response_object
+
+from ..common_utils import EdenAIException, endpoint_url, json_headers, pick, reported_cost
+
+if TYPE_CHECKING:
+    import tiktoken
+
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+_SUPPORTED_PARAMS: Final[tuple[OpenAIImageGenerationOptionalParams, ...]] = (
+    "background",
+    "moderation",
+    "n",
+    "output_compression",
+    "output_format",
+    "quality",
+    "response_format",
+    "size",
+    "style",
+    "user",
+)
+
+
+class EdenAIImageGenerationConfig(BaseImageGenerationConfig):
+    def get_supported_openai_params(
+        self, model: str
+    ) -> list[OpenAIImageGenerationOptionalParams]:  # mutable-ok: inherited contract
+        return list(_SUPPORTED_PARAMS)  # mutable-ok: inherited contract
+
+    def map_openai_params(
+        self,
+        non_default_params: dict[str, object],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        drop_params: bool,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return {**optional_params, **pick(non_default_params, _SUPPORTED_PARAMS)}  # mutable-ok: inherited contract
+
+    def get_complete_url(
+        self,
+        api_base: str | None,
+        api_key: str | None,
+        model: str,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        stream: bool | None = None,
+    ) -> str:
+        return endpoint_url(api_base, "images/generations")
+
+    def validate_environment(
+        self,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        messages: list[AllMessageValues],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return json_headers(headers, api_key, model)
+
+    def transform_image_generation_request(
+        self,
+        model: str,
+        prompt: str,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        headers: dict[str, object],  # mutable-ok: inherited contract
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return {"model": model, "prompt": prompt, **optional_params}  # mutable-ok: inherited contract
+
+    def transform_image_generation_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        model_response: ImageResponse,
+        logging_obj: "LiteLLMLoggingObj",
+        request_data: dict[str, object],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        encoding: "tiktoken.Encoding | None",
+        api_key: str | None = None,
+        json_mode: bool | None = None,
+    ) -> ImageResponse:
+        body: Final = raw_response.json()
+        logging_obj.post_call(original_response=body)
+        response: Final[ImageResponse] = convert_to_model_response_object(
+            response_object=body, model_response_object=model_response, response_type="image_generation"
+        )
+        set_response_cost_in_hidden_params(response, reported_cost(body))
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)

litellm/llms/edenai/messages/transformation.py

@@ -0,0 +1,79 @@
+"""
+Support for Anthropic's `/v1/messages` endpoint on Eden AI.
+
+Eden AI serves the Anthropic Messages API at `/v3/v1/messages` for every model in its catalog, so
+the Anthropic payload is forwarded untranslated and the answer comes back in Anthropic's shape with
+Eden's per-request `cost` beside it. Eden does not report a cost inside a Messages stream yet, so
+streams fall back to the price map.
+
+Docs: https://www.edenai.co/docs/api-reference/anthropic-messages/create-anthropic-message
+"""
+
+from typing import TYPE_CHECKING, Final
+
+import httpx
+
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.openai_like.json_loader import SimpleProviderConfig
+from litellm.llms.openai_like.messages.transformation import JSONProviderAnthropicMessagesConfig
+from litellm.types.llms.anthropic_messages.anthropic_response import AnthropicMessagesResponse
+from litellm.types.utils import LlmProviders
+
+from ..common_utils import EDENAI_API_BASE, EdenAIException, reported_cost, require_api_key
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+_EDENAI_PROVIDER_SPEC: Final[dict[str, str]] = {  # mutable-ok: SimpleProviderConfig takes a plain dict
+    "base_url": EDENAI_API_BASE,
+    "api_key_env": "EDENAI_API_KEY",
+    "api_base_env": "EDENAI_API_BASE",
+}
+_EDENAI_PROVIDER: Final = SimpleProviderConfig(LlmProviders.EDENAI.value, _EDENAI_PROVIDER_SPEC)
+
+
+class EdenAIAnthropicMessagesConfig(JSONProviderAnthropicMessagesConfig):
+    def __init__(self) -> None:
+        super().__init__(_EDENAI_PROVIDER)
+
+    def validate_anthropic_messages_environment(
+        self,
+        headers: dict[str, str],  # mutable-ok: inherited contract
+        model: str,
+        messages: list[object],  # mutable-ok: inherited contract
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> tuple[dict[str, str], str | None]:  # mutable-ok: inherited contract
+        return super().validate_anthropic_messages_environment(
+            headers=headers,
+            model=model,
+            messages=messages,
+            optional_params=optional_params,
+            litellm_params=litellm_params,
+            api_key=require_api_key(api_key, model),
+            api_base=api_base,
+        )
+
+    def transform_anthropic_messages_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+    ) -> AnthropicMessagesResponse:
+        response: Final = super().transform_anthropic_messages_response(
+            model=model, raw_response=raw_response, logging_obj=logging_obj
+        )
+        cost: Final = reported_cost(response)
+        if cost is not None:
+            logging_obj.model_call_details["response_cost"] = cost  # rebind-ok: the per-call record spend logging reads
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)

litellm/llms/edenai/responses/transformation.py

@@ -0,0 +1,80 @@
+"""
+Support for OpenAI's `/v1/responses` endpoint on Eden AI.
+
+Eden AI serves the Responses API at `/v3/responses` in OpenAI's wire format, so the OpenAI config
+does the work; this one points it at Eden and authenticates with the Eden key. Eden reports the
+per-request cost on `usage.cost` of every body, the final `response.completed` event included, so
+the shared usage-cost lift bills both modes.
+
+Docs: https://www.edenai.co/docs/v3/llms/responses
+"""
+
+from typing import TYPE_CHECKING, Final
+
+import httpx
+
+from litellm.litellm_core_utils.core_helpers import set_response_cost_in_hidden_params
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.openai.responses.transformation import OpenAIResponsesAPIConfig
+from litellm.types.llms.openai import ResponsesAPIResponse
+from litellm.types.router import GenericLiteLLMParams
+from litellm.types.utils import LlmProviders
+
+from ..common_utils import EdenAIException, authorized_headers, resolve_api_base
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+
+class EdenAIResponsesAPIConfig(OpenAIResponsesAPIConfig):
+    @property
+    def custom_llm_provider(self) -> LlmProviders:
+        return LlmProviders.EDENAI
+
+    def validate_environment(
+        self,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        litellm_params: GenericLiteLLMParams | None,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return authorized_headers(headers, litellm_params.api_key if litellm_params else None, model)
+
+    def get_complete_url(
+        self,
+        api_base: str | None,
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+    ) -> str:
+        return super().get_complete_url(api_base=resolve_api_base(api_base), litellm_params=litellm_params)
+
+    def transform_response_api_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+    ) -> ResponsesAPIResponse:
+        response: Final = super().transform_response_api_response(
+            model=model, raw_response=raw_response, logging_obj=logging_obj
+        )
+        set_response_cost_in_hidden_params(response, response.usage.cost if response.usage else None)
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)
+
+    def should_fake_stream(
+        self,
+        model: str | None,
+        stream: bool | None,
+        custom_llm_provider: str | None = None,
+    ) -> bool:
+        """Eden streams every catalog model natively; the base class would fake-stream any model the
+        price map does not know, which is all of them."""
+        return False
+
+    def supports_native_websocket(self) -> bool:
+        return False

litellm/llms/edenai/text_to_speech/transformation.py

@@ -0,0 +1,85 @@
+"""
+Support for OpenAI's `/v1/audio/speech` endpoint on Eden AI, served at `/v3/audio/speech`. The answer
+is raw audio, so the real per-request cost travels in the `x-edenai-cost` response header.
+
+Docs: https://www.edenai.co/docs/api-reference/audio/audio-speech
+"""
+
+from typing import TYPE_CHECKING, Final
+
+import httpx
+
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.base_llm.text_to_speech.transformation import BaseTextToSpeechConfig, TextToSpeechRequestData
+from litellm.types.llms.openai import HttpxBinaryResponseContent
+
+from ..common_utils import EdenAIException, endpoint_url, json_headers, reported_cost
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+_SUPPORTED_PARAMS: Final = ("voice", "response_format", "speed", "instructions")
+
+
+class EdenAITextToSpeechConfig(BaseTextToSpeechConfig):
+    def get_supported_openai_params(self, model: str) -> list[str]:  # mutable-ok: inherited contract
+        return list(_SUPPORTED_PARAMS)  # mutable-ok: inherited contract
+
+    def map_openai_params(
+        self,
+        model: str,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        voice: str | dict[str, object] | None = None,  # mutable-ok: inherited contract
+        drop_params: bool = False,
+        kwargs: dict[str, object] | None = None,  # mutable-ok: inherited contract
+    ) -> tuple[str | None, dict[str, object]]:  # mutable-ok: inherited contract
+        return (voice if isinstance(voice, str) else None), optional_params
+
+    def validate_environment(
+        self,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return json_headers(headers, api_key, model)
+
+    def get_complete_url(
+        self,
+        model: str,
+        api_base: str | None,
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+    ) -> str:
+        return endpoint_url(api_base, "audio/speech")
+
+    def transform_text_to_speech_request(
+        self,
+        model: str,
+        input: str,
+        voice: str | None,
+        optional_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+        headers: dict[str, object],  # mutable-ok: inherited contract
+    ) -> TextToSpeechRequestData:
+        fields: Final = (("model", model), ("input", input), ("voice", voice), *optional_params.items())
+        return TextToSpeechRequestData(
+            dict_body={key: value for key, value in fields if value is not None}  # mutable-ok: TypedDict field
+        )
+
+    def transform_text_to_speech_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+    ) -> HttpxBinaryResponseContent:
+        response: Final = HttpxBinaryResponseContent(response=raw_response)
+        response.set_response_cost(reported_cost(raw_response.headers))
+        return response
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)

litellm/llms/edenai/videos/transformation.py

@@ -0,0 +1,146 @@
+"""
+Support for OpenAI's `/v1/videos` API on Eden AI, served at `/v3/videos`. A job is created, polled and
+downloaded through the OpenAI routes; Eden reports `cost` as 0 on the create response and the settled
+amount on the status read once the job completes or fails.
+
+Docs: https://www.edenai.co/docs/v3/llms/video-generation
+"""
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Final
+
+import httpx
+from httpx._types import RequestFiles
+
+from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.openai.videos.transformation import OpenAIVideoConfig
+from litellm.types.router import GenericLiteLLMParams
+from litellm.types.videos.main import VideoObject
+
+from ..common_utils import EdenAIException, authorized_headers, endpoint_url, reported_cost
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+
+def _usage_with_reported_cost(
+    usage: Mapping[str, object] | None, body: bytes
+) -> dict[str, object]:  # mutable-ok: VideoObject.usage is a plain dict field
+    cost: Final = reported_cost(body)
+    return {  # mutable-ok: VideoObject.usage is a plain dict field
+        key: value
+        for key, value in (*(usage.items() if usage else ()), ("provider_reported_cost_usd", cost))
+        if value is not None
+    }
+
+
+class EdenAIVideoConfig(OpenAIVideoConfig):
+    def validate_environment(
+        self,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+        model: str,
+        api_key: str | None = None,
+        litellm_params: GenericLiteLLMParams | None = None,
+    ) -> dict[str, object]:  # mutable-ok: inherited contract
+        return authorized_headers(headers, api_key or (litellm_params.api_key if litellm_params else None), model)
+
+    def get_complete_url(
+        self,
+        model: str,
+        api_base: str | None,
+        litellm_params: dict[str, object],  # mutable-ok: inherited contract
+    ) -> str:
+        return endpoint_url(api_base, "videos")
+
+    def use_multipart_form_data(self) -> bool:
+        return False
+
+    def transform_video_create_request(
+        self,
+        model: str,
+        prompt: str,
+        api_base: str,
+        video_create_optional_request_params: dict[str, object],  # mutable-ok: inherited contract
+        litellm_params: GenericLiteLLMParams,
+        headers: dict[str, object],  # mutable-ok: inherited contract
+    ) -> tuple[dict[str, object], RequestFiles, str]:  # mutable-ok: inherited contract
+        """A reference image is a multipart file part, or a JSON `{"file_id"}` / `{"image_url"}` object."""
+        reference: Final = video_create_optional_request_params.get("input_reference")
+        if not isinstance(reference, Mapping):
+            return super().transform_video_create_request(
+                model=model,
+                prompt=prompt,
+                api_base=api_base,
+                video_create_optional_request_params=video_create_optional_request_params,
+                litellm_params=litellm_params,
+                headers=headers,
+            )
+        data, files, url = super().transform_video_create_request(
+            model=model,
+            prompt=prompt,
+            api_base=api_base,
+            video_create_optional_request_params={  # mutable-ok: inherited contract
+                key: value for key, value in video_create_optional_request_params.items() if key != "input_reference"
+            },
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+        return {**data, "input_reference": dict(reference)}, files, url  # mutable-ok: JSON body
+
+    def transform_video_create_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+        custom_llm_provider: str | None = None,
+        request_data: dict[str, object] | None = None,  # mutable-ok: inherited contract
+    ) -> VideoObject:
+        video: Final = super().transform_video_create_response(
+            model=model,
+            raw_response=raw_response,
+            logging_obj=logging_obj,
+            custom_llm_provider=custom_llm_provider,
+            request_data=request_data,
+        )
+        video.usage = _usage_with_reported_cost(video.usage, raw_response.content)
+        return video
+
+    def transform_video_status_retrieve_response(
+        self,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+        custom_llm_provider: str | None = None,
+    ) -> VideoObject:
+        raw_response.raise_for_status()  # the shared GET helpers return error bodies instead of raising
+        video: Final = super().transform_video_status_retrieve_response(
+            raw_response=raw_response, logging_obj=logging_obj, custom_llm_provider=custom_llm_provider
+        )
+        video.usage = _usage_with_reported_cost(video.usage, raw_response.content)
+        return video
+
+    def transform_video_content_response(
+        self,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+    ) -> bytes:
+        raw_response.raise_for_status()  # the shared GET helpers return error bodies instead of raising
+        return raw_response.content
+
+    def transform_video_list_response(
+        self,
+        raw_response: httpx.Response,
+        logging_obj: "LiteLLMLoggingObj",
+        custom_llm_provider: str | None = None,
+    ) -> dict[str, str]:  # mutable-ok: inherited contract
+        raw_response.raise_for_status()  # the shared GET helpers return error bodies instead of raising
+        return super().transform_video_list_response(
+            raw_response=raw_response, logging_obj=logging_obj, custom_llm_provider=custom_llm_provider
+        )
+
+    def get_error_class(
+        self,
+        error_message: str,
+        status_code: int,
+        headers: dict[str, object] | httpx.Headers,  # mutable-ok: inherited contract
+    ) -> BaseLLMException:
+        return EdenAIException(message=error_message, status_code=status_code, headers=headers)

litellm/llms/fal_ai/videos/transformation.py

@@ -1,7 +1,7 @@
 import math
 import sys
 import time
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from types import MappingProxyType
 from typing import Final, TypeAlias
@@ -163,12 +163,127 @@ def _response_data(raw_response: httpx.Response) -> Mapping[str, object]:
     return TypeAdapter(Mapping[str, object]).validate_python(raw_response.json())
 
 
+def _response_data_or_none(raw_response: httpx.Response) -> Mapping[str, object] | None:
+    try:
+        return _response_data(raw_response)
+    except ValueError:
+        return None
+
+
+def _detail_item_text(item: Mapping[str, object]) -> str | None:
+    message: Final[object] = item.get("msg")
+    if not isinstance(message, str):
+        return None
+    location: Final[object] = item.get("loc")
+    if isinstance(location, str) and location:
+        return f"{location}: {message}"
+    if isinstance(location, (list, tuple)):
+        location_parts: Final[tuple[str, ...]] = tuple(part for part in location if isinstance(part, str))
+        if location_parts:
+            return f"{'.'.join(location_parts)}: {message}"
+    return message
+
+
+def _error_text(response_data: Mapping[str, object]) -> str | None:
+    detail: Final[object] = response_data.get("detail")
+    if isinstance(detail, str):
+        return detail
+    if isinstance(detail, list):
+        detail_items: Final[tuple[Mapping[str, object], ...]] = tuple(
+            item for item in detail if isinstance(item, Mapping)
+        )
+        detail_messages: Final[tuple[str, ...]] = tuple(
+            message for item in detail_items if (message := _detail_item_text(item)) is not None
+        )
+        if detail_messages:
+            return "; ".join(detail_messages)
+    error: Final[object] = response_data.get("error")
+    return error if isinstance(error, str) else None
+
+
+def _result_error(raw_response: httpx.Response) -> str | None:
+    if raw_response.is_success:
+        return None
+    response_data: Final[Mapping[str, object] | None] = _response_data_or_none(raw_response)
+    error_text: Final[str | None] = _error_text(response_data) if response_data is not None else None
+    if error_text:
+        return error_text
+    response_text: Final[str] = raw_response.text
+    return response_text or f"fal.ai returned HTTP {raw_response.status_code}"
+
+
+def _terminal_result_error(raw_response: httpx.Response) -> str | None:
+    if raw_response.status_code == 429 or raw_response.status_code >= 500:
+        return None
+    return _result_error(raw_response)
+
+
+def _get_fal_ai_async_httpx_client() -> AsyncHTTPHandler:
+    return get_async_httpx_client(llm_provider=LlmProviders.FAL_AI)
+
+
 def _response_string(response_data: Mapping[str, object], key: str, default: str = "") -> str:
     value: Final[object] = response_data.get(key)
     return value if isinstance(value, str) else default
 
 
+def _result_request(
+    raw_response: httpx.Response,
+    response_data: Mapping[str, object],
+) -> tuple[str, Mapping[str, str]] | None:
+    if _response_string(response_data, "status", "IN_QUEUE") != "COMPLETED":
+        return None
+    result_url: Final[str] = str(raw_response.request.url).removesuffix("/status")
+    result_headers: Final[Mapping[str, str]] = MappingProxyType(
+        {
+            key: value
+            for key, value in (
+                ("Authorization", raw_response.request.headers.get("Authorization")),
+                ("Content-Type", raw_response.request.headers.get("Content-Type")),
+            )
+            if value is not None
+        }
+    )
+    return result_url, result_headers
+
+
+def _status_video_object(
+    response_data: Mapping[str, object],
+    raw_response: httpx.Response,
+    custom_llm_provider: str | None,
+    result_error: str | None,
+) -> VideoObject:
+    raw_status: Final[str] = _response_string(response_data, "status", "IN_QUEUE")
+    status: Final[str] = _STATUS_MAP.get(raw_status, "queued")
+    status_error: Final[str | None] = _error_text(response_data)
+    error: Final[str | None] = result_error if result_error is not None else status_error
+    provider: Final[str] = custom_llm_provider or _FAL_AI_PROVIDER
+    model_path: Final[str | None] = _model_path_from_request_url(raw_response)
+    request_id: Final[str] = _response_string(response_data, "request_id") or (
+        _request_id_from_request_url(raw_response) or ""
+    )
+    return VideoObject(
+        id=encode_video_id_with_provider(request_id, provider, model_path),
+        object="video",
+        status="failed" if error else status,
+        created_at=0,
+        model=model_path,
+        error=(
+            {"code": "fal_error", "message": error} if error else None  # mutable-ok: VideoObject requires a dict
+        ),
+    )
+
+
 class FalAIVideoConfig(BaseVideoConfig):
+    def __init__(
+        self,
+        sync_client_factory: Callable[[], HTTPHandler] = _get_httpx_client,
+        async_client_factory: Callable[[], AsyncHTTPHandler] = _get_fal_ai_async_httpx_client,
+    ) -> None:
+        super().__init__()
+        self._sync_client_factory: Final = sync_client_factory
+        self._async_client_factory: Final = async_client_factory
+
     def get_supported_openai_params(self, model: str) -> _SupportedParams:
         supported_params: Final[_SupportedParams] = [  # mutable-ok: BaseVideoConfig requires a list
             "model",
@@ -345,25 +460,58 @@ class FalAIVideoConfig(BaseVideoConfig):
         custom_llm_provider: str | None = None,
     ) -> VideoObject:
         response_data: Final[Mapping[str, object]] = _response_data(raw_response)
-        raw_status: Final[str] = _response_string(response_data, "status", "IN_QUEUE")
-        status: Final[str] = _STATUS_MAP.get(raw_status, "queued")
-        error_value: Final[object] = response_data.get("error")
-        error: Final[str | None] = error_value if isinstance(error_value, str) else None
-        provider: Final[str] = custom_llm_provider or _FAL_AI_PROVIDER
-        model_path: Final[str | None] = _model_path_from_request_url(raw_response)
-        request_id: Final[str] = _response_string(response_data, "request_id") or (
-            _request_id_from_request_url(raw_response) or ""
+        result_error: Final[str | None] = self._fetch_result_error(raw_response, response_data)
+        return _status_video_object(
+            response_data=response_data,
+            raw_response=raw_response,
+            custom_llm_provider=custom_llm_provider,
+            result_error=result_error,
         )
-        return VideoObject(
-            id=encode_video_id_with_provider(request_id, provider, model_path),
-            object="video",
-            status="failed" if error else status,
-            created_at=0,
-            model=model_path,
-            error=(
-                {"code": "fal_error", "message": error} if error else None  # mutable-ok: VideoObject requires a dict
-            ),
+
+    def _fetch_result_error(
+        self,
+        raw_response: httpx.Response,
+        response_data: Mapping[str, object],
+    ) -> str | None:
+        result_request: Final[tuple[str, Mapping[str, str]] | None] = _result_request(raw_response, response_data)
+        if result_request is None:
+            return None
+        result_url, result_headers = result_request
+        result_response: Final[httpx.Response] = self._sync_client_factory().get(
+            url=result_url,
+            headers=result_headers,
         )
+        return _terminal_result_error(result_response)
+
+    async def async_transform_video_status_retrieve_response(
+        self,
+        raw_response: httpx.Response,
+        logging_obj: object,
+        custom_llm_provider: str | None = None,
+    ) -> VideoObject:
+        response_data: Final[Mapping[str, object]] = _response_data(raw_response)
+        result_error: Final[str | None] = await self._fetch_result_error_async(raw_response, response_data)
+        return _status_video_object(
+            response_data=response_data,
+            raw_response=raw_response,
+            custom_llm_provider=custom_llm_provider,
+            result_error=result_error,
+        )
+
+    async def _fetch_result_error_async(
+        self,
+        raw_response: httpx.Response,
+        response_data: Mapping[str, object],
+    ) -> str | None:
+        result_request: Final[tuple[str, Mapping[str, str]] | None] = _result_request(raw_response, response_data)
+        if result_request is None:
+            return None
+        result_url, result_headers = result_request
+        result_response: Final[httpx.Response] = await self._async_client_factory().get(
+            url=result_url,
+            headers=result_headers,
+        )
+        return _terminal_result_error(result_response)
 
     @staticmethod
     def _decode_video_id(video_id: str) -> tuple[str, str]:
@@ -401,17 +549,23 @@ class FalAIVideoConfig(BaseVideoConfig):
             video_url: Final[object] = video_data.get("url")
             if isinstance(video_url, str) and video_url:
                 return video_url
-        error_message: Final[str | None] = next(
-            (value for key in ("error", "detail") if isinstance(value := response_data.get(key), str)),
-            None,
-        )
+        error_message: Final[str | None] = _error_text(response_data)
         if error_message:
             raise ValueError(f"fal.ai video result did not include a video URL: {error_message}")
         raise ValueError("fal.ai video result did not include a video URL")
 
     def transform_video_content_response(self, raw_response: httpx.Response, logging_obj: object) -> bytes:
+        error: Final[str | None] = _result_error(raw_response)
+        if error is not None:
+            raise FalAIVideoError(
+                status_code=raw_response.status_code,
+                message=error,
+                headers=dict(raw_response.headers),  # mutable-ok: exception headers require a mutable dictionary
+                request=raw_response.request,
+                response=raw_response,
+            )
         video_url: Final[str] = self._extract_video_url(_response_data(raw_response))
-        httpx_client: Final[HTTPHandler] = _get_httpx_client()
+        httpx_client: Final[HTTPHandler] = self._sync_client_factory()
         video_response: Final[httpx.Response] = httpx_client.get(  # pyright: ignore[reportUnknownMemberType]  # HTTP handler stubs are untyped
             video_url
         )
@@ -419,8 +573,17 @@ class FalAIVideoConfig(BaseVideoConfig):
         return video_response.content
 
     async def async_transform_video_content_response(self, raw_response: httpx.Response, logging_obj: object) -> bytes:
+        error: Final[str | None] = _result_error(raw_response)
+        if error is not None:
+            raise FalAIVideoError(
+                status_code=raw_response.status_code,
+                message=error,
+                headers=dict(raw_response.headers),  # mutable-ok: exception headers require a mutable dictionary
+                request=raw_response.request,
+                response=raw_response,
+            )
         video_url: Final[str] = self._extract_video_url(_response_data(raw_response))
-        async_httpx_client: Final[AsyncHTTPHandler] = get_async_httpx_client(llm_provider=LlmProviders.FAL_AI)
+        async_httpx_client: Final[AsyncHTTPHandler] = self._async_client_factory()
         video_response: Final[httpx.Response] = await async_httpx_client.get(  # pyright: ignore[reportUnknownMemberType]  # HTTP handler stubs are untyped
             video_url
         )

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py

@@ -108,6 +108,9 @@ class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, Vert
         if anthropic_model_info.is_tool_search_used(tools):
             beta_values.add(get_tool_search_beta_header("vertex_ai"))
 
+        if optional_params.get("safeguards") is not None:
+            beta_values.add(ANTHROPIC_BETA_HEADER_VALUES.DANGEROUS_TOOL_USE_2026_09_03.value)
+
         if beta_values:
             headers["anthropic-beta"] = ",".join(beta_values)
 

litellm/main.py

@@ -3568,6 +3568,32 @@ def _complete_vercel_ai_gateway(
     return response
 
 
+def _complete_edenai(ctx: _CompletionDispatchContext) -> _CompletionDispatchResult:
+    api_base: Final = litellm.EdenAIChatConfig.get_api_base(ctx.api_base)
+    api_key: Final = litellm.EdenAIChatConfig.get_api_key(ctx.api_key or litellm.api_key)
+    response: Final = base_llm_http_handler.completion(
+        model=ctx.model,
+        messages=ctx.messages,
+        api_base=api_base,
+        custom_llm_provider="edenai",
+        model_response=ctx.model_response,
+        encoding=_get_encoding(),
+        logging_obj=ctx.logging,
+        optional_params=ctx.optional_params,
+        timeout=ctx.timeout,
+        litellm_params=ctx.litellm_params,
+        shared_session=ctx.shared_session,
+        acompletion=ctx.acompletion,
+        stream=ctx.stream,
+        api_key=api_key,
+        headers=ctx.headers or litellm.headers,
+        client=_dispatch_client_http(ctx),
+        provider_config=ctx.provider_config,
+    )
+    ctx.logging.post_call(input=ctx.messages, api_key=api_key, original_response=response)
+    return response
+
+
 def _complete_vertex_ai_beta(
     ctx: _CompletionDispatchContext,
 ) -> _CompletionDispatchResult:
@@ -5771,6 +5797,8 @@ def completion(
             response = _complete_minimax(_dispatch_ctx)
         elif custom_llm_provider == "hosted_vllm":
             response = _complete_hosted_vllm(_dispatch_ctx)
+        elif custom_llm_provider == "edenai":
+            response = _complete_edenai(_dispatch_ctx)  # rebind-ok: dispatch chain binds response per branch
         elif (
             # A known OpenAI model name only decides the route when nothing else
             # resolved a provider. get_llm_provider() already maps these names to
@@ -6440,6 +6468,22 @@ def embedding(
                 litellm_params=litellm_params_dict,
                 headers=headers or {},
             )
+        elif custom_llm_provider == "edenai":
+            response = base_llm_http_handler.embedding(
+                model=model,
+                input=input,
+                custom_llm_provider=custom_llm_provider,
+                api_base=api_base,
+                api_key=api_key,
+                logging_obj=logging,
+                timeout=timeout,
+                model_response=EmbeddingResponse(),
+                optional_params=optional_params,
+                client=client,
+                aembedding=aembedding,
+                litellm_params=litellm_params_dict,
+                headers=headers,
+            )
         elif (
             custom_llm_provider == "openai_like"
             or custom_llm_provider == "llamafile"
@@ -8142,7 +8186,23 @@ def speech(
         custom_llm_provider=custom_llm_provider,
     )
     response: HttpxBinaryResponseContent | Coroutine[object, object, HttpxBinaryResponseContent] | None = None
-    if custom_llm_provider == "openai" or (
+    if custom_llm_provider == "edenai":
+        litellm_params_dict["api_base"] = api_base
+        response = base_llm_http_handler.text_to_speech_handler(
+            model=model,
+            input=input,
+            voice=voice if isinstance(voice, str) else None,
+            text_to_speech_provider_config=text_to_speech_provider_config or litellm.EdenAITextToSpeechConfig(),
+            text_to_speech_optional_params=optional_params,
+            custom_llm_provider=custom_llm_provider,
+            litellm_params=litellm_params_dict,
+            logging_obj=logging_obj,
+            timeout=timeout,
+            extra_headers=extra_headers,
+            client=client,
+            _is_async=aspeech or False,
+        )
+    elif custom_llm_provider == "openai" or (
         custom_llm_provider in litellm.openai_compatible_providers
         and custom_llm_provider not in AZURE_OPENAI_AUDIO_PROVIDERS
     ):

litellm/model_prices_and_context_window_backup.json

@@ -43011,21 +43011,21 @@
         "supports_web_search": false
     },
     "openrouter/deepseek/deepseek-v4-pro": {
-        "input_cost_per_token": 9.15936e-07,
+        "input_cost_per_token": 9.00798e-07,
         "input_cost_per_token_cache_hit": 4.4e-08,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 384000,
         "max_tokens": 384000,
         "mode": "chat",
-        "output_cost_per_token": 1.831872e-06,
+        "output_cost_per_token": 1.801596e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_function_calling": true,
         "supports_prompt_caching": true,
         "supports_reasoning": true,
         "supports_response_schema": true,
         "supports_tool_choice": true,
-        "cache_read_input_token_cost": 7.6328e-08,
+        "cache_read_input_token_cost": 7.50665e-08,
         "supports_audio_input": false,
         "supports_pdf_input": false,
         "supports_vision": false,
@@ -76889,5 +76889,65 @@
         "supports_system_messages": true,
         "supports_tool_choice": true,
         "supports_vision": true
+    },
+    "openrouter/xiaomi/mimo-v2.6-flash": {
+        "cache_read_input_token_cost": 2.8e-09,
+        "input_cost_per_token": 1.4e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 2.8e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/xiaomi/mimo-v2.6-pro": {
+        "cache_read_input_token_cost": 3.6e-09,
+        "input_cost_per_token": 4.35e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 8.7e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/xiaomi/mimo-v2.6-pro-ultraspeed": {
+        "cache_read_input_token_cost": 3.6e-08,
+        "input_cost_per_token": 4.35e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 8.7e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
     }
 }

litellm/provider_endpoints_support_backup.json

@@ -815,6 +815,24 @@
         "interactions": true
       }
     },
+    "edenai": {
+      "display_name": "Eden AI (`edenai`)",
+      "url": "https://docs.litellm.ai/docs/providers/edenai",
+      "endpoints": {
+        "chat_completions": true,
+        "messages": true,
+        "responses": true,
+        "embeddings": true,
+        "image_generations": true,
+        "audio_transcriptions": true,
+        "audio_speech": true,
+        "moderations": false,
+        "batches": false,
+        "rerank": false,
+        "interactions": false,
+        "video_generations": true
+      }
+    },
     "duckduckgo": {
       "display_name": "DuckDuckGo (`duckduckgo`)",
       "url": "https://docs.litellm.ai/docs/search/duckduckgo",

litellm/proxy/_experimental/mcp_server/mcp_server_manager.py

@@ -2500,9 +2500,8 @@ class MCPServerManager:
             # Filter blank scopes (e.g. YAML ``scopes: [""]``) the same way the DB-build path does, so
             # an all-blank list normalizes to None rather than a ``("",)`` tuple that skips the
             # entra_obo fail-closed scope precondition and POSTs an empty scope to the IdP.
-            resolved_scopes = self._extract_scopes(server_config.get("scopes")) or (
-                gated_oauth_metadata.scopes if gated_oauth_metadata else None
-            )
+            configured_scopes = self._extract_scopes(server_config.get("scopes"))
+            resolved_scopes = configured_scopes or (gated_oauth_metadata.scopes if gated_oauth_metadata else None)
             resolved_authorization_url = manual_authorization_url or (
                 gated_oauth_metadata.authorization_url if gated_oauth_metadata else None
             )
@@ -2579,6 +2578,7 @@ class MCPServerManager:
                 client_secret=server_config.get("client_secret", None),
                 oauth2_flow=self._explicit_oauth2_flow(config_oauth2_flow),
                 scopes=resolved_scopes,
+                configured_scopes=tuple(configured_scopes) if configured_scopes else None,
                 issuer=effective_issuer,
                 issuer_is_anchored=use_issuer_anchor,
                 authorization_url=resolved_authorization_url,
@@ -3055,6 +3055,18 @@ class MCPServerManager:
             if scopes_value is not None:
                 scopes = self._extract_scopes(scopes_value)
 
+        stored_scopes: Final[object] = credentials_dict.get("scopes") if credentials_dict else None
+        scopes_as_objects: Final = (
+            cast(Sequence[object], stored_scopes)  # cast-ok: list shape validated below
+            if isinstance(stored_scopes, list)
+            else ()
+        )
+        configured_scopes: Final = (
+            tuple(scope for scope in scopes_as_objects if isinstance(scope, str))
+            if scopes_as_objects and all(isinstance(scope, str) and scope for scope in scopes_as_objects)
+            else None
+        )
+
         name_for_prefix: Final = mcp_server.alias or mcp_server.server_name or mcp_server.server_id
 
         mcp_info: Final[MCPInfo] = _mcp_info.copy()
@@ -3129,6 +3141,7 @@ class MCPServerManager:
             client_secret=client_secret_value or getattr(mcp_server, "client_secret", None),
             oauth2_flow=self._explicit_oauth2_flow(getattr(mcp_server, "oauth2_flow", None)),
             scopes=resolved_scopes,
+            configured_scopes=configured_scopes,
             issuer=effective_issuer,
             issuer_is_anchored=use_issuer_anchor,
             authorization_url=manual_authorization_url or getattr(gated_oauth_metadata, "authorization_url", None),
@@ -7094,6 +7107,11 @@ class MCPServerManager:
             spec_path=server.spec_path,
             transport=server.transport,
             auth_type=server.auth_type,
+            credentials=(
+                {"scopes": list(server.configured_scopes)}  # mutable-ok: MCPCredentials requires a JSON-array list
+                if server.configured_scopes
+                else None
+            ),
             created_at=server.created_at,
             updated_at=server.updated_at,
             teams=[],

litellm/proxy/_types.py

@@ -641,6 +641,7 @@ class LiteLLMRoutes(enum.Enum):
         "/v1/models",
         "/sso/get/ui_settings",
         "/get/user_banner",
+        "/get/latest_release_info",
     ]
 
     # NOTE: ROUTES ONLY FOR MASTER KEY - only the Master Key should be able to Reset Spend

litellm/proxy/management_endpoints/mcp_management_endpoints.py

@@ -22,7 +22,14 @@ import os
 from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Annotated, Final, Literal, Protocol
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Final,
+    Literal,
+    Protocol,
+    cast,  # noqa: TID251  # validated JSON values need explicit narrowing
+)
 
 from fastapi import (
     APIRouter,
@@ -628,8 +635,8 @@ if MCP_AVAILABLE:
 
     def _preserved_admin_config_credentials(
         credentials: "MCPCredentials | str | None",
-    ) -> "dict[str, str] | None":
-        """Keep only the non-secret admin-config keys, which are stored unencrypted so they lift out
+    ) -> "dict[str, str | list[str]] | None":  # mutable-ok: API response payload
+        """Keep non-secret admin-config keys and scopes, which are stored unencrypted so they lift out
         as plaintext; every secret and minted-token key is dropped.
 
         Total over every stored shape: a dict is read directly, a JSON-object string is parsed, and
@@ -639,15 +646,30 @@ if MCP_AVAILABLE:
         parsed: object = credentials
         if isinstance(credentials, str):
             try:
-                parsed = json.loads(credentials)
+                parsed = cast(object, json.loads(credentials))  # cast-ok: JSON parse result is validated below
             except (ValueError, TypeError):
                 return None
         if not isinstance(parsed, dict):
             return None
-        preserved: Final = {
-            key: value
-            for key in MCP_ADMIN_CONFIG_CREDENTIAL_KEYS
-            if isinstance((value := parsed.get(key)), str) and value
+        parsed_credentials: Final = cast(Mapping[str, object], parsed)  # cast-ok: dict shape validated above
+        scopes: Final[object] = parsed_credentials.get("scopes")
+        scopes_as_objects: Final = (
+            cast(Sequence[object], scopes)  # cast-ok: list shape validated above
+            if isinstance(scopes, list)
+            else ()
+        )
+        preserved_scopes: Final = (
+            {"scopes": cast(list[str], scopes_as_objects)}  # cast-ok: every scope is validated below
+            if scopes_as_objects and all(isinstance(scope, str) and scope for scope in scopes_as_objects)
+            else {}
+        )
+        preserved: Final = {  # mutable-ok: API response payload
+            **{
+                key: value
+                for key in MCP_ADMIN_CONFIG_CREDENTIAL_KEYS
+                if isinstance((value := parsed_credentials.get(key)), str) and value
+            },
+            **preserved_scopes,
         }
         return preserved or None
 
@@ -827,7 +849,9 @@ if MCP_AVAILABLE:
         if not credentials:
             return False
         as_dict: Final[dict[str, object]] = dict(credentials)
-        return any(value for key, value in as_dict.items() if key not in MCP_ADMIN_CONFIG_CREDENTIAL_KEYS)
+        return any(
+            value for key, value in as_dict.items() if key not in MCP_ADMIN_CONFIG_CREDENTIAL_KEYS and key != "scopes"
+        )
 
     def _inherit_credentials_from_existing_server(
         payload: NewMCPServerRequest,

litellm/proxy/management_endpoints/model_management_endpoints.py

@@ -28,6 +28,7 @@ import litellm
 from litellm._logging import verbose_proxy_logger
 from litellm._uuid import uuid
 from litellm.constants import LITELLM_PROXY_ADMIN_NAME
+from litellm.litellm_core_utils.credential_accessor import CredentialAccessor
 from litellm.litellm_core_utils.ptu_pricing import (
     CUSTOM_PRICING_FIELDS,
     PTU_EMPTIED_PRICING_FIELDS,
@@ -94,6 +95,7 @@ from litellm.proxy.spend_tracking.ptu_feature_flag import (
     is_ptu_cost_attribution_enabled,
 )
 from litellm.proxy.utils import PrismaClient, ProxyLogging
+from litellm.repositories.credentials_repository import CredentialsRepository
 from litellm.repositories.model_repository import ModelRepository
 from litellm.repositories.prisma_protocols import TableActions
 from litellm.repositories.table_repositories import ModelTableRepository
@@ -145,7 +147,7 @@ if TYPE_CHECKING:
     from prisma import types as prisma_types
 
 router: Final = APIRouter()
-CLEARABLE_LITELLM_PARAMS: Final = frozenset({"cache_control_injection_points"})
+CLEARABLE_LITELLM_PARAMS: Final = frozenset({"cache_control_injection_points", "litellm_credential_name"})
 NULL_CLEARABLE_LITELLM_PARAMS: Final = frozenset((*SPECIAL_MODEL_INFO_PARAMS, *CLEARABLE_LITELLM_PARAMS))
 
 
@@ -332,6 +334,36 @@ def _raise_on_strategy_router_write_violation(
     )
 
 
+async def _raise_on_invalid_credential_name(
+    litellm_params: updateLiteLLMParams | None, prisma_client: PrismaClient
+) -> None:
+    if litellm_params is None or "litellm_credential_name" not in litellm_params.model_fields_set:
+        return
+    credential_name: Final = litellm_params.litellm_credential_name
+    if credential_name is None:
+        return
+    if credential_name == "":
+        raise ProxyException(
+            message="litellm_credential_name cannot be an empty string. Send null to detach the stored credential or omit the field to leave it unchanged.",
+            type=ProxyErrorTypes.validation_error.value,
+            code=status.HTTP_400_BAD_REQUEST,
+            param="litellm_credential_name",
+        )
+    if CredentialAccessor.find_credential(credential_name) is not None:
+        return
+    stored_credential: Final = await CredentialsRepository(WriterPinnedClient(prisma_client.db)).find_by_name(
+        credential_name
+    )
+    if stored_credential is not None:
+        return
+    raise ProxyException(
+        message=f"Credential '{credential_name}' not found. Create it via /credentials before attaching it to a model.",
+        type=ProxyErrorTypes.validation_error.value,
+        code=status.HTTP_400_BAD_REQUEST,
+        param="litellm_credential_name",
+    )
+
+
 AUTO_ROUTER_CAPABILITY_SLOT_LOCK_KEY: Final = 5_872_301
 _CAPABILITY_LOCK_SQL: Final = "SELECT 1 AS locked FROM pg_advisory_xact_lock($1)"
 _STORED_LITELLM_PARAMS_SQL: Final = (
@@ -1110,7 +1142,9 @@ async def patch_model(
             litellm_params=patch_data.litellm_params,
             user_api_key_dict=user_api_key_dict,
             existing_litellm_params=db_model.litellm_params,
+            null_detaches=True,
         )
+        await _raise_on_invalid_credential_name(patch_data.litellm_params, prisma_client)
 
         ModelManagementAuthChecks.can_user_set_aws_session_tags(
             litellm_params=patch_data.litellm_params,
@@ -1920,22 +1954,33 @@ class ModelManagementAuthChecks:
         litellm_params: GenericLiteLLMParams | None,
         user_api_key_dict: UserAPIKeyAuth,
         existing_litellm_params: GenericLiteLLMParams | None = None,
+        *,
+        null_detaches: bool = False,
     ) -> Literal[True]:
-        if litellm_params is None or litellm_params.litellm_credential_name is None:
+        if litellm_params is None:
             return True
-        if existing_litellm_params is not None and existing_litellm_params.litellm_credential_name is not None:
-            existing_credential_name: Final = decrypt_value_helper(
+        if "litellm_credential_name" not in litellm_params.model_fields_set:
+            return True
+        if litellm_params.litellm_credential_name is None and not null_detaches:
+            return True
+        existing_credential_name: Final = (
+            decrypt_value_helper(
                 value=existing_litellm_params.litellm_credential_name,
                 key="litellm_credential_name",
                 exception_type="debug",
                 return_original_value=True,
             )
-            if litellm_params.litellm_credential_name == existing_credential_name:
-                return True
+            if existing_litellm_params is not None and existing_litellm_params.litellm_credential_name is not None
+            else None
+        )
+        requested_credential_name: Final = litellm_params.litellm_credential_name
+        if requested_credential_name == existing_credential_name:
+            return True
         if user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN:
             return True
+        action: Final = "detach" if requested_credential_name is None else "attach"
         raise ProxyException(
-            message=f"Only a proxy admin can attach a stored credential (litellm_credential_name) to a model. Your role={user_api_key_dict.user_role}.",
+            message=f"Only a proxy admin can {action} a stored credential (litellm_credential_name) on a model. Your role={user_api_key_dict.user_role}.",
             type=ProxyErrorTypes.auth_error.value,
             code=status.HTTP_403_FORBIDDEN,
             param="litellm_credential_name",

litellm/proxy/proxy_server.py

@@ -730,6 +730,9 @@ from litellm.proxy.spend_tracking.spend_management_endpoints import (
 )
 from litellm.proxy.spend_tracking.spend_tracking_utils import get_logging_payload
 from litellm.proxy.types_utils.utils import get_instance_fn
+from litellm.proxy.ui_crud_endpoints.latest_release_endpoints import (
+    router as latest_release_endpoints_router,
+)
 from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
     router as ui_crud_endpoints_router,
 )
@@ -3546,6 +3549,16 @@ async def increment_spend_counter(counter_key: str, increment: float):
     return await _increment_spend_counter_cache(counter_key=counter_key, increment=increment)
 
 
+async def refresh_spend_counter_ttl(counter_key: str) -> bool:
+    if spend_counter_cache.redis_cache is None:
+        return False
+    try:
+        return await spend_counter_cache.redis_cache.async_refresh_ttl(key=counter_key)
+    except Exception as e:
+        verbose_proxy_logger.debug("spend counter TTL refresh skipped for %s: %s", counter_key, e)
+        return False
+
+
 async def _increment_spend_counter_cache(counter_key: str, increment: float):
     if spend_counter_cache.redis_cache is not None:
         try:
@@ -6878,10 +6891,27 @@ class ProxyConfig:
         router_model_ids: Final = llm_router.get_model_ids()
         # Check for model IDs in llm_router not present in combined_id_list and delete them
 
+        kept_config_ids: Final[frozenset[str]] = (
+            frozenset(
+                model_id
+                for model_id in router_model_ids
+                if (deployment := llm_router.get_deployment(model_id=model_id)) is not None
+                and deployment.model_info.db_model is False
+            )
+            if model_list is None
+            else frozenset()
+        )
+        if kept_config_ids:
+            verbose_proxy_logger.warning(
+                "Config read in _delete_deployment returned no model_list. "
+                "Keeping %d config-defined deployments to avoid removing valid models.",
+                len(kept_config_ids),
+            )
+
         for model_id in router_model_ids:
-            if model_id not in combined_id_list:
+            if model_id not in combined_id_list and model_id not in kept_config_ids:
                 llm_router.delete_deployment(id=model_id)
-        return frozenset(combined_id_list)
+        return frozenset(combined_id_list) | kept_config_ids
 
     def _resolve_db_litellm_param(self, key: str, value: object) -> object:
         if not isinstance(value, str):
@@ -19267,6 +19297,7 @@ app.include_router(debugging_endpoints_router)
 app.include_router(rust_control_plane_router)
 app.include_router(ui_crud_endpoints_router)
 app.include_router(user_banner_endpoints_router)
+app.include_router(latest_release_endpoints_router)
 app.include_router(team_callback_router)
 app.include_router(budget_management_router)
 app.include_router(model_management_router)

litellm/proxy/public_endpoints/provider_create_fields.json

@@ -1321,6 +1321,34 @@
     ],
     "default_model_placeholder": "gpt-3.5-turbo"
   },
+  {
+    "provider": "EDENAI",
+    "provider_display_name": "Eden AI",
+    "litellm_provider": "edenai",
+    "credential_fields": [
+      {
+        "key": "api_base",
+        "label": "API Base",
+        "placeholder": "https://api.edenai.run/v3",
+        "tooltip": "Set to https://api.eu.edenai.run/v3 for the EU endpoint",
+        "required": false,
+        "field_type": "text",
+        "options": null,
+        "default_value": null
+      },
+      {
+        "key": "api_key",
+        "label": "API Key",
+        "placeholder": null,
+        "tooltip": null,
+        "required": true,
+        "field_type": "password",
+        "options": null,
+        "default_value": null
+      }
+    ],
+    "default_model_placeholder": "edenai/openai/gpt-mini-latest"
+  },
   {
     "provider": "ElevenLabs",
     "provider_display_name": "ElevenLabs",

litellm/proxy/spend_tracking/budget_reservation.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import json
 import math
+import time
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
@@ -105,6 +106,48 @@ def get_reserved_counter_keys(budget_reservation: dict | None) -> set:
     }
 
 
+_lease_renewals: Final[set[asyncio.Task[None]]] = set()  # mutable-ok: asyncio only weak-refs pending tasks
+
+
+def _start_reservation_lease_renewal(budget_reservation: Mapping[str, object], counter_keys: frozenset[str]) -> None:
+    """A reservation lives inside spend counter keys that expire on their Redis TTL. Renew the TTL
+    while the request is in flight so a request longer than the TTL does not drop its
+    reservation and admit concurrent requests against the DB floor on any worker."""
+    from litellm.proxy.proxy_server import spend_counter_cache
+
+    if spend_counter_cache.redis_cache is None or not counter_keys:
+        return
+    task: Final = asyncio.create_task(
+        _renew_reservation_lease(
+            budget_reservation=budget_reservation,
+            counter_keys=counter_keys,
+            interval=spend_counter_cache.redis_cache.default_ttl / 2,
+            request_task=asyncio.current_task(),
+        )
+    )
+    _lease_renewals.add(task)
+    task.add_done_callback(_lease_renewals.discard)
+
+
+async def _renew_reservation_lease(
+    budget_reservation: Mapping[str, object],
+    counter_keys: frozenset[str],
+    interval: float,
+    request_task: asyncio.Task[object] | None,
+) -> None:
+    """Stops on finalization or once the request task that took the reservation is gone, so a
+    disconnect path that skipped reconciliation falls back to the plain counter TTL."""
+    from litellm.proxy.proxy_server import refresh_spend_counter_ttl
+
+    deadline: Final = time.monotonic() + litellm.request_timeout
+    while time.monotonic() < deadline:
+        await asyncio.sleep(interval)
+        if budget_reservation.get("finalized") is True or (request_task is not None and request_task.done()):
+            return
+        for counter_key in counter_keys:
+            await refresh_spend_counter_ttl(counter_key=counter_key)
+
+
 def _key_reservation_should_release_for_throttle(counter_key: str, valid_token: UserAPIKeyAuth | None) -> bool:
     """
     Whether an over-budget key's own ``max_budget`` reservation should be
@@ -319,13 +362,18 @@ async def reserve_budget_for_request(
         llm_router=llm_router,
         input_token_counts=input_token_counts,
     )
-    return {
+    budget_reservation: Final = {
         "reserved_cost": reservation_cost,
         "entries": applied_entries,
         "finalized": False,
         "input_cost": min(float(input_cost or 0.0), reservation_cost),
         "input_tokens": max(input_token_counts.values(), default=None),
     }
+    _start_reservation_lease_renewal(
+        budget_reservation=budget_reservation,
+        counter_keys=frozenset(get_reserved_counter_keys(budget_reservation=budget_reservation)),
+    )
+    return budget_reservation
 
 
 async def reconcile_budget_reservation(

litellm/proxy/ui_crud_endpoints/latest_release_endpoints.py

@@ -0,0 +1,153 @@
+import asyncio
+import re
+from collections import Counter
+from collections.abc import Awaitable, Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Annotated, Final, Literal, Protocol, TypeAlias
+
+import httpx
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel, ValidationError
+
+from litellm._logging import verbose_proxy_logger
+from litellm.caching.in_memory_cache import InMemoryCache
+from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
+
+router: Final = APIRouter()
+
+LATEST_RELEASE_URL: Final = "https://api.github.com/repos/BerriAI/litellm/releases/latest"
+LATEST_RELEASE_FETCH_TIMEOUT_SECONDS: Final = 5
+LATEST_RELEASE_CACHE_TTL_SECONDS: Final = 60 * 60
+LATEST_RELEASE_UNAVAILABLE_CACHE_TTL_SECONDS: Final = 5 * 60
+LATEST_RELEASE_CACHE_KEY: Final = "latest_release_info"
+
+_RELEASE_BULLET_PATTERN: Final = re.compile(r"^\*\s+(?:([A-Za-z]+)(?:\([^)]*\))?!?:\s)?\S")
+_NEW_CONTRIBUTOR_PATTERN: Final = re.compile(r"^\*\s+@\S+ made their first contribution\b")
+
+_Bucket: TypeAlias = Literal["new_features", "bug_fixes", "other_updates"]
+_PREFIX_BUCKETS: Final[Mapping[str, _Bucket]] = MappingProxyType({"feat": "new_features", "fix": "bug_fixes"})
+
+
+class LatestReleaseInfo(BaseModel):
+    version: str
+    new_features: int
+    bug_fixes: int
+    other_updates: int
+    release_url: str
+
+
+@dataclass(frozen=True, slots=True)
+class LatestReleaseUnavailable:
+    reason: str
+
+
+class _GitHubRelease(BaseModel):
+    tag_name: str
+    html_url: str
+    body: str
+
+
+class _AsyncGetClient(Protocol):
+    def get(self, url: str, *, timeout: float | None = None) -> Awaitable[httpx.Response]: ...
+
+
+_latest_release_cache: Final = InMemoryCache(max_size_in_memory=1, default_ttl=LATEST_RELEASE_CACHE_TTL_SECONDS)
+_latest_release_fetch_lock: Final = asyncio.Lock()
+
+
+def _default_client() -> _AsyncGetClient:
+    from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
+    from litellm.types.llms.custom_http import httpxSpecialProvider
+
+    return get_async_httpx_client(llm_provider=httpxSpecialProvider.UI)
+
+
+def _default_cache() -> InMemoryCache:
+    return _latest_release_cache
+
+
+def _default_fetch_lock() -> asyncio.Lock:
+    return _latest_release_fetch_lock
+
+
+def _bucket_for(line: str) -> _Bucket | None:
+    if _NEW_CONTRIBUTOR_PATTERN.match(line) is not None:
+        return None
+    match: Final = _RELEASE_BULLET_PATTERN.match(line)
+    if match is None:
+        return None
+    prefix: Final = match.group(1)
+    return "other_updates" if prefix is None else _PREFIX_BUCKETS.get(prefix.lower(), "other_updates")
+
+
+def count_release_bullets(body: str) -> Mapping[_Bucket, int]:
+    """Bucket release-note bullets by conventional-commit type or ``other_updates``."""
+    return MappingProxyType(Counter(bucket for line in body.splitlines() if (bucket := _bucket_for(line)) is not None))
+
+
+def parse_latest_release(response: httpx.Response) -> LatestReleaseInfo | LatestReleaseUnavailable:
+    if response.status_code != 200:
+        return LatestReleaseUnavailable(reason=f"GitHub responded with status {response.status_code}")
+    try:
+        release: Final = _GitHubRelease.model_validate_json(response.content)
+    except ValidationError as e:
+        return LatestReleaseUnavailable(reason=f"GitHub release payload was not the expected shape: {e}")
+    counts: Final = count_release_bullets(release.body)
+    return LatestReleaseInfo(
+        version=release.tag_name.removeprefix("v"),
+        new_features=counts.get("new_features", 0),
+        bug_fixes=counts.get("bug_fixes", 0),
+        other_updates=counts.get("other_updates", 0),
+        release_url=release.html_url,
+    )
+
+
+async def fetch_latest_release(client: _AsyncGetClient) -> LatestReleaseInfo | LatestReleaseUnavailable:
+    try:
+        response: Final = await client.get(LATEST_RELEASE_URL, timeout=LATEST_RELEASE_FETCH_TIMEOUT_SECONDS)
+    except httpx.HTTPError as e:
+        return LatestReleaseUnavailable(reason=f"{type(e).__name__}: {e}")
+    return parse_latest_release(response)
+
+
+async def get_latest_release_info(
+    client: _AsyncGetClient, cache: InMemoryCache, fetch_lock: asyncio.Lock
+) -> LatestReleaseInfo | LatestReleaseUnavailable:
+    cached: Final = cache.get_cache(LATEST_RELEASE_CACHE_KEY)
+    if isinstance(cached, (LatestReleaseInfo, LatestReleaseUnavailable)):
+        return cached
+    async with fetch_lock:
+        cached_after_lock: Final = cache.get_cache(LATEST_RELEASE_CACHE_KEY)
+        if isinstance(cached_after_lock, (LatestReleaseInfo, LatestReleaseUnavailable)):
+            return cached_after_lock
+        result: Final = await fetch_latest_release(client)
+        ttl: Final = (
+            LATEST_RELEASE_UNAVAILABLE_CACHE_TTL_SECONDS
+            if isinstance(result, LatestReleaseUnavailable)
+            else LATEST_RELEASE_CACHE_TTL_SECONDS
+        )
+        cache.set_cache(LATEST_RELEASE_CACHE_KEY, result, ttl=ttl)
+        return result
+
+
+@router.get(
+    "/get/latest_release_info",
+    tags=["UI Settings"],  # mutable-ok: FastAPI's route decorator only accepts a list
+    dependencies=[Depends(user_api_key_auth)],  # mutable-ok: FastAPI's route decorator only accepts a list
+    response_model=LatestReleaseInfo | None,
+)
+async def latest_release_info(
+    client: Annotated[_AsyncGetClient, Depends(_default_client)],
+    cache: Annotated[InMemoryCache, Depends(_default_cache)],
+    fetch_lock: Annotated[asyncio.Lock, Depends(_default_fetch_lock)],
+) -> LatestReleaseInfo | None:
+    """
+    Latest stable LiteLLM GitHub release with its PR count split into new features, bug fixes and other updates.
+    Returns null when GitHub can't be reached so the dashboard upgrade banner simply doesn't render.
+    """
+    result: Final = await get_latest_release_info(client=client, cache=cache, fetch_lock=fetch_lock)
+    if isinstance(result, LatestReleaseUnavailable):
+        verbose_proxy_logger.warning("LiteLLM: latest release info unavailable: %s", result.reason)
+        return None
+    return result

litellm/types/llms/anthropic.py

@@ -751,6 +751,7 @@ class ANTHROPIC_BETA_HEADER_VALUES(str, Enum):
     FAST_MODE_2026_02_01 = "fast-mode-2026-02-01"
     ADVISOR_TOOL_2026_03_01 = "advisor-tool-2026-03-01"
     PER_TURN_CONTROL_2026_07_01 = "per-turn-control-2026-07-01"
+    DANGEROUS_TOOL_USE_2026_09_03 = "dangerous-tool-use-2026-09-03"
 
 
 # Tool search beta header constant (for Anthropic direct API and Microsoft Foundry)

litellm/types/llms/bedrock.py

@@ -1238,6 +1238,7 @@ class BedrockInvokeAnthropicMessagesRequest(TypedDict, total=False):
     thinking: dict
     metadata: dict
     output_config: dict
+    safeguards: list
 
     # `context_management` is allowed for Bedrock InvokeModel only when it
     # carries `compact_20260112` edits paired with the `compact-2026-01-12`

litellm/types/mcp_server/mcp_server_manager.py

@@ -99,6 +99,7 @@ class MCPServer(BaseModel):
     configured_authorization_url: str | None = None
     configured_token_url: str | None = None
     configured_registration_url: str | None = None
+    configured_scopes: tuple[str, ...] | None = None
     # How the gateway authenticates to the upstream token endpoint. When
     # "client_secret_basic" the credentials go in an HTTP Basic Authorization
     # header (omitted from the body); None defaults to "client_secret_post".

litellm/types/utils.py

@@ -4161,6 +4161,7 @@ class LlmProviders(str, Enum):
     OCI = "oci"
     AUTO_ROUTER = "auto_router"
     VERCEL_AI_GATEWAY = "vercel_ai_gateway"
+    EDENAI = "edenai"
     DOTPROMPT = "dotprompt"
     MANUS = "manus"
     WANDB = "wandb"

litellm/utils.py

@@ -3313,6 +3313,9 @@ def register_model(
         elif value.get("litellm_provider") == "vercel_ai_gateway":
             if key not in litellm.vercel_ai_gateway_models:
                 litellm.vercel_ai_gateway_models.add(key)
+        elif value.get("litellm_provider") == "edenai":
+            if key not in litellm.edenai_models:
+                litellm.edenai_models.add(key)
         elif value.get("litellm_provider") == "vertex_ai-text-models":
             if key not in litellm.vertex_text_models:
                 litellm.vertex_text_models.add(key)
@@ -4895,6 +4898,9 @@ def get_optional_params(
     return optional_params
 
 
+EXTRA_BODY_ROUTING_KEYS: Final = frozenset({"model"})
+
+
 def add_provider_specific_params_to_optional_params(
     optional_params: dict,
     passed_params: dict,
@@ -4920,10 +4926,8 @@ def add_provider_specific_params_to_optional_params(
                 **extra_body,
             }
 
-            if additional_drop_params is not None:
-                processed_extra_body = {k: v for k, v in initial_extra_body.items() if k not in additional_drop_params}
-            else:
-                processed_extra_body = initial_extra_body
+            dropped_keys: Final = EXTRA_BODY_ROUTING_KEYS | frozenset(additional_drop_params or ())
+            processed_extra_body: Final = {k: v for k, v in initial_extra_body.items() if k not in dropped_keys}
 
             _ensure_extra_body_is_safe: Final = getattr(sys.modules[__name__], "_ensure_extra_body_is_safe")
             optional_params["extra_body"] = _ensure_extra_body_is_safe(extra_body=processed_extra_body)
@@ -6574,6 +6578,11 @@ def validate_environment(
                 keys_in_environment = True
             else:
                 missing_keys.append("VERCEL_AI_GATEWAY_API_KEY")
+        elif custom_llm_provider == "edenai":
+            if "EDENAI_API_KEY" in os.environ:
+                keys_in_environment = True
+            else:
+                missing_keys.append("EDENAI_API_KEY")
         elif custom_llm_provider == "datarobot":
             if "DATAROBOT_API_TOKEN" in os.environ:
                 keys_in_environment = True
@@ -6824,6 +6833,12 @@ def validate_environment(
                 keys_in_environment = True
             else:
                 missing_keys.append("VERCEL_AI_GATEWAY_API_KEY")
+        ## edenai
+        elif model in litellm.edenai_models:
+            if "EDENAI_API_KEY" in os.environ:
+                keys_in_environment = True
+            else:
+                missing_keys.append("EDENAI_API_KEY")
         ## datarobot
         elif model in litellm.datarobot_models:
             if "DATAROBOT_API_TOKEN" in os.environ:
@@ -8324,6 +8339,7 @@ class ProviderConfigManager:
                 lambda: litellm.VercelAIGatewayConfig(),
                 False,
             ),
+            LlmProviders.EDENAI: (litellm.EdenAIChatConfig, False),
             LlmProviders.COMETAPI: (lambda: litellm.CometAPIConfig(), False),
             LlmProviders.DATAROBOT: (lambda: litellm.DataRobotConfig(), False),
             LlmProviders.GEMINI: (lambda: litellm.GoogleAIStudioGeminiConfig(), False),
@@ -8626,6 +8642,8 @@ class ProviderConfigManager:
             return SagemakerEmbeddingConfig.get_model_config(model)
         elif litellm.LlmProviders.PERPLEXITY == provider:
             return litellm.PerplexityEmbeddingConfig()
+        elif litellm.LlmProviders.EDENAI == provider:
+            return litellm.EdenAIEmbeddingConfig()
         return None
 
     @staticmethod
@@ -8746,6 +8764,8 @@ class ProviderConfigManager:
                 )
 
                 return GithubCopilotAnthropicMessagesConfig()
+        elif litellm.LlmProviders.EDENAI == provider:
+            return litellm.EdenAIAnthropicMessagesConfig()
 
         from litellm.llms.openai_like.json_loader import JSONProviderRegistry
 
@@ -8854,6 +8874,8 @@ class ProviderConfigManager:
             )
 
             return GeminiAudioTranscriptionConfig()
+        elif litellm.LlmProviders.EDENAI == provider:
+            return litellm.EdenAIAudioTranscriptionConfig()
         return None
 
     @staticmethod
@@ -8956,6 +8978,8 @@ class ProviderConfigManager:
             return litellm.HostedVLLMResponsesAPIConfig()
         elif litellm.LlmProviders.FIREWORKS_AI == provider:
             return litellm.FireworksAIResponsesAPIConfig()
+        elif litellm.LlmProviders.EDENAI == provider:
+            return litellm.EdenAIResponsesAPIConfig()
         elif litellm.LlmProviders.BEDROCK_MANTLE == provider:
             # Both decisions are data-driven from the model's price-map entry, with
             # no model-name logic. Capability (can it serve Responses?) comes from
@@ -9028,7 +9052,7 @@ class ProviderConfigManager:
         return litellm.OpenAITextCompletionConfig()
 
     @staticmethod
-    def get_provider_model_info(
+    def get_provider_model_info(  # noqa: C901  # provider dispatch table, one branch per provider
         model: str | None,
         provider: LlmProviders,
     ) -> BaseLLMModelInfo | None:
@@ -9065,6 +9089,8 @@ class ProviderConfigManager:
             return litellm.LemonadeChatConfig()
         elif LlmProviders.CLARIFAI == provider:
             return litellm.ClarifaiConfig()
+        elif LlmProviders.EDENAI == provider:
+            return litellm.EdenAIChatConfig()
         elif LlmProviders.BEDROCK == provider:
             from litellm.llms.bedrock.common_utils import BedrockModelInfo
 
@@ -9413,6 +9439,8 @@ class ProviderConfigManager:
             )
 
             return get_modelscope_image_generation_config(model)
+        elif LlmProviders.EDENAI == provider:
+            return litellm.EdenAIImageGenerationConfig()
         return None
 
     @staticmethod
@@ -9448,6 +9476,8 @@ class ProviderConfigManager:
             from litellm.llms.hosted_vllm.videos import get_hosted_vllm_video_config
 
             return get_hosted_vllm_video_config(model)
+        elif LlmProviders.EDENAI == provider:
+            return litellm.EdenAIVideoConfig()
         return None
 
     @staticmethod
@@ -9768,6 +9798,8 @@ class ProviderConfigManager:
             )
 
             return AWSPollyTextToSpeechConfig()
+        elif litellm.LlmProviders.EDENAI == provider:
+            return litellm.EdenAITextToSpeechConfig()
         return None
 
     @staticmethod

model_prices_and_context_window.json

@@ -43011,21 +43011,21 @@
         "supports_web_search": false
     },
     "openrouter/deepseek/deepseek-v4-pro": {
-        "input_cost_per_token": 9.15936e-07,
+        "input_cost_per_token": 9.00798e-07,
         "input_cost_per_token_cache_hit": 4.4e-08,
         "litellm_provider": "openrouter",
         "max_input_tokens": 1048576,
         "max_output_tokens": 384000,
         "max_tokens": 384000,
         "mode": "chat",
-        "output_cost_per_token": 1.831872e-06,
+        "output_cost_per_token": 1.801596e-06,
         "source": "https://openrouter.ai/api/v1/models",
         "supports_function_calling": true,
         "supports_prompt_caching": true,
         "supports_reasoning": true,
         "supports_response_schema": true,
         "supports_tool_choice": true,
-        "cache_read_input_token_cost": 7.6328e-08,
+        "cache_read_input_token_cost": 7.50665e-08,
         "supports_audio_input": false,
         "supports_pdf_input": false,
         "supports_vision": false,
@@ -76889,5 +76889,65 @@
         "supports_system_messages": true,
         "supports_tool_choice": true,
         "supports_vision": true
+    },
+    "openrouter/xiaomi/mimo-v2.6-flash": {
+        "cache_read_input_token_cost": 2.8e-09,
+        "input_cost_per_token": 1.4e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 2.8e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/xiaomi/mimo-v2.6-pro": {
+        "cache_read_input_token_cost": 3.6e-09,
+        "input_cost_per_token": 4.35e-07,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 8.7e-07,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
+    },
+    "openrouter/xiaomi/mimo-v2.6-pro-ultraspeed": {
+        "cache_read_input_token_cost": 3.6e-08,
+        "input_cost_per_token": 4.35e-06,
+        "litellm_provider": "openrouter",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 131072,
+        "max_tokens": 131072,
+        "mode": "chat",
+        "output_cost_per_token": 8.7e-06,
+        "source": "https://openrouter.ai/api/v1/models",
+        "supports_audio_input": true,
+        "supports_function_calling": true,
+        "supports_pdf_input": false,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_response_schema": true,
+        "supports_tool_choice": true,
+        "supports_vision": true,
+        "supports_web_search": false
     }
 }

provider_endpoints_support.json

@@ -868,6 +868,24 @@
         "interactions": true
       }
     },
+    "edenai": {
+      "display_name": "Eden AI (`edenai`)",
+      "url": "https://docs.litellm.ai/docs/providers/edenai",
+      "endpoints": {
+        "chat_completions": true,
+        "messages": true,
+        "responses": true,
+        "embeddings": true,
+        "image_generations": true,
+        "audio_transcriptions": true,
+        "audio_speech": true,
+        "moderations": false,
+        "batches": false,
+        "rerank": false,
+        "interactions": false,
+        "video_generations": true
+      }
+    },
     "duckduckgo": {
       "display_name": "DuckDuckGo (`duckduckgo`)",
       "url": "https://docs.litellm.ai/docs/search/duckduckgo",

pyproject.toml

@@ -236,6 +236,7 @@ e2e-dev = [
     "playwright==1.61.0",
     "websockets>=15.0.1,<16.0",
     "locust==2.45.0",
+    "anthropic==0.84.0",
     "psutil==7.2.2",
     "mcp>=2.2.0,<3",
 ]

tests/e2e/AGENTS.md

@@ -85,6 +85,8 @@ That snippet only conveys intent. What you actually write uses the real harness:
 
 Every HTTP call goes through the shared transport, never through `requests.*` in a test. `e2e_http.py` is the only module permitted to call `requests.*`, and that is enforced in CI by `tests/code_coverage_tests/check_e2e_no_raw_requests.py`. A test that imports requests will fail the check
 
+One deliberate exception: LLM-endpoint calls in `llm_translation/` go through the real provider SDKs (OpenAI, Anthropic) via the suite's `sdk` fixture (`llm_translation/sdk_clients.py`), because that is what customers actually run against the proxy (LIT-4577). The SDKs raise their own typed exceptions on failure, which is exactly the customer-observable contract; management routes (model/key CRUD, spend read-back) and endpoints no official SDK covers (e.g. `/v1/rerank`, `/v1/ocr`, custom passthrough paths) stay on the shared transport. Raw HTTP client imports remain banned either way
+
 The shape is layered so tests stay declarative
 
 `transport.py` exposes a `Transport` Protocol with `post`, `get`, `delete`, `send`, `stream`, `probe`, plus `bearer(key)` and the `master` header. `HttpTransport` fulfils it, and `SplitTransport` routes each call by path to the data plane or the control plane so a split control-plane/data-plane deployment works without any change in the test

tests/e2e/CONTRIBUTING.md

@@ -75,10 +75,10 @@ The suites run against a live proxy, so bring one up first by running the litell
 
    Buildkite runs this suite against a Keycloak deployed beside the ephemeral stack by project-releaser. It fetches the realm from the test-runner revision even when it reuses a gateway image from another commit. The GitHub Actions changed-test stack starts the same digest-pinned Keycloak through `.github/e2e-stack/start-idp.sh`, imports the checked-out realm, and exports the IdP URL and credentials in `stack.env`. Both runners configure issuer/audience validation and store the realm, keys and users in a separate schema in the stack's PostgreSQL, so replacing Keycloak preserves token validity. Both wait for realm discovery before running tests. Losing the whole ephemeral database invalidates the stack. Keycloak skips imports into an existing realm, so changes to the realm export require a fresh stack (or deliberately replacing the local data volume). A stack without it fails the JWT tests rather than skipping them
 
-4. Run a suite against it; the harness reads `LITELLM_PROXY_URL` (default `http://localhost:4000`):
+4. Run a suite against it; the harness reads `LITELLM_PROXY_URL` (default `http://localhost:4000`). The suites' client dependencies (the provider SDKs, websockets) live in the `e2e-dev` dependency group; `make bootstrap` installs it, and naming the group on the run keeps the command working from any environment state:
 
    ```bash
-   uv run pytest tests/e2e/llm_translation/ -v
+   uv run --group e2e-dev pytest tests/e2e/llm_translation/ -v
    ```
 
    The browser tests in the `management/` suite drive the dashboard the proxy serves at `/ui` through playwright, an optional dependency behind `importorskip` (the suite's API tests run without it). It lives in the `e2e-dev` dependency group; install it along with its browser:
@@ -206,6 +206,8 @@ That snippet only conveys intent. What you actually write uses the real harness:
 
 Every HTTP call goes through the shared transport, never through `requests.*` in a test. `e2e_http.py` is the only module permitted to call `requests.*`, and that is enforced in CI by `tests/code_coverage_tests/check_e2e_no_raw_requests.py`. A test that imports requests will fail the check
 
+One deliberate exception: LLM-endpoint calls in `llm_translation/` go through the real provider SDKs (OpenAI, Anthropic) via the suite's `sdk` fixture (`llm_translation/sdk_clients.py`), because that is what customers actually run against the proxy (LIT-4577). Management routes and endpoints no official SDK covers stay on the shared transport, and raw HTTP client imports remain banned either way
+
 The shape is layered so tests stay declarative
 
 `transport.py` exposes a `Transport` Protocol with `post`, `get`, `delete`, `send`, `stream`, `probe`, plus `bearer(key)` and the `master` header. `HttpTransport` fulfils it, and `SplitTransport` routes each call by path to the data plane or the control plane so a split control-plane/data-plane deployment works without any change in the test
@@ -230,7 +232,7 @@ Before you push
 
    ```bash
    litellm --config <your-e2e-config>.yml --port 4000
-   uv run pytest tests/e2e/<your_suite>/ -v
+   uv run --group e2e-dev pytest tests/e2e/<your_suite>/ -v
    ```
 
 4. Capture screenshots of the test run and attach them to the PR as proof

tests/e2e/llm_translation/conftest.py

@@ -2,14 +2,16 @@
 
 The shared lifecycle (resources/scoped_key), proxy liveness gate, and e2e marker
 live in the parent tests/e2e/conftest.py. PassthroughClient holds the shared
-ProxyClient, so the `resources` fixture cleans up keys this suite creates.
+ProxyClient, so the `resources` fixture cleans up keys this suite creates. The
+`sdk` fixture hands tests real provider SDK clients (OpenAI, Anthropic) pointed
+at the proxy, the way customers actually call it.
 """
 
 import pytest
 
-from endpoints_client import EndpointsClient, build_endpoints_client
 from passthrough_client import PassthroughClient, build_client
 from proxy_client import ProxyClient
+from sdk_clients import SdkClients, build_sdk_clients
 
 
 def pytest_configure(config: pytest.Config) -> None:
@@ -25,5 +27,5 @@ def client(proxy: ProxyClient) -> PassthroughClient:
 
 
 @pytest.fixture(scope="session")
-def endpoints_client(proxy: ProxyClient) -> EndpointsClient:
-    return build_endpoints_client(proxy)
+def sdk() -> SdkClients:
+    return build_sdk_clients()

tests/e2e/llm_translation/endpoints_client.py

@@ -1,476 +0,0 @@
-"""Client for the non-chat inference endpoints (responses, messages, rerank,
-embeddings, audio speech, image generation).
-
-Each test registers the deployment it needs through /model/new (deleted on
-teardown), so nothing is hardcoded into the gateway config, then drives the
-endpoint with `send` and parses the provider-native body with a suite-local model
-so the assertion is on real content, not just a 200.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Literal
-
-from e2e_config import SLOW_PROVIDER_TIMEOUT_SECONDS
-from e2e_http import BinaryStream, Result, StreamingResponse
-from models import CacheControl, ChatMessage, LiteLLMParamsBody, RichMessage, TextBlock
-from proxy_client import ProxyClient
-from pydantic import BaseModel
-
-__all__ = [
-    "CacheControl",
-    "ImageEditForm",
-    "ImagesResult",
-    "RichMessage",
-    "TextBlock",
-    "TranscriptionForm",
-    "TranscriptionResult",
-]
-
-
-class FunctionParameterProperty(BaseModel):
-    type: str
-    description: str | None = None
-
-
-class FunctionParameters(BaseModel):
-    type: Literal["object"] = "object"
-    properties: dict[str, FunctionParameterProperty]
-    required: list[str] = []
-
-
-class ResponsesFunctionTool(BaseModel):
-    type: Literal["function"] = "function"
-    name: str
-    description: str | None = None
-    parameters: FunctionParameters
-
-
-class ResponsesInputTextPart(BaseModel):
-    type: Literal["input_text"] = "input_text"
-    text: str
-
-
-class ResponsesInputImagePart(BaseModel):
-    type: Literal["input_image"] = "input_image"
-    image_url: str
-
-
-ResponsesInputContentPart = ResponsesInputTextPart | ResponsesInputImagePart
-
-
-class ResponsesInputMessage(BaseModel):
-    role: Literal["user", "assistant", "system"] = "user"
-    content: list[ResponsesInputContentPart]
-
-
-ResponsesInput = str | list[ResponsesInputMessage]
-
-
-class ResponsesRequest(BaseModel):
-    model: str
-    input: ResponsesInput
-    instructions: str | None = None
-    stream: bool = False
-    tools: list[ResponsesFunctionTool] | None = None
-    guardrails: list[str] | None = None
-    safety_identifier: str | None = None
-    cache: dict[str, bool] | None = {"no-cache": True}
-
-
-class MessagesRequest(BaseModel):
-    model: str
-    max_tokens: int
-    messages: list[ChatMessage]
-    cache: dict[str, bool] | None = {"no-cache": True}
-
-
-class RichMessagesRequest(BaseModel):
-    model: str
-    max_tokens: int = 64
-    system: list[TextBlock]
-    messages: list[RichMessage]
-    cache: dict[str, bool] | None = {"no-cache": True}
-
-
-class CompletionsRequest(BaseModel):
-    model: str
-    prompt: str
-    max_tokens: int = 32
-    cache: dict[str, bool] | None = {"no-cache": True}
-
-
-class EmbeddingsRequest(BaseModel):
-    model: str
-    input: str
-    cache: dict[str, bool] | None = {"no-cache": True}
-
-
-class RerankRequest(BaseModel):
-    model: str
-    query: str
-    documents: list[str]
-    top_n: int
-    cache: dict[str, bool] | None = {"no-cache": True}
-
-
-class SpeechRequest(BaseModel):
-    model: str
-    input: str
-    voice: str
-
-
-class ImageRequest(BaseModel):
-    model: str
-    prompt: str
-    n: int = 1
-    size: str = "1024x1024"
-
-
-class ImageEditForm(BaseModel):
-    model: str
-    prompt: str
-    n: int = 1
-
-
-class TranscriptionForm(BaseModel):
-    model: str
-    response_format: str = "json"
-
-
-class ModerationRequest(BaseModel):
-    model: str
-    input: str
-
-
-class GenerateContentPart(BaseModel):
-    text: str
-
-
-class GenerateContentContent(BaseModel):
-    role: Literal["user"] = "user"
-    parts: tuple[GenerateContentPart, ...]
-
-
-class GenerateContentBody(BaseModel):
-    contents: tuple[GenerateContentContent, ...]
-
-
-class ResponsesOutputContent(BaseModel):
-    type: str | None = None
-    text: str | None = None
-
-
-class ResponsesOutputItem(BaseModel):
-    type: str | None = None
-    content: list[ResponsesOutputContent] = []
-    name: str | None = None
-    arguments: str | None = None
-    call_id: str | None = None
-
-
-class ResponsesResult(BaseModel):
-    id: str | None = None
-    status: str | None = None
-    model: str | None = None
-    output: list[ResponsesOutputItem] = []
-
-    @property
-    def text(self) -> str:
-        return "".join(
-            content.text or "" for item in self.output for content in item.content
-        )
-
-    @property
-    def function_calls(self) -> tuple[ResponsesOutputItem, ...]:
-        return tuple(
-            item
-            for item in self.output
-            if item.type == "function_call"
-            and item.name is not None
-            and item.arguments is not None
-        )
-
-
-class ResponsesStreamEvent(BaseModel):
-    event_id: str | None = None
-
-
-class ResponsesStreamEventType(BaseModel):
-    type: str
-
-
-class ResponsesOutputTextDeltaEvent(ResponsesStreamEvent):
-    type: Literal["response.output_text.delta"]
-    delta: str
-
-
-class AnthropicContentBlock(BaseModel):
-    type: str | None = None
-    text: str | None = None
-
-
-class MessagesUsage(BaseModel):
-    input_tokens: int = 0
-    output_tokens: int = 0
-    cache_creation_input_tokens: int = 0
-    cache_read_input_tokens: int = 0
-
-
-class MessagesResult(BaseModel):
-    id: str | None = None
-    role: str | None = None
-    model: str | None = None
-    content: list[AnthropicContentBlock] = []
-    usage: MessagesUsage = MessagesUsage()
-
-    @property
-    def text(self) -> str:
-        return "".join(block.text or "" for block in self.content)
-
-
-class CompletionChoice(BaseModel):
-    text: str | None = None
-
-
-class CompletionsResult(BaseModel):
-    choices: list[CompletionChoice] = []
-
-
-class EmbeddingItem(BaseModel):
-    embedding: list[float] = []
-
-
-class EmbeddingsResult(BaseModel):
-    data: list[EmbeddingItem] = []
-
-    @property
-    def first_vector(self) -> tuple[float, ...]:
-        return tuple(self.data[0].embedding) if self.data else ()
-
-
-class RerankItem(BaseModel):
-    index: int | None = None
-    relevance_score: float | None = None
-
-
-class RerankResult(BaseModel):
-    results: list[RerankItem] = []
-
-
-class ImageItem(BaseModel):
-    url: str | None = None
-    b64_json: str | None = None
-
-
-class ImagesResult(BaseModel):
-    data: list[ImageItem] = []
-
-
-class TranscriptionResult(BaseModel):
-    text: str = ""
-
-
-class ModerationResultItem(BaseModel):
-    flagged: bool
-    categories: dict[str, bool] = {}
-
-    @property
-    def flagged_categories(self) -> tuple[str, ...]:
-        return tuple(name for name, hit in self.categories.items() if hit)
-
-
-class ModerationResult(BaseModel):
-    results: list[ModerationResultItem] = []
-
-    @property
-    def first(self) -> ModerationResultItem | None:
-        return self.results[0] if self.results else None
-
-
-@dataclass(frozen=True, slots=True)
-class EndpointsClient:
-    proxy: ProxyClient
-
-    def create_model(self, model_name: str, litellm_params: LiteLLMParamsBody) -> str:
-        return self.proxy.create_model(model_name, litellm_params)
-
-    def delete_model(self, model_id: str) -> None:
-        self.proxy.delete_model(model_id)
-
-    def _send(
-        self, path: str, key: str, body: BaseModel, *, stream: bool = False
-    ) -> StreamingResponse:
-        return self.proxy.transport.send(
-            path,
-            headers=self.proxy.transport.bearer(key),
-            json=body,
-            stream=stream,
-        )
-
-    def responses(
-        self,
-        key: str,
-        model: str,
-        text: str,
-        *,
-        stream: bool = False,
-        guardrails: list[str] | None = None,
-        safety_identifier: str | None = None,
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/responses",
-            key,
-            ResponsesRequest(
-                model=model,
-                input=text,
-                instructions="You are a helpful assistant",
-                stream=stream,
-                guardrails=guardrails,
-                safety_identifier=safety_identifier,
-            ),
-            stream=stream,
-        )
-
-    def responses_vision(
-        self, key: str, model: str, text: str, image_url: str
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/responses",
-            key,
-            ResponsesRequest(
-                model=model,
-                input=[
-                    ResponsesInputMessage(
-                        content=[
-                            ResponsesInputTextPart(text=text),
-                            ResponsesInputImagePart(image_url=image_url),
-                        ]
-                    )
-                ],
-                instructions="You are a helpful assistant",
-            ),
-        )
-
-    def responses_with_tools(
-        self, key: str, model: str, text: str, tools: list[ResponsesFunctionTool]
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/responses",
-            key,
-            ResponsesRequest(
-                model=model,
-                input=text,
-                instructions="You are a helpful assistant",
-                tools=tools,
-            ),
-        )
-
-    def messages(
-        self, key: str, model: str, text: str, *, max_tokens: int = 64
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/messages",
-            key,
-            MessagesRequest(
-                model=model,
-                max_tokens=max_tokens,
-                messages=[ChatMessage(role="user", content=text)],
-            ),
-        )
-
-    def text_completions(
-        self, key: str, model: str, prompt: str, *, max_tokens: int = 32
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/completions",
-            key,
-            CompletionsRequest(model=model, prompt=prompt, max_tokens=max_tokens),
-        )
-
-    def embeddings(self, key: str, model: str, text: str) -> StreamingResponse:
-        return self._send("/embeddings", key, EmbeddingsRequest(model=model, input=text))
-
-    def rerank(
-        self, key: str, model: str, query: str, documents: list[str], top_n: int
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/rerank",
-            key,
-            RerankRequest(model=model, query=query, documents=documents, top_n=top_n),
-        )
-
-    def audio_speech(
-        self, key: str, model: str, text: str, *, voice: str = "alloy"
-    ) -> StreamingResponse:
-        return self._send(
-            "/v1/audio/speech", key, SpeechRequest(model=model, input=text, voice=voice)
-        )
-
-    def audio_speech_stream(
-        self, key: str, model: str, text: str, *, voice: str = "alloy"
-    ) -> BinaryStream:
-        return self.proxy.transport.stream_binary(
-            "/v1/audio/speech",
-            headers=self.proxy.transport.bearer(key),
-            json=SpeechRequest(model=model, input=text, voice=voice),
-        )
-
-    def transcribe(
-        self, key: str, model: str, *, filename: str, content: bytes
-    ) -> Result[TranscriptionResult]:
-        return self.proxy.transport.upload(
-            "/v1/audio/transcriptions",
-            headers=self.proxy.transport.bearer(key),
-            form=TranscriptionForm(model=model),
-            filename=filename,
-            content=content,
-            file_content_type="audio/wav",
-            response_type=TranscriptionResult,
-        )
-
-    def moderations(self, key: str, model: str, text: str) -> Result[ModerationResult]:
-        return self.proxy.transport.post(
-            "/v1/moderations",
-            headers=self.proxy.transport.bearer(key),
-            json=ModerationRequest(model=model, input=text),
-            response_type=ModerationResult,
-        )
-
-    def images(self, key: str, model: str, prompt: str) -> StreamingResponse:
-        return self._send(
-            "/v1/images/generations", key, ImageRequest(model=model, prompt=prompt)
-        )
-
-    def image_edit(
-        self, key: str, model: str, prompt: str, image: bytes, *, filename: str = "image.png"
-    ) -> Result[ImagesResult]:
-        return self.proxy.transport.upload(
-            "/v1/images/edits",
-            headers=self.proxy.transport.bearer(key),
-            form=ImageEditForm(model=model, prompt=prompt),
-            filename=filename,
-            content=image,
-            file_content_type="image/png",
-            file_field="image",
-            response_type=ImagesResult,
-            timeout=SLOW_PROVIDER_TIMEOUT_SECONDS,
-        )
-
-    def generate_content(
-        self, key: str, model: str, text: str, *, stream: bool = False
-    ) -> StreamingResponse:
-        operation = "streamGenerateContent" if stream else "generateContent"
-        return self._send(
-            f"/v1beta/models/{model}:{operation}",
-            key,
-            GenerateContentBody(
-                contents=(GenerateContentContent(parts=(GenerateContentPart(text=text),)),)
-            ),
-            stream=stream,
-        )
-
-
-def build_endpoints_client(proxy: ProxyClient) -> EndpointsClient:
-    return EndpointsClient(proxy=proxy)

tests/e2e/llm_translation/sdk_clients.py

@@ -0,0 +1,62 @@
+"""Real provider SDK clients pointed at the proxy, connected the way customers
+connect (LIT-4577).
+
+The OpenAI SDK drives the OpenAI-compatible surface (/responses, /embeddings,
+/images/generations, /moderations, /audio/*) and the Anthropic SDK drives
+/v1/messages, each authenticated with a litellm virtual key. Errors surface as
+the SDK's own exceptions, exactly what an end user sees. Retries are disabled
+so a proxy fault fails the test instead of being papered over, and the timeout
+matches the shared transport's request budget.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Final
+
+from anthropic import Anthropic
+from openai import OpenAI
+
+from e2e_config import PROXY_BASE_URL, REQUEST_TIMEOUT
+
+NO_PROXY_CACHE: Final = MappingProxyType({"cache": {"no-cache": True}})
+"""``extra_body`` for every cacheable SDK call (messages, responses, completions,
+embeddings): the gateway under test caches those call types, so an identical
+re-send would otherwise be served from Redis instead of reaching the provider,
+which hides provider-side behavior such as prompt-cache warm-up. The SDKs
+themselves cannot bypass it (``Cache-Control`` only sets a TTL on the proxy)."""
+
+
+def response_header(headers: Mapping[str, str], name: str) -> str | None:
+    """Typed read of an SDK response header: httpx.Headers.get returns Any and
+    httpx itself is a banned import in suite code, so tests read headers through
+    the Mapping[str, str] interface Headers fulfils."""
+    return headers[name] if name in headers else None
+
+
+@dataclass(frozen=True, slots=True)
+class SdkClients:
+    base_url: str
+    request_timeout: float
+
+    def openai(self, key: str) -> OpenAI:
+        return OpenAI(
+            base_url=self.base_url,
+            api_key=key,
+            timeout=self.request_timeout,
+            max_retries=0,
+        )
+
+    def anthropic(self, key: str) -> Anthropic:
+        return Anthropic(
+            base_url=self.base_url,
+            api_key=key,
+            timeout=self.request_timeout,
+            max_retries=0,
+        )
+
+
+def build_sdk_clients() -> SdkClients:
+    return SdkClients(base_url=PROXY_BASE_URL, request_timeout=REQUEST_TIMEOUT)

tests/e2e/llm_translation/test_audio_speech_e2e.py

@@ -1,20 +1,23 @@
 """Live e2e: POST /v1/audio/speech returns audio, non-streamed and streamed.
 
-The non-streamed call asserts an audio (not JSON) body. The streamed call consumes
-the response the way a player would and asserts customer-observable streaming:
-chunked transfer encoding (a buffered body would carry a content-length) with
-non-zero audio bytes.
+Both positive calls go through the real OpenAI SDK (LIT-4577). The non-streamed
+call asserts an audio (not JSON) body. The streamed call consumes the response
+the way a player would and asserts customer-observable streaming: chunked
+transfer encoding (a buffered body would carry a content-length) with non-zero
+audio bytes. The malformed-body negatives stay on the shared transport because
+the SDK refuses to send a request missing its required fields.
 """
 
 from __future__ import annotations
 
 import pytest
 from e2e_config import unique_marker
-from e2e_http import assert_client_error, require_successful_call
-from endpoints_client import EndpointsClient
+from e2e_http import assert_client_error
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
 from pydantic import BaseModel
+from sdk_clients import SdkClients, response_header
 
 pytestmark = pytest.mark.e2e
 
@@ -25,67 +28,75 @@ class _OptionalSpeechBody(BaseModel):
     voice: str | None = None
 
 
-def _register_tts(
-    endpoints_client: EndpointsClient, resources: ResourceManager
-) -> tuple[str, str]:
+def _register_tts(proxy: ProxyClient, resources: ResourceManager) -> tuple[str, str]:
     model = f"e2e-speech-{unique_marker()}"
-    model_id = endpoints_client.create_model(
+    model_id = proxy.create_model(
         model,
         LiteLLMParamsBody(model="openai/gpt-4o-mini-tts", api_key="os.environ/OPENAI_API_KEY"),
     )
-    resources.defer(lambda: endpoints_client.delete_model(model_id))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model, resources.key()
 
 
 class TestAudioSpeech:
     @pytest.mark.covers("llm.audio_speech.openai.basic.nonstream.works")
     def test_audio_speech_returns_audio(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model, key = _register_tts(endpoints_client, resources)
-        result = endpoints_client.audio_speech(key, model, "Hello!")
-        require_successful_call(result)
-        assert "audio" in (result.content_type or ""), (
-            f"/audio/speech content-type is not audio: {result.content_type!r}"
+        model, key = _register_tts(proxy, resources)
+        client = sdk.openai(key)
+
+        response = client.audio.speech.with_raw_response.create(
+            model=model, voice="alloy", input="Hello!"
         )
-        assert result.body, "/audio/speech returned an empty body"
+        content_type = response_header(response.headers, "content-type")
+        assert "audio" in (content_type or ""), (
+            f"/audio/speech content-type is not audio: {content_type!r}"
+        )
+        assert response.content, "/audio/speech returned an empty body"
 
     @pytest.mark.covers("llm.audio_speech.openai.basic.stream.works")
     def test_audio_speech_streams_audio_chunks(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model, key = _register_tts(endpoints_client, resources)
-        result = endpoints_client.audio_speech_stream(
-            key,
-            model,
-            "Streaming speech should arrive in several audio chunks so a client can "
-            "begin playback well before the whole clip has finished generating.",
+        model, key = _register_tts(proxy, resources)
+        client = sdk.openai(key)
+
+        with client.audio.speech.with_streaming_response.create(
+            model=model,
+            voice="alloy",
+            input=(
+                "Streaming speech should arrive in several audio chunks so a client can "
+                "begin playback well before the whole clip has finished generating."
+            ),
+        ) as response:
+            content_type = response_header(response.headers, "content-type")
+            transfer_encoding = response_header(response.headers, "transfer-encoding")
+            content_length = response_header(response.headers, "content-length")
+            total_bytes = sum(len(chunk) for chunk in response.iter_bytes(chunk_size=8192))
+
+        assert "audio" in (content_type or ""), (
+            f"/audio/speech content-type is not audio: {content_type!r}"
         )
-        assert result.ok, (
-            f"/audio/speech stream failed (status {result.status_code}); body={result.error_body}"
+        assert "chunked" in (transfer_encoding or ""), (
+            f"/audio/speech did not stream: transfer-encoding={transfer_encoding!r}, "
+            f"content-length={content_length!r} (a buffered body is not a stream)"
         )
-        assert "audio" in (result.content_type or ""), (
-            f"/audio/speech content-type is not audio: {result.content_type!r}"
-        )
-        assert result.chunked, (
-            f"/audio/speech did not stream: transfer-encoding={result.transfer_encoding!r}, "
-            f"content-length={result.content_length!r} (a buffered body is not a stream)"
-        )
-        assert result.content_length is None, (
-            f"/audio/speech advertised content-length={result.content_length!r} on a "
+        assert content_length is None, (
+            f"/audio/speech advertised content-length={content_length!r} on a "
             f"streamed response (a buffered body is not a stream)"
         )
-        assert result.total_bytes > 0, "/audio/speech stream returned no audio bytes"
+        assert total_bytes > 0, "/audio/speech stream returned no audio bytes"
 
     @pytest.mark.skip(reason="stage red: product gap, /v1/audio/speech 500s on missing input instead of 400")
     @pytest.mark.covers("llm.audio_speech.openai.input_validation.nonstream.works")
     def test_missing_input_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        model, key = _register_tts(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+        model, key = _register_tts(proxy, resources)
+        result = proxy.transport.send(
             "/v1/audio/speech",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalSpeechBody(model=model, voice="alloy"),
         )
         assert_client_error(result, "speech missing input")
@@ -93,12 +104,12 @@ class TestAudioSpeech:
     @pytest.mark.skip(reason="stage red: product gap, /v1/audio/speech 500s on missing model instead of 400")
     @pytest.mark.covers("llm.audio_speech.openai.input_validation.nonstream.works")
     def test_missing_model_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        _, key = _register_tts(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+        _, key = _register_tts(proxy, resources)
+        result = proxy.transport.send(
             "/v1/audio/speech",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalSpeechBody(input="hello", voice="alloy"),
         )
         assert_client_error(result, "speech missing model")
@@ -106,12 +117,12 @@ class TestAudioSpeech:
     @pytest.mark.skip(reason="stage red: product gap, /v1/audio/speech 500s on invalid voice instead of surfacing the provider 4xx")
     @pytest.mark.covers("llm.audio_speech.openai.input_validation.nonstream.works")
     def test_invalid_voice_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        model, key = _register_tts(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+        model, key = _register_tts(proxy, resources)
+        result = proxy.transport.send(
             "/v1/audio/speech",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalSpeechBody(model=model, input="hello", voice="invalid_voice_xyz"),
         )
         assert_client_error(result, "speech invalid voice")
@@ -119,12 +130,12 @@ class TestAudioSpeech:
     @pytest.mark.skip(reason="stage red: product gap, /v1/audio/speech 500s on empty input instead of surfacing the provider 4xx")
     @pytest.mark.covers("llm.audio_speech.openai.input_validation.nonstream.works")
     def test_empty_input_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        model, key = _register_tts(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+        model, key = _register_tts(proxy, resources)
+        result = proxy.transport.send(
             "/v1/audio/speech",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalSpeechBody(model=model, input="", voice="alloy"),
         )
         assert_client_error(result, "speech empty input")

tests/e2e/llm_translation/test_audio_transcriptions_e2e.py

@@ -1,12 +1,13 @@
 """Live e2e: POST /v1/audio/transcriptions turns speech into text (vendor §9.7 / LIT-4778).
 
 Registers an OpenAI speech-to-text deployment at runtime and uploads a spoken
-weather question (the realtime suite's 24kHz WAV fixture) as multipart, asserting
-the returned transcript is non-empty and mentions the word it was asked about.
-Also pins missing file/model negatives. A model-less request comes back as one of
-two 400s depending on whether any wildcard deployment happens to be registered on
-the shared proxy, so the assertion accepts either phrasing and holds both to naming
-the model as the problem.
+weather question (the realtime suite's 24kHz WAV fixture) through the real
+OpenAI SDK (LIT-4577), asserting the returned transcript is non-empty and
+mentions the word it was asked about. Also pins missing file/model negatives on
+the shared multipart transport, since the SDK refuses to send them. A model-less
+request comes back as one of two 400s depending on whether any wildcard
+deployment happens to be registered on the shared proxy, so the assertion
+accepts either phrasing and holds both to naming the model as the problem.
 """
 
 from __future__ import annotations
@@ -16,11 +17,12 @@ from typing import Final
 
 import pytest
 from e2e_config import unique_marker
-from e2e_http import UnknownApiError, unwrap
-from endpoints_client import EndpointsClient, TranscriptionForm, TranscriptionResult
+from e2e_http import UnknownApiError
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
 from pydantic import BaseModel
+from sdk_clients import SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -36,32 +38,34 @@ class _OptionalTranscriptionForm(BaseModel):
     response_format: str = "json"
 
 
-def _register(
-    endpoints_client: EndpointsClient, resources: ResourceManager
-) -> tuple[str, str]:
+class _TranscriptionResult(BaseModel):
+    text: str = ""
+
+
+def _register(proxy: ProxyClient, resources: ResourceManager) -> tuple[str, str]:
     model = f"e2e-transcribe-{unique_marker()}"
-    model_id = endpoints_client.create_model(
+    model_id = proxy.create_model(
         model,
         LiteLLMParamsBody(
             model="openai/gpt-4o-mini-transcribe", api_key="os.environ/OPENAI_API_KEY"
         ),
     )
-    resources.defer(lambda: endpoints_client.delete_model(model_id))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model, resources.key()
 
 
 class TestAudioTranscriptions:
     @pytest.mark.covers("llm.audio_transcriptions.openai.basic.nonstream.works")
     def test_audio_transcriptions_returns_text(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model, key = _register(endpoints_client, resources)
-        result = unwrap(
-            endpoints_client.transcribe(
-                key, model, filename=WEATHER_WAV.name, content=WEATHER_WAV.read_bytes()
-            )
+        model, key = _register(proxy, resources)
+        client = sdk.openai(key)
+
+        transcription = client.audio.transcriptions.create(
+            model=model, file=(WEATHER_WAV.name, WEATHER_WAV.read_bytes(), "audio/wav")
         )
-        text = result.text.strip()
+        text = transcription.text.strip()
         assert text, "/audio/transcriptions returned an empty transcript"
         assert "weather" in text.lower(), (
             f"transcript of a spoken weather question does not mention weather: {text!r}"
@@ -69,17 +73,17 @@ class TestAudioTranscriptions:
 
     @pytest.mark.covers("llm.audio_transcriptions.openai.input_validation.nonstream.works")
     def test_missing_file_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        model, key = _register(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.upload(
+        model, key = _register(proxy, resources)
+        result = proxy.transport.upload(
             "/v1/audio/transcriptions",
-            headers=endpoints_client.proxy.transport.bearer(key),
-            form=TranscriptionForm(model=model),
+            headers=proxy.transport.bearer(key),
+            form=_OptionalTranscriptionForm(model=model),
             filename="empty.wav",
             content=b"",
             file_content_type="audio/wav",
-            response_type=TranscriptionResult,
+            response_type=_TranscriptionResult,
         )
         match result:
             case UnknownApiError(status_code=400, body=body):
@@ -95,17 +99,17 @@ class TestAudioTranscriptions:
 
     @pytest.mark.covers("llm.audio_transcriptions.openai.input_validation.nonstream.works")
     def test_missing_model_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        _, key = _register(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.upload(
+        _, key = _register(proxy, resources)
+        result = proxy.transport.upload(
             "/v1/audio/transcriptions",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             form=_OptionalTranscriptionForm(),
             filename=WEATHER_WAV.name,
             content=WEATHER_WAV.read_bytes(),
             file_content_type="audio/wav",
-            response_type=TranscriptionResult,
+            response_type=_TranscriptionResult,
         )
         match result:
             case UnknownApiError(status_code=400, body=body):

tests/e2e/llm_translation/test_bedrock_web_search_server_tool_e2e.py

@@ -34,27 +34,22 @@ block alone does not activate it.
 from __future__ import annotations
 
 import pytest
-
+from anthropic.types import WebSearchTool20250305Param
 from e2e_config import unique_marker
-from e2e_http import unwrap
-from endpoints_client import EndpointsClient
 from lifecycle import ResourceManager
-from models import (
-    AnthropicMessagesBody,
-    AnthropicWebSearchTool,
-    ChatMessage,
-    LiteLLMParamsBody,
-)
+from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
 BEDROCK_INVOKE_BACKEND = "bedrock/invoke/us.anthropic.claude-haiku-4-5-20251001-v1:0"
 
-WEB_SEARCH_TOOL = AnthropicWebSearchTool(
-    type="web_search_20250305",
-    name="web_search",
-    max_uses=3,
-)
+WEB_SEARCH_TOOL: WebSearchTool20250305Param = {
+    "type": "web_search_20250305",
+    "name": "web_search",
+    "max_uses": 3,
+}
 
 SEARCH_PROMPT = "Use web search to tell me one recent news headline about Anthropic."
 
@@ -68,34 +63,30 @@ class TestBedrockWebSearchServerTool:
     )
     @pytest.mark.covers("llm.messages.bedrock_invoke.web_search_server_tool.nonstream.works")
     def test_web_search_server_tool_is_served(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
         """A bedrock deployment must answer a web_search server-tool request
         instead of handing the tool to AWS and returning its 400."""
         model = f"e2e-bedrock-websearch-{unique_marker()}"
-        model_id = endpoints_client.create_model(
+        model_id = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model=BEDROCK_INVOKE_BACKEND,
                 aws_region_name="us-east-1",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        resources.defer(lambda: proxy.delete_model(model_id))
+        client = sdk.anthropic(resources.key())
 
-        response = unwrap(
-            endpoints_client.proxy.messages(
-                key,
-                AnthropicMessagesBody(
-                    model=model,
-                    max_tokens=512,
-                    tools=[WEB_SEARCH_TOOL],
-                    messages=[ChatMessage(role="user", content=SEARCH_PROMPT)],
-                ),
-            )
+        response = client.messages.create(
+            model=model,
+            max_tokens=512,
+            tools=[WEB_SEARCH_TOOL],
+            messages=[{"role": "user", "content": SEARCH_PROMPT}],
+            extra_body=NO_PROXY_CACHE,
         )
 
-        assert response.content, f"no content blocks in response: {response}"
+        assert response.content, f"no content blocks in response: {response!r}"
         block_types = [block.type for block in response.content]
         assert "web_search_tool_result" in block_types, (
             "the answer carries no web_search_tool_result block, so the search "

tests/e2e/llm_translation/test_cache_control.py

@@ -24,7 +24,7 @@ service_tier lives in test_provider_features_e2e.py.
 
 The provider-native cache_control request shape is not expressible with the
 shared ``ChatBody`` (whose content is a plain string), so the cacheable body is
-built from the typed content blocks shared in ``endpoints_client.py``.
+built from the typed content blocks shared in ``models.py``.
 """
 
 from __future__ import annotations
@@ -38,9 +38,8 @@ from pydantic import BaseModel
 
 from e2e_config import unique_marker
 from e2e_http import Result, UnknownApiError, unwrap
-from endpoints_client import CacheControl, RichMessage, TextBlock
 from lifecycle import ResourceManager
-from models import ChatBody, ChatMessage, ChatResponse, LiteLLMParamsBody, Usage
+from models import CacheControl, ChatBody, ChatMessage, ChatResponse, LiteLLMParamsBody, RichMessage, TextBlock, Usage
 from passthrough_client import PassthroughClient
 import os
 

tests/e2e/llm_translation/test_completions_endpoint_e2e.py

@@ -3,19 +3,19 @@
 The legacy text-completion endpoint (prompt-style, non-chat) is the second-busiest
 route in production yet was previously uncovered; the rest of the "completions"
 surface is chat only. Registers an OpenAI instruct deployment at runtime (deleted
-on teardown), drives /v1/completions through the gateway, and asserts real
-generated text came back so a regression that empties the completion fails here.
+on teardown), drives /v1/completions through the gateway with the real OpenAI SDK
+(LIT-4577), and asserts real generated text came back so a regression that empties
+the completion fails here.
 """
 
 from __future__ import annotations
 
 import pytest
-
 from e2e_config import unique_marker
-from e2e_http import require_successful_call
-from endpoints_client import CompletionsResult, EndpointsClient
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -23,24 +23,25 @@ pytestmark = pytest.mark.e2e
 class TestCompletionsEndpoint:
     @pytest.mark.covers("llm.completions.openai.basic.nonstream.works")
     def test_text_completion_returns_text(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
         model = f"e2e-completions-{unique_marker()}"
-        model_id = endpoints_client.create_model(
+        model_id = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model="text-completion-openai/gpt-3.5-turbo-instruct",
                 api_key="os.environ/OPENAI_API_KEY",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        resources.defer(lambda: proxy.delete_model(model_id))
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.text_completions(
-            key, model, "Finish this sentence in a few words: the capital of France is"
+        completion = client.completions.create(
+            model=model,
+            prompt="Finish this sentence in a few words: the capital of France is",
+            max_tokens=32,
+            extra_body=NO_PROXY_CACHE,
         )
-        require_successful_call(result)
-        parsed = CompletionsResult.model_validate_json(result.body)
-        assert parsed.choices, f"/v1/completions returned no choices: {result.body[:300]}"
-        completion = (parsed.choices[0].text or "").strip()
-        assert completion, f"/v1/completions returned an empty completion: {result.body[:300]}"
+        assert completion.choices, f"/v1/completions returned no choices: {completion!r}"
+        text = (completion.choices[0].text or "").strip()
+        assert text, f"/v1/completions returned an empty completion: {completion!r}"

tests/e2e/llm_translation/test_credential_messages_e2e.py

@@ -7,43 +7,47 @@ import os
 import pytest
 
 from e2e_config import unique_marker
-from e2e_http import require_successful_call
-from endpoints_client import EndpointsClient, MessagesResult
 from lifecycle import ResourceManager
 from models import CredentialCreateBody, LiteLLMParamsBody
+from proxy_client import ProxyClient
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
 
 class TestCredentialBackedMessages:
     @pytest.mark.covers("mgmt.credential.new.serves_request")
-    def test_credential_backed_messages(self, endpoints_client: EndpointsClient, resources: ResourceManager) -> None:
+    def test_credential_backed_messages(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
         marker = unique_marker()
         credential_name = f"e2e-cred-{marker}"
         model = f"e2e-cred-messages-{marker}"
         anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
         assert anthropic_api_key, "ANTHROPIC_API_KEY must be set for this live e2e test"
 
-        endpoints_client.proxy.create_credential(
+        proxy.create_credential(
             CredentialCreateBody(
                 credential_name=credential_name,
                 credential_values={"api_key": anthropic_api_key},
             )
         )
-        resources.defer(lambda: endpoints_client.proxy.delete_credential(credential_name))
+        resources.defer(lambda: proxy.delete_credential(credential_name))
 
-        model_id = endpoints_client.create_model(
+        model_id = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model="anthropic/claude-haiku-4-5",
                 litellm_credential_name=credential_name,
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+        resources.defer(lambda: proxy.delete_model(model_id))
 
-        key = resources.key()
-        result = endpoints_client.messages(key, model, "reply with one word")
-        require_successful_call(result)
-        parsed = MessagesResult.model_validate_json(result.body)
-        assert parsed.role == "assistant", f"unexpected role: {result.body[:300]}"
-        assert parsed.text.strip(), f"/v1/messages returned no text: {result.body[:300]}"
+        client = sdk.anthropic(resources.key())
+        message = client.messages.create(
+            model=model,
+            max_tokens=64,
+            messages=[{"role": "user", "content": "reply with one word"}],
+            extra_body=NO_PROXY_CACHE,
+        )
+        assert message.role == "assistant", f"unexpected role: {message.role!r}"
+        text = "".join(block.text for block in message.content if block.type == "text")
+        assert text.strip(), f"/v1/messages returned no text: {message.content!r}"

tests/e2e/llm_translation/test_custom_pricing_e2e.py

@@ -25,7 +25,6 @@ from pydantic import BaseModel, RootModel
 from e2e_config import unique_marker
 from proxy_client import ProxyClient
 from e2e_http import Success, unwrap
-from endpoints_client import EndpointsClient
 from lifecycle import ResourceManager
 from models import (
     ChatBody,
@@ -71,7 +70,7 @@ def _approx_equal(actual: float, expected: float) -> bool:
 
 
 def _provision(
-    endpoints_client: EndpointsClient,
+    proxy: ProxyClient,
     resources: ResourceManager,
     prefix: str,
     *,
@@ -84,7 +83,7 @@ def _provision(
     marker keeps the name unique so concurrent runs on the shared proxy never
     collide."""
     model_name = f"{prefix}-{unique_marker()}"
-    model_id = endpoints_client.create_model(
+    model_id = proxy.create_model(
         model_name,
         LiteLLMParamsBody(
             model=BACKEND_MODEL,
@@ -93,15 +92,15 @@ def _provision(
             output_cost_per_token=output_cost_per_token,
         ),
     )
-    resources.defer(lambda: endpoints_client.delete_model(model_id))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model_name
 
 
 def _provision_custom_priced(
-    endpoints_client: EndpointsClient, resources: ResourceManager
+    proxy: ProxyClient, resources: ResourceManager
 ) -> str:
     return _provision(
-        endpoints_client,
+        proxy,
         resources,
         "custom-priced-flash",
         input_cost_per_token=CUSTOM_INPUT_RATE,
@@ -151,14 +150,14 @@ def _poll_breakdown_row(proxy: ProxyClient, key: str, response_id: str | None) -
 class TestCustomPricing:
     def test_custom_pricing_is_billed_at_configured_rate(
         self,
-        endpoints_client: EndpointsClient,
+        proxy: ProxyClient,
         resources: ResourceManager,
         scoped_key: str,
     ) -> None:
-        model = _provision_custom_priced(endpoints_client, resources)
+        model = _provision_custom_priced(proxy, resources)
 
         chat = unwrap(
-            endpoints_client.proxy.chat(
+            proxy.chat(
                 scoped_key,
                 ChatBody(
                     model=model,
@@ -172,7 +171,7 @@ class TestCustomPricing:
             )
         )
 
-        row = _poll_breakdown_row(endpoints_client.proxy, scoped_key, chat.id)
+        row = _poll_breakdown_row(proxy, scoped_key, chat.id)
         assert row.metadata and row.metadata.cost_breakdown  # guaranteed by the poll
         breakdown = row.metadata.cost_breakdown
 
@@ -195,10 +194,10 @@ class TestCustomPricing:
         )
 
     def test_model_info_reports_custom_pricing(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        model = _provision_custom_priced(endpoints_client, resources)
-        entry = _model_info_entry(endpoints_client.proxy.model_info(), model)
+        model = _provision_custom_priced(proxy, resources)
+        entry = _model_info_entry(proxy.model_info(), model)
 
         assert entry.litellm_params.input_cost_per_token == CUSTOM_INPUT_RATE, (
             f"/model/info litellm_params input rate "
@@ -210,20 +209,20 @@ class TestCustomPricing:
         )
 
     def test_custom_pricing_is_isolated_from_sibling_deployment(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
         # Register the override first so its rate is in the backend cost map before
         # the sibling resolves; a leak (LIT-3897) would then poison the sibling.
-        custom = _provision_custom_priced(endpoints_client, resources)
+        custom = _provision_custom_priced(proxy, resources)
         sibling = _provision(
-            endpoints_client,
+            proxy,
             resources,
             "base-flash",
             input_cost_per_token=None,
             output_cost_per_token=None,
         )
 
-        entries = {entry.model_name: entry for entry in endpoints_client.proxy.model_info()}
+        entries = {entry.model_name: entry for entry in proxy.model_info()}
         custom_entry = entries.get(custom)
         sibling_entry = entries.get(sibling)
         assert custom_entry is not None, f"{custom} absent from /model/info"

tests/e2e/llm_translation/test_embeddings_endpoint_e2e.py

@@ -1,23 +1,23 @@
 """Live e2e: POST /embeddings returns a real vector across OpenAI, Bedrock, Vertex, Cohere.
 
-Each test registers the deployment it needs at runtime (deleted on teardown) and
-asserts a non-empty, non-zero vector came back. The LIT-3167 guard in
-tests/e2e/embeddings/ covers the Gemini embedding path; embeddings cost tracking is
-covered by tests/e2e/quota_management/spend_tracking/.
+Each test registers the deployment it needs at runtime (deleted on teardown),
+drives the endpoint with the real OpenAI SDK (LIT-4577), and asserts a
+non-empty, non-zero vector came back. The LIT-3167 guard in
+tests/e2e/embeddings/ covers the Gemini embedding path; embeddings cost tracking
+is covered by tests/e2e/quota_management/spend_tracking/. Malformed bodies the
+SDK refuses to build stay on the shared transport.
 """
 
 from __future__ import annotations
 
 import pytest
 from e2e_config import provider_edge_base, unique_marker
-from e2e_http import (
-    assert_client_error,
-    require_successful_call,
-)
-from endpoints_client import EmbeddingsResult, EndpointsClient
+from e2e_http import assert_client_error
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
 from pydantic import BaseModel
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -39,35 +39,47 @@ def _openai_embeddings_params() -> LiteLLMParamsBody:
     )
 
 
+def _register(
+    proxy: ProxyClient, resources: ResourceManager, prefix: str, params: LiteLLMParamsBody
+) -> tuple[str, str]:
+    model = f"{prefix}-{unique_marker()}"
+    model_id = proxy.create_model(model, params)
+    resources.defer(lambda: proxy.delete_model(model_id))
+    return model, resources.key()
+
+
+def _assert_embedding_vector(
+    proxy: ProxyClient,
+    resources: ResourceManager,
+    sdk: SdkClients,
+    prefix: str,
+    params: LiteLLMParamsBody,
+) -> None:
+    model, key = _register(proxy, resources, prefix, params)
+    client = sdk.openai(key)
+
+    embeddings = client.embeddings.create(model=model, input="Say this is a test!", extra_body=NO_PROXY_CACHE)
+    assert embeddings.data, f"/embeddings returned no data: {embeddings!r}"
+    vector = embeddings.data[0].embedding
+    assert vector, f"/embeddings returned no vector: {embeddings!r}"
+    assert any(component != 0.0 for component in vector), "embedding vector is all zeros"
+
+
 class TestEmbeddingsEndpoint:
     @pytest.mark.replayable
     @pytest.mark.covers("llm.embeddings.openai.basic.nonstream.works")
-    def test_embeddings_returns_vector(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model = f"e2e-embeddings-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            _openai_embeddings_params(),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-
-        result = endpoints_client.embeddings(key, model, "Say this is a test!")
-        require_successful_call(result)
-        parsed = EmbeddingsResult.model_validate_json(result.body)
-        assert parsed.first_vector, f"/embeddings returned no vector: {result.body[:300]}"
-        assert any(component != 0.0 for component in parsed.first_vector), (
-            f"embedding vector is all zeros: {result.body[:300]}"
-        )
+    def test_embeddings_returns_vector(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        _assert_embedding_vector(proxy, resources, sdk, "e2e-embeddings", _openai_embeddings_params())
 
     @pytest.mark.covers("llm.embeddings.bedrock.basic.nonstream.works")
     def test_bedrock_embeddings_returns_vector(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-embeddings-bedrock-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
+        _assert_embedding_vector(
+            proxy,
+            resources,
+            sdk,
+            "e2e-embeddings-bedrock",
             LiteLLMParamsBody(
                 model="bedrock/amazon.titan-embed-text-v2:0",
                 aws_access_key_id="os.environ/AWS_ACCESS_KEY_ID",
@@ -75,110 +87,62 @@ class TestEmbeddingsEndpoint:
                 aws_region_name="os.environ/AWS_REGION",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-
-        result = endpoints_client.embeddings(key, model, "Say this is a test!")
-        require_successful_call(result)
-        parsed = EmbeddingsResult.model_validate_json(result.body)
-        assert parsed.first_vector, f"/embeddings returned no vector: {result.body[:300]}"
-        assert any(component != 0.0 for component in parsed.first_vector), (
-            f"embedding vector is all zeros: {result.body[:300]}"
-        )
 
     @pytest.mark.covers("llm.embeddings.cohere.basic.nonstream.works")
     def test_cohere_embeddings_returns_vector(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-embeddings-cohere-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
+        _assert_embedding_vector(
+            proxy,
+            resources,
+            sdk,
+            "e2e-embeddings-cohere",
             LiteLLMParamsBody(model="cohere/embed-v4.0", api_key="os.environ/COHERE_API_KEY"),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-
-        result = endpoints_client.embeddings(key, model, "Say this is a test!")
-        require_successful_call(result)
-        parsed = EmbeddingsResult.model_validate_json(result.body)
-        assert parsed.first_vector, f"/embeddings returned no vector: {result.body[:300]}"
-        assert any(component != 0.0 for component in parsed.first_vector), (
-            f"embedding vector is all zeros: {result.body[:300]}"
-        )
 
     @pytest.mark.covers("llm.embeddings.vertex.basic.nonstream.works")
     def test_vertex_embeddings_returns_vector(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-embeddings-vertex-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
+        _assert_embedding_vector(
+            proxy,
+            resources,
+            sdk,
+            "e2e-embeddings-vertex",
             LiteLLMParamsBody(
                 model="vertex_ai/text-embedding-005",
                 vertex_project="os.environ/VERTEXAI_PROJECT",
                 vertex_location="us-central1",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-
-        result = endpoints_client.embeddings(key, model, "Say this is a test!")
-        require_successful_call(result)
-        parsed = EmbeddingsResult.model_validate_json(result.body)
-        assert parsed.first_vector, f"/embeddings returned no vector: {result.body[:300]}"
-        assert any(component != 0.0 for component in parsed.first_vector), (
-            f"embedding vector is all zeros: {result.body[:300]}"
-        )
 
     @pytest.mark.replayable
     @pytest.mark.covers("llm.embeddings.openai.basic.nonstream.works")
-    def test_array_input_returns_vectors(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model = f"e2e-embeddings-array-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            _openai_embeddings_params(),
+    def test_array_input_returns_vectors(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model, key = _register(proxy, resources, "e2e-embeddings-array", _openai_embeddings_params())
+        embeddings = sdk.openai(key).embeddings.create(
+            model=model, input=["Hello", "World", "Test"], extra_body=NO_PROXY_CACHE
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-        result = endpoints_client.proxy.transport.send(
-            "/embeddings",
-            headers=endpoints_client.proxy.transport.bearer(key),
-            json=_OptionalEmbeddingsBody(model=model, input=["Hello", "World", "Test"]),
-        )
-        require_successful_call(result)
-        parsed = EmbeddingsResult.model_validate_json(result.body)
-        assert len(parsed.data) == 3, f"expected 3 vectors: {result.body[:300]}"
+        assert len(embeddings.data) == 3, f"expected 3 vectors: {embeddings!r}"
 
     @pytest.mark.replayable
     @pytest.mark.covers("llm.embeddings.openai.input_validation.nonstream.works")
-    def test_missing_model_returns_client_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
+    def test_missing_model_returns_client_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
         key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+        result = proxy.transport.send(
             "/embeddings",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalEmbeddingsBody(input="hello"),
         )
         assert_client_error(result, "embeddings missing model")
 
     @pytest.mark.replayable
     @pytest.mark.covers("llm.embeddings.openai.input_validation.nonstream.works")
-    def test_missing_input_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model = f"e2e-embeddings-missin-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            _openai_embeddings_params(),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+    def test_missing_input_returns_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register(proxy, resources, "e2e-embeddings-missin", _openai_embeddings_params())
+        result = proxy.transport.send(
             "/embeddings",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalEmbeddingsBody(model=model),
         )
         assert_client_error(result, "embeddings missing input")

tests/e2e/llm_translation/test_google_native_e2e.py

@@ -1,19 +1,41 @@
+"""Live e2e: the Gemini-native generateContent routes through the gateway.
+
+Google's own SDKs read these routes, and the streaming test asserts the exact SSE
+framing they expect (no doubled ``data:`` prefix, no bytes literal, no OpenAI
+``[DONE]`` sentinel), which an SDK would hide, so this passthrough surface stays on
+the shared transport.
+"""
+
 from __future__ import annotations
 
-import pytest
-from pydantic import BaseModel
+from typing import Literal
 
+import pytest
 from e2e_config import unique_marker
 from e2e_http import StreamingResponse, require_successful_call
-from endpoints_client import EndpointsClient
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from pydantic import BaseModel
 
 pytestmark = pytest.mark.e2e
 
 UPSTREAM_MODEL = "gemini/gemini-2.5-flash"
 
 
+class _GenerateContentPart(BaseModel):
+    text: str
+
+
+class _GenerateContentContent(BaseModel):
+    role: Literal["user"] = "user"
+    parts: tuple[_GenerateContentPart, ...]
+
+
+class _GenerateContentBody(BaseModel):
+    contents: tuple[_GenerateContentContent, ...]
+
+
 class _StreamPart(BaseModel):
     text: str | None = None
 
@@ -30,16 +52,27 @@ class _StreamEvent(BaseModel):
     candidates: tuple[_StreamCandidate, ...] = ()
 
 
-def _managed_deployment(client: EndpointsClient, resources: ResourceManager) -> str:
+def _managed_deployment(proxy: ProxyClient, resources: ResourceManager) -> str:
     model = f"e2e-google-native-{unique_marker()}"
-    model_id = client.create_model(
+    model_id = proxy.create_model(
         model,
         LiteLLMParamsBody(model=UPSTREAM_MODEL, api_key="os.environ/GEMINI_API_KEY"),
     )
-    resources.defer(lambda: client.delete_model(model_id))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model
 
 
+def _generate_content(proxy: ProxyClient, key: str, model: str, text: str, *, stream: bool = False) -> StreamingResponse:
+    operation = "streamGenerateContent" if stream else "generateContent"
+    body = _GenerateContentBody(contents=(_GenerateContentContent(parts=(_GenerateContentPart(text=text),)),))
+    return proxy.transport.send(
+        f"/v1beta/models/{model}:{operation}",
+        headers=proxy.transport.bearer(key),
+        json=body,
+        stream=stream,
+    )
+
+
 def _streamed_text(result: StreamingResponse) -> str:
     return "".join(
         part.text
@@ -54,15 +87,13 @@ class TestGoogleNativeGenerateContent:
     @pytest.mark.covers("llm.google_native.gemini.basic.nonstream.cost_logged")
     def test_generate_content_returns_response_cost_header(
         self,
-        endpoints_client: EndpointsClient,
+        proxy: ProxyClient,
         resources: ResourceManager,
         scoped_key: str,
     ) -> None:
-        model = _managed_deployment(endpoints_client, resources)
+        model = _managed_deployment(proxy, resources)
 
-        result = endpoints_client.generate_content(
-            scoped_key, model, f"Reply with the single word ok. {unique_marker()}"
-        )
+        result = _generate_content(proxy, scoped_key, model, f"Reply with the single word ok. {unique_marker()}")
 
         require_successful_call(result)
         assert result.call_id, "generateContent must stamp x-litellm-call-id"
@@ -75,13 +106,14 @@ class TestGoogleNativeGenerateContent:
     @pytest.mark.covers("llm.google_native.gemini.basic.stream.works")
     def test_stream_generate_content_frames_sse_the_way_google_sdks_expect(
         self,
-        endpoints_client: EndpointsClient,
+        proxy: ProxyClient,
         resources: ResourceManager,
         scoped_key: str,
     ) -> None:
-        model = _managed_deployment(endpoints_client, resources)
+        model = _managed_deployment(proxy, resources)
 
-        result = endpoints_client.generate_content(
+        result = _generate_content(
+            proxy,
             scoped_key,
             model,
             f"Count from one to five, one number per line. {unique_marker()}",

tests/e2e/llm_translation/test_image_edits_e2e.py

@@ -1,23 +1,24 @@
 """Live e2e: POST /v1/images/edits returns an edited image.
 
-Registers an OpenAI image model, then sends a small PNG plus an edit prompt as a
-multipart request to /v1/images/edits and asserts the response carries an image
-(url or base64). /images/edits is a distinct native route from
-/images/generations: it is multipart file upload with the image sent as the
-`image` part, not a JSON body. The fixture image is a small generated 64x64 PNG,
-so no external asset is needed.
+Registers an OpenAI image model, then sends a small PNG plus an edit prompt
+through the real OpenAI SDK (LIT-4577) to /v1/images/edits and asserts the
+response carries an image (url or base64). /images/edits is a distinct native
+route from /images/generations: it is multipart file upload with the image sent
+as the `image` part, not a JSON body. The fixture image is a small generated
+64x64 PNG, so no external asset is needed.
 """
 
 from __future__ import annotations
 
 import base64
 
+import openai
 import pytest
-from e2e_config import unique_marker
-from e2e_http import Result, UnknownApiError, unwrap
-from endpoints_client import EndpointsClient, ImageEditForm, ImagesResult
+from e2e_config import SLOW_PROVIDER_TIMEOUT_SECONDS, unique_marker
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from sdk_clients import SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -28,51 +29,54 @@ _TEST_PNG = base64.b64decode(
 )
 
 
-def _register_image_model(endpoints_client: EndpointsClient, resources: ResourceManager) -> tuple[str, str]:
+def _register_image_model(proxy: ProxyClient, resources: ResourceManager) -> tuple[str, str]:
     model = f"e2e-image-edit-{unique_marker()}"
-    model_id = endpoints_client.create_model(
+    model_id = proxy.create_model(
         model,
         LiteLLMParamsBody(model="openai/gpt-image-1", api_key="os.environ/OPENAI_API_KEY"),
     )
-    resources.defer(lambda: endpoints_client.delete_model(model_id))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model, resources.key()
 
 
-def _assert_client_error(result: Result[ImagesResult], context: str) -> None:
-    match result:
-        case UnknownApiError(status_code=status) if 400 <= status < 500:
-            return
-        case other:
-            pytest.fail(f"{context}: expected 4xx, got {other!r}")
+def _image_part(content: bytes) -> tuple[str, bytes, str]:
+    return ("image.png", content, "image/png")
+
+
+def _assert_client_error(error: openai.APIStatusError, context: str) -> None:
+    assert 400 <= error.status_code < 500, f"{context}: expected 4xx, got {error.status_code}: {error.message}"
 
 
 class TestImageEdit:
     @pytest.mark.covers("llm.images_edits.openai.basic.nonstream.works")
-    def test_image_edit_returns_image(self, endpoints_client: EndpointsClient, resources: ResourceManager) -> None:
-        model, key = _register_image_model(endpoints_client, resources)
+    def test_image_edit_returns_image(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model, key = _register_image_model(proxy, resources)
+        client = sdk.openai(key)
 
-        edited = unwrap(endpoints_client.image_edit(key, model, "Add a small red circle in the center", _TEST_PNG))
-        assert edited.data, f"/images/edits returned no data: {edited}"
-        first = edited.data[0]
-        assert first.b64_json or first.url, f"edited image has neither b64_json nor url: {first}"
-
-    @pytest.mark.covers("llm.images_edits.openai.input_validation.nonstream.works")
-    def test_empty_prompt_returns_error(self, endpoints_client: EndpointsClient, resources: ResourceManager) -> None:
-        model, key = _register_image_model(endpoints_client, resources)
-        result = endpoints_client.image_edit(key, model, "", _TEST_PNG)
-        _assert_client_error(result, "empty image-edit prompt")
-
-    @pytest.mark.covers("llm.images_edits.openai.input_validation.nonstream.works")
-    def test_empty_image_returns_error(self, endpoints_client: EndpointsClient, resources: ResourceManager) -> None:
-        model, key = _register_image_model(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.upload(
-            "/v1/images/edits",
-            headers=endpoints_client.proxy.transport.bearer(key),
-            form=ImageEditForm(model=model, prompt="add a red circle"),
-            filename="image.png",
-            content=b"",
-            file_content_type="image/png",
-            file_field="image",
-            response_type=ImagesResult,
+        edited = client.images.edit(
+            model=model,
+            image=_image_part(_TEST_PNG),
+            prompt="Add a small red circle in the center",
+            timeout=SLOW_PROVIDER_TIMEOUT_SECONDS,
         )
-        _assert_client_error(result, "empty image-edit file")
+        assert edited.data, f"/images/edits returned no data: {edited!r}"
+        first = edited.data[0]
+        assert first.b64_json or first.url, f"edited image has neither b64_json nor url: {first!r}"
+
+    @pytest.mark.covers("llm.images_edits.openai.input_validation.nonstream.works")
+    def test_empty_prompt_returns_error(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model, key = _register_image_model(proxy, resources)
+        client = sdk.openai(key)
+
+        with pytest.raises(openai.APIStatusError) as raised:
+            client.images.edit(model=model, image=_image_part(_TEST_PNG), prompt="")
+        _assert_client_error(raised.value, "empty image-edit prompt")
+
+    @pytest.mark.covers("llm.images_edits.openai.input_validation.nonstream.works")
+    def test_empty_image_returns_error(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model, key = _register_image_model(proxy, resources)
+        client = sdk.openai(key)
+
+        with pytest.raises(openai.APIStatusError) as raised:
+            client.images.edit(model=model, image=_image_part(b""), prompt="add a red circle")
+        _assert_client_error(raised.value, "empty image-edit file")

tests/e2e/llm_translation/test_image_generation_e2e.py

@@ -1,22 +1,22 @@
 """Live e2e: POST /v1/images/generations returns an image.
 
-Registers an OpenAI image deployment at runtime and asserts the response carries a
-generated image (url or base64). Migrated from
-litellm-regression-tests/tests/test_inference_endpoints.py.
+Registers an image deployment at runtime, drives it through the real OpenAI SDK
+(LIT-4577), and asserts the response carries a generated image (url or base64).
+Malformed bodies the SDK refuses to build stay on the shared transport. Migrated
+from litellm-regression-tests/tests/test_inference_endpoints.py.
 """
 
 from __future__ import annotations
 
 import pytest
 from e2e_config import unique_marker
-from e2e_http import (
-    assert_client_error,
-    require_successful_call,
-)
-from endpoints_client import EndpointsClient, ImagesResult
+from e2e_http import assert_client_error
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from openai.types import ImagesResponse
+from proxy_client import ProxyClient
 from pydantic import BaseModel
+from sdk_clients import SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -28,44 +28,46 @@ class _OptionalImageBody(BaseModel):
     size: str | None = None
 
 
-def _assert_image_returned(body: str) -> None:
-    parsed = ImagesResult.model_validate_json(body)
-    assert parsed.data, f"/images/generations returned no data: {body[:300]}"
-    first = parsed.data[0]
-    assert first.b64_json or first.url, (
-        f"generated image has neither b64_json nor url: {body[:300]}"
-    )
+def _assert_image_returned(images: ImagesResponse) -> None:
+    data = images.data or []
+    assert data, f"/images/generations returned no data: {images!r}"
+    first = data[0]
+    assert first.b64_json or first.url, f"generated image has neither b64_json nor url: {first!r}"
 
 
-def _register_openai_image(
-    endpoints_client: EndpointsClient, resources: ResourceManager
-) -> tuple[str, str]:
-    model = f"e2e-image-{unique_marker()}"
-    model_id = endpoints_client.create_model(
-        model,
+def _register(proxy: ProxyClient, resources: ResourceManager, prefix: str, params: LiteLLMParamsBody) -> tuple[str, str]:
+    model = f"{prefix}-{unique_marker()}"
+    model_id = proxy.create_model(model, params)
+    resources.defer(lambda: proxy.delete_model(model_id))
+    return model, resources.key()
+
+
+def _register_openai_image(proxy: ProxyClient, resources: ResourceManager) -> tuple[str, str]:
+    return _register(
+        proxy,
+        resources,
+        "e2e-image",
         LiteLLMParamsBody(model="openai/gpt-image-1-mini", api_key="os.environ/OPENAI_API_KEY"),
     )
-    resources.defer(lambda: endpoints_client.delete_model(model_id))
-    return model, resources.key()
 
 
 class TestImageGeneration:
     @pytest.mark.covers("llm.images_generations.openai.basic.nonstream.works")
     def test_image_generation_returns_image(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model, key = _register_openai_image(endpoints_client, resources)
-        result = endpoints_client.images(key, model, "Draw a cute cat")
-        require_successful_call(result)
-        _assert_image_returned(result.body)
+        model, key = _register_openai_image(proxy, resources)
+        images = sdk.openai(key).images.generate(model=model, prompt="Draw a cute cat", n=1, size="1024x1024")
+        _assert_image_returned(images)
 
     @pytest.mark.covers("llm.images_generations.bedrock.basic.nonstream.works", exercised_on=["images_generations"])
     def test_bedrock_image_generation_returns_image(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-bedrock-image-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
+        model, key = _register(
+            proxy,
+            resources,
+            "e2e-bedrock-image",
             LiteLLMParamsBody(
                 model="bedrock/amazon.nova-canvas-v1:0",
                 aws_access_key_id="os.environ/AWS_ACCESS_KEY_ID",
@@ -73,58 +75,46 @@ class TestImageGeneration:
                 aws_region_name="os.environ/AWS_REGION",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
-
-        result = endpoints_client.images(key, model, "Draw a cute cat")
-        require_successful_call(result)
-        _assert_image_returned(result.body)
+        images = sdk.openai(key).images.generate(model=model, prompt="Draw a cute cat", n=1, size="1024x1024")
+        _assert_image_returned(images)
 
     @pytest.mark.skip(reason="stage red: product gap, /v1/images/generations 500s (aimage_generation TypeError) on missing prompt instead of 400")
     @pytest.mark.covers("llm.images_generations.openai.input_validation.nonstream.works")
-    def test_missing_prompt_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = _register_openai_image(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_missing_prompt_returns_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register_openai_image(proxy, resources)
+        result = proxy.transport.send(
             "/v1/images/generations",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalImageBody(model=model),
         )
         assert_client_error(result, "images missing prompt")
 
     @pytest.mark.covers("llm.images_generations.openai.input_validation.nonstream.works")
-    def test_empty_prompt_returns_client_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = _register_openai_image(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_empty_prompt_returns_client_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register_openai_image(proxy, resources)
+        result = proxy.transport.send(
             "/v1/images/generations",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalImageBody(model=model, prompt=""),
         )
         assert_client_error(result, "images empty prompt")
 
     @pytest.mark.covers("llm.images_generations.openai.input_validation.nonstream.works")
-    def test_invalid_size_returns_client_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = _register_openai_image(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_invalid_size_returns_client_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register_openai_image(proxy, resources)
+        result = proxy.transport.send(
             "/v1/images/generations",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalImageBody(model=model, prompt="a blue square", size="999x999"),
         )
         assert_client_error(result, "images invalid size")
 
     @pytest.mark.covers("llm.images_generations.openai.input_validation.nonstream.works")
-    def test_invalid_n_returns_client_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = _register_openai_image(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_invalid_n_returns_client_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register_openai_image(proxy, resources)
+        result = proxy.transport.send(
             "/v1/images/generations",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalImageBody(model=model, prompt="a blue square", n=0),
         )
         assert_client_error(result, "images invalid n")

tests/e2e/llm_translation/test_messages_azure_foundry_e2e.py

@@ -1,9 +1,9 @@
 """Live e2e: POST /v1/messages routed to Azure AI Foundry Anthropic deployments.
 
 Registers `azure_ai/<claude>` deployments at runtime and drives the Messages
-endpoint through the gateway across the behaviors an Anthropic client relies on:
-a basic completion, a streamed completion, and tool use (non-streaming and
-streaming). Auth is the Azure API key (`x-api-key`); the deployment reads
+endpoint through the gateway with the real Anthropic SDK (LIT-4577) across the
+behaviors an Anthropic client relies on: a basic completion, a streamed
+completion, and tool use (non-streaming and streaming). The deployment reads
 `AZURE_AI_API_BASE` / `AZURE_AI_API_KEY` from the proxy env, so no secret is
 sent in the request.
 """
@@ -11,52 +11,39 @@ sent in the request.
 from __future__ import annotations
 
 import pytest
+from anthropic.types import RawMessageStreamEvent, ToolParam
+
 from e2e_config import unique_marker
-from e2e_http import StreamingResponse, require_successful_call, unwrap
-from endpoints_client import EndpointsClient
 from lifecycle import ResourceManager
-from models import (
-    AnthropicCustomTool,
-    AnthropicMessagesBody,
-    ChatMessage,
-    JsonSchemaProperty,
-    LiteLLMParamsBody,
-    ToolInputSchema,
-)
+from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
 AZURE_FOUNDRY_MODEL = "azure_ai/claude-haiku-4-5"
 
-WEATHER_TOOL = AnthropicCustomTool(
-    name="get_weather",
-    description="Get the current weather for a city.",
-    input_schema=ToolInputSchema(
-        properties={"city": JsonSchemaProperty(type="string")},
-        required=["city"],
-    ),
-)
+WEATHER_TOOL: ToolParam = {
+    "name": "get_weather",
+    "description": "Get the current weather for a city.",
+    "input_schema": {
+        "type": "object",
+        "properties": {"city": {"type": "string"}},
+        "required": ["city"],
+    },
+}
 
 
-def _assert_streamed_ok(result: StreamingResponse) -> None:
-    require_successful_call(result)
-    assert result.is_streaming, f"response was not streamed: {result.headers}"
-    assert not result.stream_error, f"stream errored: {result.stream_error}"
-    assert result.stream_events, "stream produced no SSE events"
-    assert any("content_block_delta" in event for event in result.stream_events), (
-        "stream carried no content deltas"
-    )
-    assert any("message_stop" in event for event in result.stream_events), (
-        "stream never reached message_stop"
-    )
+def _assert_streamed_ok(event_types: list[str]) -> None:
+    assert event_types, "stream produced no SSE events"
+    assert "content_block_delta" in event_types, "stream carried no content deltas"
+    assert "message_stop" in event_types, "stream never reached message_stop"
 
 
 class TestAzureFoundryMessages:
-    def _register(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> tuple[str, str]:
+    def _register(self, proxy: ProxyClient, resources: ResourceManager) -> str:
         model = f"e2e-azure-foundry-messages-{unique_marker()}"
-        model_id = endpoints_client.create_model(
+        model_id = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model=AZURE_FOUNDRY_MODEL,
@@ -64,91 +51,72 @@ class TestAzureFoundryMessages:
                 api_key="os.environ/AZURE_AI_API_KEY",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        return model, resources.key(models=[model])
+        resources.defer(lambda: proxy.delete_model(model_id))
+        return model
 
     @pytest.mark.covers("llm.messages.azure_foundry.basic.nonstream.works")
-    def test_basic_nonstream(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
-        response = unwrap(
-            endpoints_client.proxy.messages(
-                key,
-                AnthropicMessagesBody(
-                    model=model,
-                    max_tokens=64,
-                    messages=[ChatMessage(role="user", content="Reply with one word.")],
-                ),
-            )
+    def test_basic_nonstream(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model = self._register(proxy, resources)
+        client = sdk.anthropic(resources.key(models=[model]))
+
+        message = client.messages.create(
+            model=model,
+            max_tokens=64,
+            messages=[{"role": "user", "content": "Reply with one word."}],
+            extra_body=NO_PROXY_CACHE,
         )
-        assert response.content, f"no content blocks in response: {response}"
-        text = "".join(block.text or "" for block in response.content if block.type == "text")
-        assert text.strip(), f"/v1/messages returned no text: {response}"
+        assert message.content, f"no content blocks in response: {message!r}"
+        text = "".join(block.text for block in message.content if block.type == "text")
+        assert text.strip(), f"/v1/messages returned no text: {message.content!r}"
 
     @pytest.mark.covers("llm.messages.azure_foundry.basic.stream.works")
-    def test_basic_stream(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
-        result = endpoints_client.proxy.messages_stream(
-            key,
-            AnthropicMessagesBody(
-                model=model,
-                max_tokens=64,
-                stream=True,
-                messages=[ChatMessage(role="user", content="Count from one to three.")],
-            ),
+    def test_basic_stream(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model = self._register(proxy, resources)
+        client = sdk.anthropic(resources.key(models=[model]))
+
+        stream = client.messages.create(
+            model=model,
+            max_tokens=64,
+            stream=True,
+            messages=[{"role": "user", "content": "Count from one to three."}],
+            extra_body=NO_PROXY_CACHE,
         )
-        _assert_streamed_ok(result)
+        _assert_streamed_ok([event.type for event in stream])
 
     @pytest.mark.covers("llm.messages.azure_foundry.tool_use.nonstream.works")
-    def test_tool_use_nonstream(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
-        response = unwrap(
-            endpoints_client.proxy.messages(
-                key,
-                AnthropicMessagesBody(
-                    model=model,
-                    max_tokens=256,
-                    tools=[WEATHER_TOOL],
-                    messages=[
-                        ChatMessage(role="user", content="What is the weather in Paris? Use the tool.")
-                    ],
-                ),
-            )
+    def test_tool_use_nonstream(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model = self._register(proxy, resources)
+        client = sdk.anthropic(resources.key(models=[model]))
+
+        message = client.messages.create(
+            model=model,
+            max_tokens=256,
+            tools=[WEATHER_TOOL],
+            messages=[{"role": "user", "content": "What is the weather in Paris? Use the tool."}],
+            extra_body=NO_PROXY_CACHE,
         )
-        assert response.content, f"no content blocks in response: {response}"
-        assert any(block.type == "tool_use" for block in response.content), (
-            f"model did not call the tool: {response}"
+        assert message.content, f"no content blocks in response: {message!r}"
+        assert any(block.type == "tool_use" for block in message.content), (
+            f"model did not call the tool: {message.content!r}"
         )
 
     @pytest.mark.covers("llm.messages.azure_foundry.tool_use.stream.works")
-    def test_tool_use_stream(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
-        result = endpoints_client.proxy.messages_stream(
-            key,
-            AnthropicMessagesBody(
-                model=model,
-                max_tokens=256,
-                stream=True,
-                tools=[WEATHER_TOOL],
-                messages=[
-                    ChatMessage(role="user", content="What is the weather in Paris? Use the tool.")
-                ],
-            ),
-        )
-        require_successful_call(result)
-        assert result.is_streaming, f"response was not streamed: {result.headers}"
-        assert not result.stream_error, f"stream errored: {result.stream_error}"
-        assert result.stream_events, "stream produced no SSE events"
-        assert any("tool_use" in event for event in result.stream_events), (
-            "stream carried no tool_use block"
-        )
-        assert any("message_stop" in event for event in result.stream_events), (
-            "stream never reached message_stop"
+    def test_tool_use_stream(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model = self._register(proxy, resources)
+        client = sdk.anthropic(resources.key(models=[model]))
+
+        stream = client.messages.create(
+            model=model,
+            max_tokens=256,
+            stream=True,
+            tools=[WEATHER_TOOL],
+            messages=[{"role": "user", "content": "What is the weather in Paris? Use the tool."}],
+            extra_body=NO_PROXY_CACHE,
         )
+        events: list[RawMessageStreamEvent] = list(stream)
+        event_types = [event.type for event in events]
+        assert event_types, "stream produced no SSE events"
+        assert any(
+            event.type == "content_block_start" and event.content_block.type == "tool_use" for event in events
+        ), "stream carried no tool_use block"
+        assert "message_stop" in event_types, "stream never reached message_stop"

tests/e2e/llm_translation/test_messages_e2e.py

@@ -1,40 +1,42 @@
 """Live e2e: POST /v1/messages (Anthropic Messages API) returns a real completion.
 
 Registers an Anthropic deployment at runtime, drives the Messages endpoint through
-the gateway, and asserts an assistant message with text came back, both
-non-streaming and streamed. Migrated from
+the gateway with the real Anthropic SDK, the client customers actually use
+(LIT-4577), and asserts an assistant message with text came back, both
+non-streaming and streamed. Malformed bodies the SDK refuses to build stay on the
+shared transport. Migrated from
 litellm-regression-tests/tests/test_inference_endpoints.py.
 """
 
 from __future__ import annotations
 
+import time
 from typing import Final
 
 import pytest
-from e2e_config import (
-    STREAM_MIN_LEAD_SECONDS,
-    provider_edge_base,
-    provider_paces_stream,
-    unique_marker,
+from anthropic import Anthropic
+from anthropic.types import (
+    InputJSONDelta,
+    Message,
+    MessageParam,
+    RawContentBlockDeltaEvent,
+    RawContentBlockStartEvent,
+    RawContentBlockStopEvent,
+    RawMessageDeltaEvent,
+    RawMessageStreamEvent,
+    TextBlock,
+    TextDelta,
+    ToolChoiceParam,
+    ToolParam,
+    ToolUseBlock,
 )
-from e2e_http import assert_client_error, require_successful_call, unwrap
-from endpoints_client import EndpointsClient, MessagesResult
+from e2e_config import STREAM_MIN_LEAD_SECONDS, provider_edge_base, provider_paces_stream, unique_marker
+from e2e_http import assert_client_error
 from lifecycle import ResourceManager
-from models import (
-    AnthropicAssistantTurn,
-    AnthropicContentBlock,
-    AnthropicCustomTool,
-    AnthropicMessagesBody,
-    AnthropicToolChoice,
-    AnthropicToolResultBlock,
-    AnthropicToolResultTurn,
-    ChatMessage,
-    JsonSchemaProperty,
-    LiteLLMParamsBody,
-    SpendLogRow,
-    ToolInputSchema,
-)
+from models import ChatMessage, LiteLLMParamsBody, SpendLogRow
+from proxy_client import ProxyClient
 from pydantic import BaseModel, ConfigDict
+from sdk_clients import NO_PROXY_CACHE, SdkClients, response_header
 
 pytestmark = [pytest.mark.e2e, pytest.mark.replayable]
 
@@ -45,35 +47,17 @@ class _OptionalMessagesBody(BaseModel):
     max_tokens: int | None = None
 
 
-class _MessagesEventDelta(BaseModel):
-    text: str = ""
-
-
-class _MessagesEventUsage(BaseModel):
-    output_tokens: int | None = None
-
-
-class _MessagesStreamEvent(BaseModel):
-    """One Anthropic SSE event, keeping only what the stream's shape is asserted on.
-
-    ``delta.text`` is populated on ``content_block_delta`` and absent on the
-    ``message_delta`` that closes the turn, which is the event carrying ``usage``."""
-
-    type: str
-    delta: _MessagesEventDelta | None = None
-    usage: _MessagesEventUsage | None = None
-
-
 ANTHROPIC_BACKEND = "anthropic/claude-haiku-4-5"
 
-WEATHER_TOOL = AnthropicCustomTool(
-    name="get_weather",
-    description="Get the current weather for a city.",
-    input_schema=ToolInputSchema(
-        properties={"city": JsonSchemaProperty(type="string")},
-        required=["city"],
-    ),
-)
+WEATHER_TOOL: ToolParam = {
+    "name": "get_weather",
+    "description": "Get the current weather for a city.",
+    "input_schema": {
+        "type": "object",
+        "properties": {"city": {"type": "string"}},
+        "required": ["city"],
+    },
+}
 
 
 def _approx_equal(actual: float, expected: float) -> bool:
@@ -87,60 +71,67 @@ def _anthropic_params() -> LiteLLMParamsBody:
     handler appends ``/v1/messages`` to ``api_base`` itself, where the OpenAI handler
     appends only ``/chat/completions``."""
     base = provider_edge_base("anthropic")
-    return LiteLLMParamsBody(
-        model=ANTHROPIC_BACKEND, api_key="os.environ/ANTHROPIC_API_KEY", api_base=base
-    )
+    return LiteLLMParamsBody(model=ANTHROPIC_BACKEND, api_key="os.environ/ANTHROPIC_API_KEY", api_base=base)
+
+
+def _register(
+    proxy: ProxyClient,
+    resources: ResourceManager,
+    params: LiteLLMParamsBody | None = None,
+    prefix: str = "e2e-messages",
+) -> tuple[str, str]:
+    model = f"{prefix}-{unique_marker()}"
+    model_id = proxy.create_model(model, _anthropic_params() if params is None else params)
+    resources.defer(lambda: proxy.delete_model(model_id))
+    return model, resources.key()
+
+
+def _text(message: Message) -> str:
+    return "".join(block.text for block in message.content if isinstance(block, TextBlock))
+
+
+def _user_turn(text: str) -> MessageParam:
+    return {"role": "user", "content": text}
 
 
 class TestAnthropicMessages:
-    def _register(
-        self,
-        endpoints_client: EndpointsClient,
-        resources: ResourceManager,
-        params: LiteLLMParamsBody | None = None,
-    ) -> tuple[str, str]:
-        model = f"e2e-messages-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model, _anthropic_params() if params is None else params
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        return model, resources.key()
-
     @pytest.mark.covers("llm.messages.anthropic.basic.nonstream.works")
-    def test_messages_returns_completion(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
+    def test_messages_returns_completion(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model, key = _register(proxy, resources)
+        client = sdk.anthropic(key)
 
-        result = endpoints_client.messages(key, model, "reply with one word")
-        require_successful_call(result)
-        parsed = MessagesResult.model_validate_json(result.body)
-        assert parsed.role == "assistant", f"unexpected role: {result.body[:300]}"
-        assert parsed.text.strip(), f"/v1/messages returned no text: {result.body[:300]}"
+        message = client.messages.create(
+            model=model, max_tokens=64, messages=[_user_turn("reply with one word")], extra_body=NO_PROXY_CACHE
+        )
+        assert message.role == "assistant", f"unexpected role: {message.role!r}"
+        assert _text(message).strip(), f"/v1/messages returned no text: {message.content!r}"
 
     @pytest.mark.covers("llm.messages.anthropic.basic.nonstream.cost_logged")
     def test_messages_logs_cost_matching_the_response_header(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-messages-cost-{unique_marker()}"
-        model_id = endpoints_client.create_model(model, _anthropic_params())
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model, key = _register(proxy, resources, prefix="e2e-messages-cost")
+        client = sdk.anthropic(key)
 
-        result = endpoints_client.messages(key, model, f"reply with one word {unique_marker()}")
-        require_successful_call(result)
-        parsed = MessagesResult.model_validate_json(result.body)
-        assert parsed.role == "assistant" and parsed.text.strip(), (
-            f"/v1/messages returned no assistant text: {result.body[:300]}"
+        raw = client.messages.with_raw_response.create(
+            model=model,
+            max_tokens=64,
+            messages=[_user_turn(f"reply with one word {unique_marker()}")],
+            extra_body=NO_PROXY_CACHE,
+        )
+        message = raw.parse()
+        assert message.role == "assistant" and _text(message).strip(), (
+            f"/v1/messages returned no assistant text: {message.content!r}"
         )
 
         # The customer reads per-request cost off the response header (LIT-4076), so
         # it must be present and positive on /v1/messages, not only /chat/completions.
-        header_cost = result.response_cost
-        assert header_cost is not None and header_cost > 0, (
-            "x-litellm-response-cost header missing or non-positive on /v1/messages; "
-            f"headers={result.headers}"
+        raw_header_cost = response_header(raw.headers, "x-litellm-response-cost")
+        assert raw_header_cost is not None, (
+            f"x-litellm-response-cost header missing on /v1/messages; headers={dict(raw.headers)}"
         )
+        header_cost = float(raw_header_cost)
+        assert header_cost > 0, f"x-litellm-response-cost header non-positive on /v1/messages: {header_cost}"
 
         # Correlate the spend row by the unique scoped key, not the Anthropic response
         # id: on /v1/messages the spend-log request_id is the proxy's own call id, which
@@ -150,11 +141,9 @@ class TestAnthropicMessages:
         def _priced(rows: list[SpendLogRow]) -> bool:
             return any(r.spend is not None and r.spend > 0 for r in rows)
 
-        rows = endpoints_client.proxy.poll_logs_for_key(key, predicate=_priced)
+        rows = proxy.poll_logs_for_key(key, predicate=_priced)
         priced = [r for r in rows if r.spend is not None and r.spend > 0]
-        assert priced, (
-            f"no priced /spend/logs row landed for key {key} within the poll window; got {rows}"
-        )
+        assert priced, f"no priced /spend/logs row landed for key {key} within the poll window; got {rows}"
         row = priced[0]
         assert (row.prompt_tokens or 0) > 0 and (row.completion_tokens or 0) > 0, (
             f"messages spend row missing token counts, so the cost is not real usage: {row}"
@@ -166,9 +155,7 @@ class TestAnthropicMessages:
 
     @pytest.mark.covers("llm.messages.anthropic.basic.stream.works")
     @pytest.mark.provider_live
-    def test_messages_streams_completion(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
+    def test_messages_streams_completion(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
         """Edge-wired like its non-streaming siblings, so record and replay both
         carry the streamed response.
 
@@ -178,51 +165,45 @@ class TestAnthropicMessages:
         the first content delta must instead reach the client well before
         ``message_stop``, which a buffered response cannot do. Replay serves chunks back
         to back, so only live and record runs judge the timing."""
-        model, key = self._register(endpoints_client, resources)
+        model, key = _register(proxy, resources)
+        client = sdk.anthropic(key)
 
-        result = endpoints_client.proxy.messages_stream(
-            key,
-            AnthropicMessagesBody(
-                model=model,
-                max_tokens=800,
-                stream=True,
-                messages=[ChatMessage(role="user", content="Count from 1 to 200, one number per line.")],
-            ),
+        started: Final = time.monotonic()
+        stream = client.messages.create(
+            model=model,
+            max_tokens=800,
+            stream=True,
+            messages=[_user_turn("Count from 1 to 200, one number per line.")],
+            extra_body=NO_PROXY_CACHE,
         )
-        require_successful_call(result)
-        assert result.is_streaming, f"response was not streamed: {result.headers}"
-        assert not result.stream_error, f"stream errored: {result.stream_error}"
-        assert result.stream_events, "stream produced no SSE events"
+        arrivals: Final = tuple((event, time.monotonic() - started) for event in stream)
+        assert arrivals, "stream produced no SSE events"
 
-        events = [
-            _MessagesStreamEvent.model_validate_json(event) for event in result.stream_events
-        ]
-        types = [event.type for event in events]
-        delta_positions = [
+        events: Final = tuple(event for event, _ in arrivals)
+        types: Final = tuple(event.type for event in events)
+        delta_positions: Final = tuple(
             index for index, event in enumerate(events) if event.type == "content_block_delta"
-        ]
+        )
         assert delta_positions, f"stream carried no content deltas: {types}"
-        text = "".join(
+        text: Final = "".join(
             event.delta.text
             for event in events
-            if event.type == "content_block_delta" and event.delta is not None
+            if isinstance(event, RawContentBlockDeltaEvent) and isinstance(event.delta, TextDelta)
         )
-        assert text.strip(), f"content deltas assembled to no text: {result.stream_events[:5]}"
+        assert text.strip(), f"content deltas assembled to no text: {events[:5]}"
 
-        usage_positions = [
-            index
-            for index, event in enumerate(events)
-            if event.type == "message_delta" and event.usage is not None
-        ]
+        usage_positions: Final = tuple(
+            index for index, event in enumerate(events) if isinstance(event, RawMessageDeltaEvent)
+        )
         assert usage_positions, f"stream never reported usage: {types}"
         assert "message_stop" in types, f"stream never reached message_stop: {types}"
-        stop_position = types.index("message_stop")
+        stop_position: Final = types.index("message_stop")
         assert delta_positions[-1] < usage_positions[0] < stop_position, (
             f"usage did not land between the last content delta and message_stop: {types}"
         )
 
-        first_delta_at: Final = result.stream_event_arrivals[delta_positions[0]]
-        stop_at: Final = result.stream_event_arrivals[stop_position]
+        first_delta_at: Final = arrivals[delta_positions[0]][1]
+        stop_at: Final = arrivals[stop_position][1]
         if provider_paces_stream():
             assert stop_at - first_delta_at >= STREAM_MIN_LEAD_SECONDS, (
                 f"first content delta reached the client {first_delta_at:.2f}s after the request "
@@ -231,142 +212,125 @@ class TestAnthropicMessages:
             )
 
     @pytest.mark.covers("llm.messages.anthropic.tool_use.nonstream.works")
-    def test_messages_tool_use(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
+    def test_messages_tool_use(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model, key = _register(proxy, resources)
+        client = sdk.anthropic(key)
 
-        response = unwrap(
-            endpoints_client.proxy.messages(
-                key,
-                AnthropicMessagesBody(
-                    model=model,
-                    max_tokens=256,
-                    tools=[WEATHER_TOOL],
-                    messages=[
-                        ChatMessage(role="user", content="What is the weather in Paris? Use the tool.")
-                    ],
-                ),
-            )
+        message = client.messages.create(
+            model=model,
+            max_tokens=256,
+            tools=[WEATHER_TOOL],
+            messages=[_user_turn("What is the weather in Paris? Use the tool.")],
+            extra_body=NO_PROXY_CACHE,
         )
-        assert response.content, f"no content blocks in response: {response}"
-        assert any(block.type == "tool_use" for block in response.content), (
-            f"model did not call the tool: {response}"
+        assert message.content, f"no content blocks in response: {message!r}"
+        assert any(isinstance(block, ToolUseBlock) for block in message.content), (
+            f"model did not call the tool: {message.content!r}"
         )
 
-    @pytest.mark.skip(reason="stage red: product gap, /v1/messages 500s (anthropic_messages TypeError) on missing messages instead of 400")
+    @pytest.mark.skip(
+        reason="stage red: product gap, /v1/messages 500s (anthropic_messages TypeError) on missing messages instead of 400"
+    )
     @pytest.mark.covers("llm.messages.anthropic.input_validation.nonstream.works")
-    def test_missing_messages_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_missing_messages_returns_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register(proxy, resources)
+        result = proxy.transport.send(
             "/v1/messages",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalMessagesBody(model=model, max_tokens=50),
         )
         assert_client_error(result, "messages missing messages")
 
-    @pytest.mark.skip(reason="stage red: product gap, /v1/messages 500s (anthropic_messages TypeError) on missing max_tokens instead of 400")
+    @pytest.mark.skip(
+        reason="stage red: product gap, /v1/messages 500s (anthropic_messages TypeError) on missing max_tokens instead of 400"
+    )
     @pytest.mark.covers("llm.messages.anthropic.input_validation.nonstream.works")
-    def test_missing_max_tokens_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model, key = self._register(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_missing_max_tokens_returns_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model, key = _register(proxy, resources)
+        result = proxy.transport.send(
             "/v1/messages",
-            headers=endpoints_client.proxy.transport.bearer(key),
-            json=_OptionalMessagesBody(
-                model=model, messages=[ChatMessage(role="user", content="hi")]
-            ),
+            headers=proxy.transport.bearer(key),
+            json=_OptionalMessagesBody(model=model, messages=[ChatMessage(role="user", content="hi")]),
         )
         assert_client_error(result, "messages missing max_tokens")
 
     @pytest.mark.covers("llm.messages.anthropic.input_validation.nonstream.works")
-    def test_missing_model_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        _, key = self._register(endpoints_client, resources)
-        result = endpoints_client.proxy.transport.send(
+    def test_missing_model_returns_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        _, key = _register(proxy, resources)
+        result = proxy.transport.send(
             "/v1/messages",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalMessagesBody(messages=[ChatMessage(role="user", content="hi")], max_tokens=50),
         )
         assert_client_error(result, "messages missing model")
 
 
-class _BridgeDelta(BaseModel):
-    type: str | None = None
-    partial_json: str | None = None
-    stop_reason: str | None = None
-
-
-class _BridgeEvent(BaseModel):
-    type: str
-    index: int | None = None
-    content_block: AnthropicContentBlock | None = None
-    delta: _BridgeDelta | None = None
-
-
 class _ParcelInput(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
     parcel: str
     shelf: int
 
 
-def _tool_from_stream(events: tuple[_BridgeEvent, ...]) -> AnthropicContentBlock:
+def _tool_from_stream(events: tuple[RawMessageStreamEvent, ...]) -> ToolUseBlock:
     starts: Final = tuple(
-        event
-        for event in events
-        if event.type == "content_block_start"
-        and event.content_block is not None
-        and event.content_block.type == "tool_use"
+        (index, event.index, event.content_block)
+        for index, event in enumerate(events)
+        if isinstance(event, RawContentBlockStartEvent) and isinstance(event.content_block, ToolUseBlock)
     )
     assert len(starts) == 1, "expected exactly one tool call"
-    start: Final = starts[0]
-    block: Final = start.content_block
-    assert block is not None and block.id and start.index is not None
+    start_position, block_index, block = starts[0]
+    assert block.id
     fragments: Final = tuple(
-        event
-        for event in events
-        if event.type == "content_block_delta" and event.delta is not None and event.delta.type == "input_json_delta"
+        (index, event.index, event.delta.partial_json)
+        for index, event in enumerate(events)
+        if isinstance(event, RawContentBlockDeltaEvent) and isinstance(event.delta, InputJSONDelta)
     )
     assert fragments, "tool stream contained no argument fragments"
-    assert all(event.index == start.index for event in fragments), "tool fragments changed index"
-    positions: Final = tuple(i for i, event in enumerate(events) if event in fragments)
+    assert all(fragment_block == block_index for _, fragment_block, _ in fragments), "tool fragments changed index"
+    positions: Final = tuple(index for index, _, _ in fragments)
     stops: Final = tuple(
-        i for i, event in enumerate(events) if event.type == "content_block_stop" and event.index == start.index
+        index
+        for index, event in enumerate(events)
+        if isinstance(event, RawContentBlockStopEvent) and event.index == block_index
     )
-    assert len(stops) == 1 and events.index(start) < positions[0] <= positions[-1] < stops[0]
-    assert tuple(
-        event.delta.stop_reason for event in events if event.type == "message_delta" and event.delta is not None
-    ) == ("tool_use",)
-    terminal_positions: Final = tuple(i for i, event in enumerate(events) if event.type == "message_delta")
+    assert len(stops) == 1 and start_position < positions[0] <= positions[-1] < stops[0]
+    terminal_positions: Final = tuple(
+        index for index, event in enumerate(events) if isinstance(event, RawMessageDeltaEvent)
+    )
+    stop_reasons: Final = tuple(event.delta.stop_reason for event in events if isinstance(event, RawMessageDeltaEvent))
+    assert stop_reasons == ("tool_use",)
     assert len(terminal_positions) == 1 and stops[0] < terminal_positions[0] < len(events) - 1
-    assert tuple(i for i, event in enumerate(events) if event.type == "message_stop") == (len(events) - 1,), (
+    assert tuple(index for index, event in enumerate(events) if event.type == "message_stop") == (len(events) - 1,), (
         "tool stream did not terminate exactly once"
     )
-    arguments: Final = _ParcelInput.model_validate_json(
-        "".join(event.delta.partial_json or "" for event in fragments if event.delta is not None)
-    )
-    return AnthropicContentBlock(type="tool_use", id=block.id, name=block.name, input=arguments.model_dump())
+    arguments: Final = _ParcelInput.model_validate_json("".join(partial for _, _, partial in fragments))
+    return ToolUseBlock(type="tool_use", id=block.id, name=block.name, input=arguments.model_dump())
 
 
-def _parcel_result(tool: AnthropicContentBlock, result: AnthropicToolResultBlock) -> AnthropicToolResultTurn:
-    assert tool.id and result.tool_use_id == tool.id, "tool result ID does not match the emitted call"
-    return AnthropicToolResultTurn(content=[result])
-
-
-def _request_tool(
-    client: EndpointsClient, key: str, request: AnthropicMessagesBody, stream: bool
-) -> AnthropicContentBlock:
+def _request_tool(client: Anthropic, model: str, question: MessageParam, tool: ToolParam, stream: bool) -> ToolUseBlock:
+    tool_choice: Final[ToolChoiceParam] = {"type": "tool", "name": tool["name"]}
     if stream:
-        response: Final = client.proxy.messages_stream(key, request)
-        require_successful_call(response)
-        assert response.is_streaming and not response.stream_error
-        return _tool_from_stream(tuple(_BridgeEvent.model_validate_json(event) for event in response.stream_events))
-    response_body: Final = unwrap(client.proxy.messages(key, request))
-    blocks: Final = tuple(block for block in response_body.content or () if block.type == "tool_use")
+        events: Final = tuple(
+            client.messages.create(
+                model=model,
+                max_tokens=2048,
+                messages=[question],
+                tools=[tool],
+                tool_choice=tool_choice,
+                stream=True,
+                extra_body=NO_PROXY_CACHE,
+            )
+        )
+        return _tool_from_stream(events)
+    message: Final = client.messages.create(
+        model=model,
+        max_tokens=2048,
+        messages=[question],
+        tools=[tool],
+        tool_choice=tool_choice,
+        extra_body=NO_PROXY_CACHE,
+    )
+    blocks: Final = tuple(block for block in message.content if isinstance(block, ToolUseBlock))
     assert len(blocks) == 1
     return blocks[0]
 
@@ -375,55 +339,49 @@ class TestOpenAIMessagesToolContinuation:
     @pytest.mark.provider_live
     @pytest.mark.parametrize("stream", [True, False], ids=["stream", "nonstream"])
     def test_required_tool_arguments_and_correlated_result(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager, stream: bool
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients, stream: bool
     ) -> None:
         model: Final = f"e2e-bridge-tool-{unique_marker()}"
         base: Final = provider_edge_base("openai")
-        model_id: Final = endpoints_client.create_model(
+        model_id: Final = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model="openai/gpt-5.6", api_key="os.environ/OPENAI_API_KEY", api_base=f"{base}/v1" if base else None
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key: Final = resources.key(models=[model])
-        tool: Final = AnthropicCustomTool(
-            name="locate_parcel",
-            description="Look up the receipt for a parcel on a shelf. Return the receipt verbatim.",
-            input_schema=ToolInputSchema(
-                properties={"parcel": JsonSchemaProperty(type="string"), "shelf": JsonSchemaProperty(type="integer")},
-                required=["parcel", "shelf"],
-            ),
+        resources.defer(lambda: proxy.delete_model(model_id))
+        client: Final = sdk.anthropic(resources.key(models=[model]))
+        tool: Final[ToolParam] = {
+            "name": "locate_parcel",
+            "description": "Look up the receipt for a parcel on a shelf. Return the receipt verbatim.",
+            "input_schema": {
+                "type": "object",
+                "properties": {"parcel": {"type": "string"}, "shelf": {"type": "integer"}},
+                "required": ["parcel", "shelf"],
+            },
+        }
+        question: Final = _user_turn(
+            "Call locate_parcel with parcel exactly amber-kite and shelf exactly 7. "
+            "After the tool result, reply with only the receipt returned by the tool."
         )
-        question: Final = ChatMessage(
-            role="user",
-            content="Call locate_parcel with parcel exactly amber-kite and shelf exactly 7. After the tool result, reply with only the receipt returned by the tool.",
-        )
-        request: Final = AnthropicMessagesBody(
-            model=model,
-            max_tokens=2048,
-            messages=[question],
-            tools=[tool],
-            tool_choice=AnthropicToolChoice(type="tool", name=tool.name),
-            stream=stream,
-        )
-        emitted: Final = _request_tool(endpoints_client, key, request, stream)
+        emitted: Final = _request_tool(client, model, question, tool, stream)
         assert emitted.id and emitted.name == "locate_parcel"
         assert emitted.input == {"parcel": "amber-kite", "shelf": 7}, "required tool arguments were lost or changed"
         receipt: Final = f"receipt-{unique_marker()}"
-        result_turn: Final = _parcel_result(emitted, AnthropicToolResultBlock(tool_use_id=emitted.id, content=receipt))
-        continuation: Final = unwrap(
-            endpoints_client.proxy.messages(
-                key,
-                AnthropicMessagesBody(
-                    model=model,
-                    max_tokens=2048,
-                    tools=[tool],
-                    tool_choice=AnthropicToolChoice(type="none"),
-                    messages=[question, AnthropicAssistantTurn(content=[emitted]), result_turn],
-                ),
-            )
+        continuation: Final = client.messages.create(
+            model=model,
+            max_tokens=2048,
+            tools=[tool],
+            tool_choice={"type": "none"},
+            messages=[
+                question,
+                {
+                    "role": "assistant",
+                    "content": [{"type": "tool_use", "id": emitted.id, "name": emitted.name, "input": emitted.input}],
+                },
+                {"role": "user", "content": [{"type": "tool_result", "tool_use_id": emitted.id, "content": receipt}]},
+            ],
+            extra_body=NO_PROXY_CACHE,
         )
-        answer: Final = "".join(block.text or "" for block in continuation.content or ())
-        assert answer.strip() == receipt, "continuation did not consume the correlated tool result"
-        assert all(block.type != "tool_use" for block in continuation.content or ())
+        assert _text(continuation).strip() == receipt, "continuation did not consume the correlated tool result"
+        assert all(not isinstance(block, ToolUseBlock) for block in continuation.content)

tests/e2e/llm_translation/test_messages_mid_conversation_system_e2e.py

@@ -17,27 +17,28 @@ entry whose prefix spans ``system`` plus message turns is invalidated when the
 reminder is hoisted (the ``system`` field mutates and a turn disappears from
 ``messages``), while an entry ending at the system block itself would survive
 the hoist and mask the regression.
+
+Calls go through the real Anthropic SDK (LIT-4577). The SDK's ``MessageParam``
+type only admits user/assistant roles, so the system reminder turn is cast to
+it; the SDK serializes the dict verbatim, which is exactly the wire shape under
+test.
 """
 
 from __future__ import annotations
 
 import time
+from collections.abc import Sequence
+from typing import cast
 
 import pytest
-from pydantic import BaseModel
-
+from anthropic import Anthropic
+from anthropic.types import Message, MessageParam, TextBlockParam
 from e2e_config import unique_marker
-from e2e_http import Result, unwrap
-from endpoints_client import (
-    CacheControl,
-    EndpointsClient,
-    MessagesResult,
-    RichMessage,
-    RichMessagesRequest,
-    TextBlock,
-)
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from pydantic import BaseModel
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -49,54 +50,54 @@ CACHE_PRIMING_INTERVAL_SECONDS = 3.0
 CACHE_WARM_CONSECUTIVE_READS = 3
 
 
-def _cacheable_system_block(marker: str) -> TextBlock:
+def _cacheable_system_block(marker: str) -> TextBlockParam:
     """A system prompt at roughly twice the 4096-token minimum cacheable size of
     Haiku 4.5 (the smallest model here), unique per run so no other run's cache
     entry can satisfy the read. The marker appears once instead of in every
     paragraph: repeating it swung the block's size by ~1800 tokens with the
     marker's own tokenization and left it under the minimum on ~15% of runs, so
     the system breakpoint went uncached and the priming loop never saw a read."""
-    text = f"Run {marker}.\n" + " ".join(
-        f"Reference paragraph {index}." for index in range(1500)
+    text = f"Run {marker}.\n" + " ".join(f"Reference paragraph {index}." for index in range(1500))
+    return {"type": "text", "text": text, "cache_control": {"type": "ephemeral"}}
+
+
+def _user_turn(text: str, *, cached: bool = False) -> MessageParam:
+    block: TextBlockParam = (
+        {"type": "text", "text": text, "cache_control": {"type": "ephemeral"}}
+        if cached
+        else {"type": "text", "text": text}
     )
-    return TextBlock(text=text, cache_control=CacheControl())
+    return {"role": "user", "content": [block]}
 
 
-def _user_turn(text: str, *, cached: bool = False) -> RichMessage:
-    block = TextBlock(text=text, cache_control=CacheControl() if cached else None)
-    return RichMessage(role="user", content=[block])
-
-
-def _system_reminder_turn() -> RichMessage:
-    return RichMessage(
-        role="system",
-        content=[
-            TextBlock(
-                text="<system-reminder>Answer with exactly one word.</system-reminder>"
-            )
-        ],
+def _system_reminder_turn() -> MessageParam:
+    return cast(
+        "MessageParam",
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": "<system-reminder>Answer with exactly one word.</system-reminder>"}],
+        },
     )
 
 
-def _post_messages(
-    client: EndpointsClient, key: str, body: RichMessagesRequest
-) -> Result[MessagesResult]:
-    return client.proxy.transport.post(
-        "/v1/messages",
-        headers=client.proxy.transport.bearer(key),
-        json=body,
-        response_type=MessagesResult,
+def _assistant_turn(text: str) -> MessageParam:
+    return {"role": "assistant", "content": [{"type": "text", "text": text}]}
+
+
+def _text(message: Message) -> str:
+    return "".join(block.text for block in message.content if block.type == "text")
+
+
+def _send(client: Anthropic, model: str, system_block: TextBlockParam, messages: Sequence[MessageParam]) -> Message:
+    return client.messages.create(
+        model=model, max_tokens=64, system=[system_block], messages=messages, extra_body=NO_PROXY_CACHE
     )
 
 
-def _register_invoke_deployment(
-    client: EndpointsClient, resources: ResourceManager, bedrock_model: str
-) -> str:
+def _register_invoke_deployment(proxy: ProxyClient, resources: ResourceManager, bedrock_model: str) -> str:
     model = f"e2e-midsys-{unique_marker()}"
-    model_id = client.create_model(
-        model, LiteLLMParamsBody(model=bedrock_model, aws_region_name=AWS_REGION)
-    )
-    resources.defer(lambda: client.delete_model(model_id))
+    model_id = proxy.create_model(model, LiteLLMParamsBody(model=bedrock_model, aws_region_name=AWS_REGION))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model
 
 
@@ -118,9 +119,7 @@ class PrimedCache(BaseModel):
         return self.prefix_read_tokens + self.first_turn_creation_tokens
 
 
-def _prime_prompt_cache(
-    client: EndpointsClient, key: str, model: str, system_block: TextBlock
-) -> PrimedCache:
+def _prime_prompt_cache(client: Anthropic, model: str, system_block: TextBlockParam) -> PrimedCache:
     """Send first-turn calls (fresh cache-marked user turn each attempt,
     identical system prefix) until one both reads the system prefix back from
     cache and writes its own user-turn chunk, then re-send that exact turn until
@@ -132,19 +131,17 @@ def _prime_prompt_cache(
     deadline = time.monotonic() + CACHE_PRIMING_DEADLINE_SECONDS
     while True:
         user_text = _first_turn_user_text(unique_marker())
-        body = RichMessagesRequest(
-            model=model,
-            system=[system_block],
-            messages=[_user_turn(user_text, cached=True)],
-        )
-        usage = unwrap(_post_messages(client, key, body)).usage
-        if usage.cache_read_input_tokens > 0 and usage.cache_creation_input_tokens > 0:
+        first_turn = (_user_turn(user_text, cached=True),)
+        usage = _send(client, model, system_block, first_turn).usage
+        read_tokens = usage.cache_read_input_tokens or 0
+        creation_tokens = usage.cache_creation_input_tokens or 0
+        if read_tokens > 0 and creation_tokens > 0:
             primed = PrimedCache(
                 first_user_text=user_text,
-                prefix_read_tokens=usage.cache_read_input_tokens,
-                first_turn_creation_tokens=usage.cache_creation_input_tokens,
+                prefix_read_tokens=read_tokens,
+                first_turn_creation_tokens=creation_tokens,
             )
-            if _first_turn_reads_back(client, key, body, primed.full_prefix_tokens, deadline):
+            if _first_turn_reads_back(client, model, system_block, first_turn, primed.full_prefix_tokens, deadline):
                 return primed
         if time.monotonic() >= deadline:
             pytest.fail(
@@ -155,15 +152,20 @@ def _prime_prompt_cache(
 
 
 def _reads_full_prefix(
-    client: EndpointsClient, key: str, body: RichMessagesRequest, full_prefix_tokens: int
+    client: Anthropic,
+    model: str,
+    system_block: TextBlockParam,
+    messages: Sequence[MessageParam],
+    full_prefix_tokens: int,
 ) -> bool:
-    return unwrap(_post_messages(client, key, body)).usage.cache_read_input_tokens >= full_prefix_tokens
+    return (_send(client, model, system_block, messages).usage.cache_read_input_tokens or 0) >= full_prefix_tokens
 
 
 def _first_turn_reads_back(
-    client: EndpointsClient,
-    key: str,
-    body: RichMessagesRequest,
+    client: Anthropic,
+    model: str,
+    system_block: TextBlockParam,
+    messages: Sequence[MessageParam],
     full_prefix_tokens: int,
     deadline: float,
 ) -> bool:
@@ -172,12 +174,24 @@ def _first_turn_reads_back(
     fresh entry can be missing from the region the next request lands on; each miss
     re-creates the entry there, so the streak converges as the regions warm up."""
     while time.monotonic() < deadline:
-        if all(_reads_full_prefix(client, key, body, full_prefix_tokens) for _ in range(CACHE_WARM_CONSECUTIVE_READS)):
+        if all(
+            _reads_full_prefix(client, model, system_block, messages, full_prefix_tokens)
+            for _ in range(CACHE_WARM_CONSECUTIVE_READS)
+        ):
             return True
         time.sleep(CACHE_PRIMING_INTERVAL_SECONDS)
     return False
 
 
+def _reminder_turn_messages(primed: PrimedCache) -> tuple[MessageParam, ...]:
+    return (
+        _user_turn(primed.first_user_text, cached=True),
+        _system_reminder_turn(),
+        _assistant_turn("OK."),
+        _user_turn("Reply with one word again.", cached=True),
+    )
+
+
 #: Kept in sync with the copy in test_messages_mid_conversation_system_native_providers_e2e.py;
 #: the e2e suites stay self-contained rather than importing across test modules.
 MID_CONVERSATION_CACHE_SKIP_REASON = (
@@ -195,32 +209,18 @@ class TestBedrockInvokeMidConversationSystem:
         exercised_on=[],
     )
     def test_flagged_model_keeps_prompt_cache_across_system_reminder(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = _register_invoke_deployment(
-            endpoints_client, resources, FLAGGED_INVOKE_MODEL
-        )
-        key = resources.key(models=[model])
+        model = _register_invoke_deployment(proxy, resources, FLAGGED_INVOKE_MODEL)
+        client = sdk.anthropic(resources.key(models=[model]))
         system_block = _cacheable_system_block(unique_marker())
 
-        primed = _prime_prompt_cache(endpoints_client, key, model, system_block)
+        primed = _prime_prompt_cache(client, model, system_block)
 
-        reminder_turn_body = RichMessagesRequest(
-            model=model,
-            system=[system_block],
-            messages=[
-                _user_turn(primed.first_user_text, cached=True),
-                _system_reminder_turn(),
-                RichMessage(role="assistant", content=[TextBlock(text="OK.")]),
-                _user_turn("Reply with one word again.", cached=True),
-            ],
-        )
-        second = unwrap(_post_messages(endpoints_client, key, reminder_turn_body))
+        second = _send(client, model, system_block, _reminder_turn_messages(primed))
 
-        assert second.text.strip(), (
-            f"{model}: reminder turn returned no completion text"
-        )
-        assert second.usage.cache_read_input_tokens >= primed.full_prefix_tokens, (
+        assert _text(second).strip(), f"{model}: reminder turn returned no completion text"
+        assert (second.usage.cache_read_input_tokens or 0) >= primed.full_prefix_tokens, (
             f"{model}: turn with a mid-conversation system reminder read "
             f"{second.usage.cache_read_input_tokens} cached tokens, expected at "
             f"least the {primed.full_prefix_tokens} cached on turn one "
@@ -235,37 +235,23 @@ class TestBedrockInvokeMidConversationSystem:
         exercised_on=[],
     )
     def test_unflagged_model_converts_system_reminder_and_succeeds(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = _register_invoke_deployment(
-            endpoints_client, resources, UNFLAGGED_INVOKE_MODEL
-        )
-        key = resources.key(models=[model])
+        model = _register_invoke_deployment(proxy, resources, UNFLAGGED_INVOKE_MODEL)
+        client = sdk.anthropic(resources.key(models=[model]))
         system_block = _cacheable_system_block(unique_marker())
 
-        primed = _prime_prompt_cache(endpoints_client, key, model, system_block)
+        primed = _prime_prompt_cache(client, model, system_block)
 
-        reminder_turn_body = RichMessagesRequest(
-            model=model,
-            system=[system_block],
-            messages=[
-                _user_turn(primed.first_user_text, cached=True),
-                _system_reminder_turn(),
-                RichMessage(role="assistant", content=[TextBlock(text="OK.")]),
-                _user_turn("Reply with one word again.", cached=True),
-            ],
-        )
-        second = unwrap(_post_messages(endpoints_client, key, reminder_turn_body))
+        second = _send(client, model, system_block, _reminder_turn_messages(primed))
 
-        assert second.role == "assistant", (
-            f"{model}: unexpected role {second.role!r}"
-        )
-        assert second.text.strip(), (
+        assert second.role == "assistant", f"{model}: unexpected role {second.role!r}"
+        assert _text(second).strip(), (
             f"{model}: conversation with a mid-conversation system reminder "
             f"returned no text; the reminder was forwarded in place to a model "
             f"that rejects role 'system' inside messages instead of being converted to a user turn"
         )
-        assert second.usage.cache_read_input_tokens >= primed.full_prefix_tokens, (
+        assert (second.usage.cache_read_input_tokens or 0) >= primed.full_prefix_tokens, (
             f"{model}: reminder turn read {second.usage.cache_read_input_tokens} "
             f"cached tokens, expected at least the {primed.full_prefix_tokens} "
             f"cached on turn one ({primed.prefix_read_tokens} system prefix + "

tests/e2e/llm_translation/test_messages_mid_conversation_system_native_providers_e2e.py

@@ -24,27 +24,28 @@ entry whose prefix spans ``system`` plus message turns is invalidated when the
 reminder is hoisted (the ``system`` field mutates and a turn disappears from
 ``messages``), while an entry ending at the system block itself would survive
 the hoist and mask the regression.
+
+Calls go through the real Anthropic SDK (LIT-4577). The SDK's ``MessageParam``
+type only admits user/assistant roles, so the system reminder turn is cast to
+it; the SDK serializes the dict verbatim, which is exactly the wire shape under
+test.
 """
 
 from __future__ import annotations
 
 import time
+from collections.abc import Sequence
+from typing import cast
 
 import pytest
-from pydantic import BaseModel
-
+from anthropic import Anthropic
+from anthropic.types import Message, MessageParam, TextBlockParam
 from e2e_config import unique_marker
-from e2e_http import Result, unwrap
-from endpoints_client import (
-    CacheControl,
-    EndpointsClient,
-    MessagesResult,
-    RichMessage,
-    RichMessagesRequest,
-    TextBlock,
-)
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
+from proxy_client import ProxyClient
+from pydantic import BaseModel
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -69,46 +70,54 @@ def _vertex_params(model: str, location: str) -> LiteLLMParamsBody:
     )
 
 
-def _cacheable_system_block(marker: str) -> TextBlock:
+def _cacheable_system_block(marker: str) -> TextBlockParam:
     """A system prompt at roughly twice the 4096-token minimum cacheable size of
     Haiku 4.5 (the smallest model here), unique per run so no other run's cache
     entry can satisfy the read. The marker appears once instead of in every
     paragraph: repeating it swung the block's size by ~1800 tokens with the
     marker's own tokenization and left it under the minimum on ~15% of runs, so
     the system breakpoint went uncached and the priming loop never saw a read."""
-    text = f"Run {marker}.\n" + " ".join(
-        f"Reference paragraph {index}." for index in range(1500)
+    text = f"Run {marker}.\n" + " ".join(f"Reference paragraph {index}." for index in range(1500))
+    return {"type": "text", "text": text, "cache_control": {"type": "ephemeral"}}
+
+
+def _user_turn(text: str, *, cached: bool = False) -> MessageParam:
+    block: TextBlockParam = (
+        {"type": "text", "text": text, "cache_control": {"type": "ephemeral"}}
+        if cached
+        else {"type": "text", "text": text}
     )
-    return TextBlock(text=text, cache_control=CacheControl())
+    return {"role": "user", "content": [block]}
 
 
-def _user_turn(text: str, *, cached: bool = False) -> RichMessage:
-    block = TextBlock(text=text, cache_control=CacheControl() if cached else None)
-    return RichMessage(role="user", content=[block])
-
-
-def _system_reminder_turn() -> RichMessage:
-    return RichMessage(
-        role="system",
-        content=[TextBlock(text="<system-reminder>Answer with exactly one word.</system-reminder>")],
+def _system_reminder_turn() -> MessageParam:
+    return cast(
+        "MessageParam",
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": "<system-reminder>Answer with exactly one word.</system-reminder>"}],
+        },
     )
 
 
-def _post_messages(client: EndpointsClient, key: str, body: RichMessagesRequest) -> Result[MessagesResult]:
-    return client.proxy.transport.post(
-        "/v1/messages",
-        headers=client.proxy.transport.bearer(key),
-        json=body,
-        response_type=MessagesResult,
+def _assistant_turn(text: str) -> MessageParam:
+    return {"role": "assistant", "content": [{"type": "text", "text": text}]}
+
+
+def _text(message: Message) -> str:
+    return "".join(block.text for block in message.content if block.type == "text")
+
+
+def _send(client: Anthropic, model: str, system_block: TextBlockParam, messages: Sequence[MessageParam]) -> Message:
+    return client.messages.create(
+        model=model, max_tokens=64, system=[system_block], messages=messages, extra_body=NO_PROXY_CACHE
     )
 
 
-def _register_deployment(
-    client: EndpointsClient, resources: ResourceManager, params: LiteLLMParamsBody
-) -> str:
+def _register_deployment(proxy: ProxyClient, resources: ResourceManager, params: LiteLLMParamsBody) -> str:
     model = f"e2e-midsys-{unique_marker()}"
-    model_id = client.create_model(model, params)
-    resources.defer(lambda: client.delete_model(model_id))
+    model_id = proxy.create_model(model, params)
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model
 
 
@@ -130,9 +139,7 @@ class PrimedCache(BaseModel):
         return self.prefix_read_tokens + self.first_turn_creation_tokens
 
 
-def _prime_prompt_cache(
-    client: EndpointsClient, key: str, model: str, system_block: TextBlock
-) -> PrimedCache:
+def _prime_prompt_cache(client: Anthropic, model: str, system_block: TextBlockParam) -> PrimedCache:
     """Send first-turn calls (fresh cache-marked user turn each attempt,
     identical system prefix) until one both reads the system prefix back from
     cache and writes its own user-turn chunk, then re-send that exact turn until
@@ -144,19 +151,17 @@ def _prime_prompt_cache(
     deadline = time.monotonic() + CACHE_PRIMING_DEADLINE_SECONDS
     while True:
         user_text = _first_turn_user_text(unique_marker())
-        body = RichMessagesRequest(
-            model=model,
-            system=[system_block],
-            messages=[_user_turn(user_text, cached=True)],
-        )
-        usage = unwrap(_post_messages(client, key, body)).usage
-        if usage.cache_read_input_tokens > 0 and usage.cache_creation_input_tokens > 0:
+        first_turn = (_user_turn(user_text, cached=True),)
+        usage = _send(client, model, system_block, first_turn).usage
+        read_tokens = usage.cache_read_input_tokens or 0
+        creation_tokens = usage.cache_creation_input_tokens or 0
+        if read_tokens > 0 and creation_tokens > 0:
             primed = PrimedCache(
                 first_user_text=user_text,
-                prefix_read_tokens=usage.cache_read_input_tokens,
-                first_turn_creation_tokens=usage.cache_creation_input_tokens,
+                prefix_read_tokens=read_tokens,
+                first_turn_creation_tokens=creation_tokens,
             )
-            if _first_turn_reads_back(client, key, body, primed.full_prefix_tokens, deadline):
+            if _first_turn_reads_back(client, model, system_block, first_turn, primed.full_prefix_tokens, deadline):
                 return primed
         if time.monotonic() >= deadline:
             pytest.fail(
@@ -167,15 +172,20 @@ def _prime_prompt_cache(
 
 
 def _reads_full_prefix(
-    client: EndpointsClient, key: str, body: RichMessagesRequest, full_prefix_tokens: int
+    client: Anthropic,
+    model: str,
+    system_block: TextBlockParam,
+    messages: Sequence[MessageParam],
+    full_prefix_tokens: int,
 ) -> bool:
-    return unwrap(_post_messages(client, key, body)).usage.cache_read_input_tokens >= full_prefix_tokens
+    return (_send(client, model, system_block, messages).usage.cache_read_input_tokens or 0) >= full_prefix_tokens
 
 
 def _first_turn_reads_back(
-    client: EndpointsClient,
-    key: str,
-    body: RichMessagesRequest,
+    client: Anthropic,
+    model: str,
+    system_block: TextBlockParam,
+    messages: Sequence[MessageParam],
     full_prefix_tokens: int,
     deadline: float,
 ) -> bool:
@@ -184,12 +194,24 @@ def _first_turn_reads_back(
     fresh entry can be missing from the region the next request lands on; each miss
     re-creates the entry there, so the streak converges as the regions warm up."""
     while time.monotonic() < deadline:
-        if all(_reads_full_prefix(client, key, body, full_prefix_tokens) for _ in range(CACHE_WARM_CONSECUTIVE_READS)):
+        if all(
+            _reads_full_prefix(client, model, system_block, messages, full_prefix_tokens)
+            for _ in range(CACHE_WARM_CONSECUTIVE_READS)
+        ):
             return True
         time.sleep(CACHE_PRIMING_INTERVAL_SECONDS)
     return False
 
 
+def _reminder_turn_messages(primed: PrimedCache) -> tuple[MessageParam, ...]:
+    return (
+        _user_turn(primed.first_user_text, cached=True),
+        _system_reminder_turn(),
+        _assistant_turn("OK."),
+        _user_turn("Reply with one word again.", cached=True),
+    )
+
+
 #: Why the flagged-model cache checks are skipped rather than failing. The
 #: assertions below are correct and must be restored unchanged when the bug is
 #: fixed; they are the regression guard for a real billing cost.
@@ -209,28 +231,18 @@ MID_CONVERSATION_CACHE_SKIP_REASON = (
 
 
 def _assert_flagged_model_keeps_cache(
-    client: EndpointsClient, resources: ResourceManager, params: LiteLLMParamsBody
+    proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients, params: LiteLLMParamsBody
 ) -> None:
-    model = _register_deployment(client, resources, params)
-    key = resources.key(models=[model])
+    model = _register_deployment(proxy, resources, params)
+    client = sdk.anthropic(resources.key(models=[model]))
     system_block = _cacheable_system_block(unique_marker())
 
-    primed = _prime_prompt_cache(client, key, model, system_block)
+    primed = _prime_prompt_cache(client, model, system_block)
 
-    reminder_turn_body = RichMessagesRequest(
-        model=model,
-        system=[system_block],
-        messages=[
-            _user_turn(primed.first_user_text, cached=True),
-            _system_reminder_turn(),
-            RichMessage(role="assistant", content=[TextBlock(text="OK.")]),
-            _user_turn("Reply with one word again.", cached=True),
-        ],
-    )
-    second = unwrap(_post_messages(client, key, reminder_turn_body))
+    second = _send(client, model, system_block, _reminder_turn_messages(primed))
 
-    assert second.text.strip(), f"{model}: reminder turn returned no completion text"
-    assert second.usage.cache_read_input_tokens >= primed.full_prefix_tokens, (
+    assert _text(second).strip(), f"{model}: reminder turn returned no completion text"
+    assert (second.usage.cache_read_input_tokens or 0) >= primed.full_prefix_tokens, (
         f"{model}: turn with a mid-conversation system reminder read "
         f"{second.usage.cache_read_input_tokens} cached tokens, expected at "
         f"least the {primed.full_prefix_tokens} cached on turn one "
@@ -242,33 +254,23 @@ def _assert_flagged_model_keeps_cache(
 
 
 def _assert_unflagged_model_converts_and_succeeds(
-    client: EndpointsClient, resources: ResourceManager, params: LiteLLMParamsBody
+    proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients, params: LiteLLMParamsBody
 ) -> None:
-    model = _register_deployment(client, resources, params)
-    key = resources.key(models=[model])
+    model = _register_deployment(proxy, resources, params)
+    client = sdk.anthropic(resources.key(models=[model]))
     system_block = _cacheable_system_block(unique_marker())
 
-    primed = _prime_prompt_cache(client, key, model, system_block)
+    primed = _prime_prompt_cache(client, model, system_block)
 
-    reminder_turn_body = RichMessagesRequest(
-        model=model,
-        system=[system_block],
-        messages=[
-            _user_turn(primed.first_user_text, cached=True),
-            _system_reminder_turn(),
-            RichMessage(role="assistant", content=[TextBlock(text="OK.")]),
-            _user_turn("Reply with one word again.", cached=True),
-        ],
-    )
-    second = unwrap(_post_messages(client, key, reminder_turn_body))
+    second = _send(client, model, system_block, _reminder_turn_messages(primed))
 
     assert second.role == "assistant", f"{model}: unexpected role {second.role!r}"
-    assert second.text.strip(), (
+    assert _text(second).strip(), (
         f"{model}: conversation with a mid-conversation system reminder returned "
         f"no text; the reminder was forwarded in place to a model that rejects "
         f"role 'system' inside messages instead of being converted to a user turn"
     )
-    assert second.usage.cache_read_input_tokens >= primed.full_prefix_tokens, (
+    assert (second.usage.cache_read_input_tokens or 0) >= primed.full_prefix_tokens, (
         f"{model}: reminder turn read {second.usage.cache_read_input_tokens} cached "
         f"tokens, expected at least the {primed.full_prefix_tokens} cached on turn "
         f"one ({primed.prefix_read_tokens} system prefix + "
@@ -289,20 +291,18 @@ class TestAzureFoundryMidConversationSystem:
         exercised_on=[],
     )
     def test_flagged_model_keeps_prompt_cache_across_system_reminder(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        _assert_flagged_model_keeps_cache(endpoints_client, resources, _azure_params(self.FLAGGED_MODEL))
+        _assert_flagged_model_keeps_cache(proxy, resources, sdk, _azure_params(self.FLAGGED_MODEL))
 
     @pytest.mark.covers(
         "llm.messages.azure_foundry.mid_conversation_system.nonstream.works",
         exercised_on=[],
     )
     def test_unflagged_model_converts_system_reminder_and_succeeds(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        _assert_unflagged_model_converts_and_succeeds(
-            endpoints_client, resources, _azure_params(self.UNFLAGGED_MODEL)
-        )
+        _assert_unflagged_model_converts_and_succeeds(proxy, resources, sdk, _azure_params(self.UNFLAGGED_MODEL))
 
 
 class TestVertexMidConversationSystem:
@@ -323,10 +323,10 @@ class TestVertexMidConversationSystem:
         exercised_on=[],
     )
     def test_flagged_model_keeps_prompt_cache_across_system_reminder(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
         _assert_flagged_model_keeps_cache(
-            endpoints_client, resources, _vertex_params(self.FLAGGED_MODEL, self.FLAGGED_LOCATION)
+            proxy, resources, sdk, _vertex_params(self.FLAGGED_MODEL, self.FLAGGED_LOCATION)
         )
 
     @pytest.mark.covers(
@@ -334,8 +334,8 @@ class TestVertexMidConversationSystem:
         exercised_on=[],
     )
     def test_unflagged_model_converts_system_reminder_and_succeeds(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
         _assert_unflagged_model_converts_and_succeeds(
-            endpoints_client, resources, _vertex_params(self.UNFLAGGED_MODEL, self.UNFLAGGED_LOCATION)
+            proxy, resources, sdk, _vertex_params(self.UNFLAGGED_MODEL, self.UNFLAGGED_LOCATION)
         )

tests/e2e/llm_translation/test_moderations_e2e.py

@@ -1,19 +1,23 @@
 """Live e2e: POST /v1/moderations classifies content against the provider policy.
 
-Registers OpenAI's omni moderation model at runtime and asserts the product
-promise on both sides of the decision: clearly violent text comes back flagged
-with at least one policy category tripped, and benign text comes back not flagged.
+Registers OpenAI's omni moderation model at runtime, drives it through the real
+OpenAI SDK (LIT-4577), and asserts the product promise on both sides of the
+decision: clearly violent text comes back flagged with at least one policy
+category tripped, and benign text comes back not flagged. The malformed-body
+negative stays on the shared transport, since the SDK refuses to send it.
 """
 
 from __future__ import annotations
 
 import pytest
 from e2e_config import unique_marker
-from e2e_http import assert_client_error, unwrap
-from endpoints_client import EndpointsClient
+from e2e_http import assert_client_error
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody
-from pydantic import BaseModel
+from openai.types import Moderation
+from proxy_client import ProxyClient
+from pydantic import BaseModel, TypeAdapter
+from sdk_clients import SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -26,59 +30,63 @@ class _OptionalModerationBody(BaseModel):
     input: str | None = None
 
 
-def _register_moderation_model(
-    endpoints_client: EndpointsClient, resources: ResourceManager
-) -> str:
+def _register_moderation_model(proxy: ProxyClient, resources: ResourceManager) -> str:
     model = f"e2e-moderation-{unique_marker()}"
-    model_id = endpoints_client.create_model(
+    model_id = proxy.create_model(
         model,
         LiteLLMParamsBody(
             model="openai/omni-moderation-latest", api_key="os.environ/OPENAI_API_KEY"
         ),
     )
-    resources.defer(lambda: endpoints_client.delete_model(model_id))
+    resources.defer(lambda: proxy.delete_model(model_id))
     return model
 
 
+_CATEGORY_FLAGS = TypeAdapter(dict[str, bool | None])
+
+
+def _flagged_categories(item: Moderation) -> tuple[str, ...]:
+    flags = _CATEGORY_FLAGS.validate_python(item.categories.model_dump())
+    return tuple(name for name, hit in flags.items() if hit)
+
+
 class TestModerations:
     @pytest.mark.covers("llm.moderations.openai.basic.nonstream.works")
     def test_moderations_flags_violent_content(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = _register_moderation_model(endpoints_client, resources)
-        key = resources.key()
+        model = _register_moderation_model(proxy, resources)
+        client = sdk.openai(resources.key())
 
-        result = unwrap(endpoints_client.moderations(key, model, VIOLENT_TEXT))
-        item = result.first
-        assert item is not None, f"/moderations returned no results: {result}"
-        assert item.flagged, f"violent text was not flagged: {item}"
-        assert item.flagged_categories, (
-            f"flagged result reported no true category: {item}"
-        )
+        moderation = client.moderations.create(model=model, input=VIOLENT_TEXT)
+        assert moderation.results, f"/moderations returned no results: {moderation!r}"
+        item = moderation.results[0]
+        assert item.flagged, f"violent text was not flagged: {item!r}"
+        assert _flagged_categories(item), f"flagged result reported no true category: {item!r}"
 
     def test_moderations_passes_benign_content(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = _register_moderation_model(endpoints_client, resources)
-        key = resources.key()
+        model = _register_moderation_model(proxy, resources)
+        client = sdk.openai(resources.key())
 
-        result = unwrap(endpoints_client.moderations(key, model, BENIGN_TEXT))
-        item = result.first
-        assert item is not None, f"/moderations returned no results: {result}"
+        moderation = client.moderations.create(model=model, input=BENIGN_TEXT)
+        assert moderation.results, f"/moderations returned no results: {moderation!r}"
+        item = moderation.results[0]
         assert not item.flagged, (
-            f"benign text was flagged as {item.flagged_categories}: {item}"
+            f"benign text was flagged as {_flagged_categories(item)}: {item!r}"
         )
 
     @pytest.mark.skip(reason="stage red: product gap, /v1/moderations 500s (KeyError 'input') on missing input instead of 400")
     @pytest.mark.covers("llm.moderations.openai.input_validation.nonstream.works")
     def test_missing_input_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
-        model = _register_moderation_model(endpoints_client, resources)
+        model = _register_moderation_model(proxy, resources)
         key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+        result = proxy.transport.send(
             "/v1/moderations",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalModerationBody(model=model),
         )
         assert_client_error(result, "moderations missing input")

tests/e2e/llm_translation/test_ocr_rust_e2e.py

@@ -21,9 +21,9 @@ from typing import Protocol
 import pytest
 from e2e_config import unique_marker
 from e2e_http import assert_client_error, unwrap
-from endpoints_client import EndpointsClient
 from lifecycle import ResourceManager
 from models import LiteLLMParamsBody, OcrBody, OcrDocument, OcrResponse
+from proxy_client import ProxyClient
 from pydantic import BaseModel
 
 pytestmark = pytest.mark.e2e
@@ -149,28 +149,28 @@ def _assert_ocr_document(response: OcrResponse) -> None:
 class TestRustOcrGateway:
     @pytest.mark.parametrize("case", RUST_OCR_CASES, ids=_CASE_IDS)
     def test_rust_ocr_response(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager, case: _OcrCase
+        self, proxy: ProxyClient, resources: ResourceManager, case: _OcrCase
     ) -> None:
         model = f"rust-ocr-{case.suffix}-{unique_marker()}"
-        model_id = endpoints_client.create_model(model, case.provider.litellm_params())
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+        model_id = proxy.create_model(model, case.provider.litellm_params())
+        resources.defer(lambda: proxy.delete_model(model_id))
         key = resources.key()
 
-        response = unwrap(endpoints_client.proxy.ocr(key, OcrBody(model=model, document=case.document)))
+        response = unwrap(proxy.ocr(key, OcrBody(model=model, document=case.document)))
         _assert_ocr_document(response)
 
     @pytest.mark.skip(reason="stage red: product gap, /v1/ocr 500s (aocr TypeError) on missing document instead of 400")
     @pytest.mark.covers("llm.ocr.openai.input_validation.nonstream.works")
     def test_missing_document_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
         model = f"rust-ocr-val-{unique_marker()}"
-        model_id = endpoints_client.create_model(model, MistralOcr().litellm_params())
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+        model_id = proxy.create_model(model, MistralOcr().litellm_params())
+        resources.defer(lambda: proxy.delete_model(model_id))
         key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+        result = proxy.transport.send(
             "/v1/ocr",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalOcrBody(model=model),
         )
         assert_client_error(result, "ocr missing document")

tests/e2e/llm_translation/test_passthrough_headers_e2e.py

@@ -20,9 +20,8 @@ from pydantic import BaseModel, Field
 
 from e2e_config import unique_marker
 from e2e_http import AuthHeaders, NoBody, require_successful_call, unwrap
-from endpoints_client import MessagesResult
 from lifecycle import ResourceManager
-from models import ChatMessage, KeyGenerateBody
+from models import AnthropicMessagesResponse, ChatMessage, KeyGenerateBody
 from passthrough_client import PassthroughClient
 
 pytestmark = pytest.mark.e2e
@@ -165,8 +164,9 @@ class TestPassthroughHeaders:
             json=_messages_body(),
         )
         require_successful_call(result)
-        completion = MessagesResult.model_validate_json(result.body)
-        assert completion.text.strip(), (
+        completion = AnthropicMessagesResponse.model_validate_json(result.body)
+        text = "".join(block.text or "" for block in (completion.content or []))
+        assert text.strip(), (
             f"static x-api-key must reach Anthropic for the call to succeed at all; got {result.body[:300]}"
         )
 

tests/e2e/llm_translation/test_rerank_e2e.py

@@ -1,19 +1,20 @@
 """Live e2e: POST /v1/rerank ranks documents by relevance.
 
-Registers a Cohere rerank deployment at runtime and asserts the endpoint returns
-scored results within the requested top_n. Migrated from
+Registers Cohere and Bedrock rerank deployments at runtime and asserts the
+endpoint returns scored results within the requested top_n. No official
+OpenAI/Anthropic SDK covers /v1/rerank, so the call rides the shared typed
+transport via ProxyClient.rerank. Migrated from
 litellm-regression-tests/tests/test_inference_endpoints.py.
 """
 
 from __future__ import annotations
 
 import pytest
-
 from e2e_config import unique_marker
-from e2e_http import require_successful_call
-from endpoints_client import EndpointsClient, RerankResult
+from e2e_http import unwrap
 from lifecycle import ResourceManager
-from models import LiteLLMParamsBody
+from models import LiteLLMParamsBody, RerankBody, RerankResponse
+from proxy_client import ProxyClient
 
 pytestmark = pytest.mark.e2e
 
@@ -26,38 +27,39 @@ DOCUMENTS = [
 QUERY = "What is the capital of the United States?"
 
 
-def _assert_top_n_scored(body: str) -> None:
-    parsed = RerankResult.model_validate_json(body)
-    assert parsed.results, f"/rerank returned no results: {body[:300]}"
-    assert len(parsed.results) <= 3, f"top_n=3 not honored: {body[:300]}"
-    assert parsed.results[0].relevance_score is not None, (
-        f"top rerank result has no relevance_score: {body[:300]}"
+def _assert_top_n_scored(response: RerankResponse) -> None:
+    assert response.results, f"/rerank returned no results: {response!r}"
+    assert len(response.results) <= 3, f"top_n=3 not honored: {response!r}"
+    assert response.results[0].relevance_score is not None, (
+        f"top rerank result has no relevance_score: {response!r}"
+    )
+
+
+def _rerank_top_3(proxy: ProxyClient, key: str, model: str) -> RerankResponse:
+    return unwrap(
+        proxy.rerank(key, RerankBody(model=model, query=QUERY, documents=DOCUMENTS, top_n=3))
     )
 
 
 class TestRerank:
     @pytest.mark.covers("llm.rerank.cohere.basic.nonstream.works")
-    def test_rerank_scores_top_n(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
+    def test_rerank_scores_top_n(self, proxy: ProxyClient, resources: ResourceManager) -> None:
         model = f"e2e-rerank-{unique_marker()}"
-        model_id = endpoints_client.create_model(
+        model_id = proxy.create_model(
             model,
             LiteLLMParamsBody(model="cohere/rerank-v3.5", api_key="os.environ/COHERE_API_KEY"),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+        resources.defer(lambda: proxy.delete_model(model_id))
         key = resources.key()
 
-        result = endpoints_client.rerank(key, model, QUERY, DOCUMENTS, top_n=3)
-        require_successful_call(result)
-        _assert_top_n_scored(result.body)
+        _assert_top_n_scored(_rerank_top_3(proxy, key, model))
 
     @pytest.mark.covers("llm.rerank.bedrock.basic.nonstream.works", exercised_on=["rerank"])
     def test_bedrock_rerank_scores_top_n(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager
     ) -> None:
         model = f"e2e-bedrock-rerank-{unique_marker()}"
-        model_id = endpoints_client.create_model(
+        model_id = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model="bedrock/arn:aws:bedrock:us-east-1::foundation-model/cohere.rerank-v3-5:0",
@@ -66,9 +68,7 @@ class TestRerank:
                 aws_region_name="os.environ/AWS_REGION",
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+        resources.defer(lambda: proxy.delete_model(model_id))
         key = resources.key()
 
-        result = endpoints_client.rerank(key, model, QUERY, DOCUMENTS, top_n=3)
-        require_successful_call(result)
-        _assert_top_n_scored(result.body)
+        _assert_top_n_scored(_rerank_top_3(proxy, key, model))

tests/e2e/llm_translation/test_responses_e2e.py

@@ -1,12 +1,15 @@
 """Live e2e: POST /v1/responses returns a real completion.
 
-Registers an OpenAI deployment at runtime, drives the Responses API through the
-gateway, and asserts output text came back. Migrated from
+Registers an OpenAI deployment at runtime and drives the Responses API through
+the gateway with the real OpenAI SDK, the client customers actually use
+(LIT-4577), asserting output text came back. Malformed bodies the SDK refuses
+to build stay on the shared transport. Migrated from
 litellm-regression-tests/tests/test_inference_endpoints.py.
 """
 
 from __future__ import annotations
 
+import contextlib
 import json
 import threading
 from collections.abc import Mapping
@@ -14,26 +17,23 @@ from dataclasses import dataclass, field
 from types import MappingProxyType
 from typing import Final, cast
 
+import openai
 import pytest
 from e2e_config import PROVIDER_EDGE_ADVERTISE_HOST, PROVIDER_EDGE_BIND_HOST, unique_marker
-from e2e_http import (
-    assert_client_error,
-    require_successful_call,
-)
-from endpoints_client import (
-    EndpointsClient,
-    FunctionParameterProperty,
-    FunctionParameters,
-    ResponsesFunctionTool,
-    ResponsesOutputTextDeltaEvent,
-    ResponsesResult,
-    ResponsesStreamEventType,
-)
+from e2e_http import assert_client_error
 from lifecycle import ResourceManager
 from models import ChatBody, ChatMessage, LiteLLMParamsBody
+from openai.types.responses import (
+    FunctionToolParam,
+    Response,
+    ResponseFunctionToolCall,
+    ResponseInputParam,
+)
 from provider_edge import LiveEdge, start_provider_edge
 from provider_edge_bedrock import bedrock_signer
-from pydantic import BaseModel, ValidationError
+from proxy_client import ProxyClient
+from pydantic import BaseModel
+from sdk_clients import NO_PROXY_CACHE, SdkClients
 
 pytestmark = pytest.mark.e2e
 
@@ -45,6 +45,8 @@ class _OptionalResponsesBody(BaseModel):
 
 
 BEDROCK_CONVERSE_BACKEND = "bedrock/us.anthropic.claude-haiku-4-5-20251001-v1:0"
+INSTRUCTIONS = "You are a helpful assistant"
+CAT_IMAGE_URL = "https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg"
 BEDROCK_EDGE_REGION: Final = "us-east-1"
 BEDROCK_EDGE_MOUNT: Final = f"bedrock/{BEDROCK_EDGE_REGION}"
 
@@ -73,14 +75,25 @@ class ConverseRequestCapture:
             return tuple(self._bodies)
 
 
-WEATHER_TOOL = ResponsesFunctionTool(
-    name="get_weather",
-    description="Get the weather for a location",
-    parameters=FunctionParameters(
-        properties={"location": FunctionParameterProperty(type="string")},
-        required=["location"],
-    ),
-)
+WEATHER_TOOL: FunctionToolParam = {
+    "type": "function",
+    "name": "get_weather",
+    "description": "Get the weather for a location",
+    "parameters": {
+        "type": "object",
+        "properties": {"location": {"type": "string"}},
+        "required": ["location"],
+    },
+    "strict": False,
+}
+
+
+def _openai_params() -> LiteLLMParamsBody:
+    return LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY")
+
+
+def _anthropic_params() -> LiteLLMParamsBody:
+    return LiteLLMParamsBody(model="anthropic/claude-haiku-4-5", api_key="os.environ/ANTHROPIC_API_KEY")
 
 
 def _bedrock_params() -> LiteLLMParamsBody:
@@ -92,6 +105,27 @@ def _bedrock_params() -> LiteLLMParamsBody:
     )
 
 
+def _register(
+    proxy: ProxyClient, resources: ResourceManager, params: LiteLLMParamsBody, prefix: str = "e2e-responses"
+) -> str:
+    model = f"{prefix}-{unique_marker()}"
+    model_id = proxy.create_model(model, params)
+    resources.defer(lambda: proxy.delete_model(model_id))
+    return model
+
+
+def _function_calls(response: Response) -> tuple[ResponseFunctionToolCall, ...]:
+    return tuple(item for item in response.output if isinstance(item, ResponseFunctionToolCall))
+
+
+def _assert_weather_call(response: Response) -> None:
+    function_call = next((call for call in _function_calls(response) if call.name == "get_weather"), None)
+    assert function_call is not None, f"no get_weather function call: {response.output!r}"
+    raw_arguments = cast(object, json.loads(function_call.arguments))
+    arguments = WeatherArguments.model_validate(raw_arguments)
+    assert arguments.location, f"function call arguments missing location: {function_call.arguments}"
+
+
 class WeatherArguments(BaseModel):
     location: str
 
@@ -99,250 +133,184 @@ class WeatherArguments(BaseModel):
 class TestResponses:
     @pytest.mark.covers("llm.responses.openai.basic.nonstream.works")
     def test_responses_returns_completion(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY"),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _openai_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses(key, model, "reply with one word")
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        assert parsed.text.strip(), f"/responses returned no output text: {result.body[:300]}"
+        response = client.responses.create(
+            model=model, input="reply with one word", instructions=INSTRUCTIONS, extra_body=NO_PROXY_CACHE
+        )
+        assert response.output_text.strip(), f"/responses returned no output text: {response.output!r}"
 
     @pytest.mark.covers("llm.responses.openai.basic.stream.works")
     def test_responses_streaming_returns_completion(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY"),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _openai_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses(key, model, "reply with one word", stream=True)
-        require_successful_call(result)
-        delta_events = tuple(
-            parsed
-            for event in result.stream_events
-            if (parsed := _parse_stream_event(event)) is not None
+        stream = client.responses.create(
+            model=model,
+            input="reply with one word",
+            instructions=INSTRUCTIONS,
+            stream=True,
+            extra_body=NO_PROXY_CACHE,
+        )
+        events = tuple(stream)
+        assert events, "responses stream returned no events"
+        deltas = tuple(event.delta for event in events if event.type == "response.output_text.delta")
+        assert any(delta for delta in deltas), "responses stream returned no text deltas"
+        assert events[-1].type == "response.completed", (
+            f"responses stream did not terminate with response.completed: {events[-1].type}"
         )
-
-        assert any(event.delta for event in delta_events), "responses stream returned no text deltas"
-        assert result.stream_events, "responses stream returned no events"
-        assert (
-            ResponsesStreamEventType.model_validate_json(result.stream_events[-1]).type
-            == "response.completed"
-        ), "responses stream did not terminate with response.completed"
 
     @pytest.mark.covers("llm.responses.openai.basic.nonstream.cost_logged")
-    def test_responses_logs_cost(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY"),
+    def test_responses_logs_cost(self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients) -> None:
+        model = _register(proxy, resources, _openai_params())
+        client = sdk.openai(resources.key())
+
+        raw = client.responses.with_raw_response.create(
+            model=model,
+            input=f"reply with one word {unique_marker()}",
+            instructions=INSTRUCTIONS,
+            extra_body=NO_PROXY_CACHE,
+        )
+        response = raw.parse()
+        assert response.output_text.strip(), f"/responses returned no output text: {response.output!r}"
+        assert raw.headers.get("x-litellm-call-id") and response.id, (
+            f"missing response identifiers: id={response.id!r}, headers={dict(raw.headers)}"
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
 
-        result = endpoints_client.responses(key, model, f"reply with one word {unique_marker()}")
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        assert parsed.text.strip(), f"/responses returned no output text: {result.body[:300]}"
-        assert result.call_id and parsed.id, f"missing response identifiers: {result.body[:300]}"
-
-        rows = endpoints_client.proxy.poll_logs_for_request_id(
-            parsed.id,
+        rows = proxy.poll_logs_for_request_id(
+            response.id,
             predicate=lambda logged_rows: any((row.spend or 0) > 0 for row in logged_rows),
         )
         row = next((logged_row for logged_row in rows if (logged_row.spend or 0) > 0), None)
-        assert row is not None, f"no costed spend row for response id {parsed.id}"
+        assert row is not None, f"no costed spend row for response id {response.id}"
         assert "gpt-4o-mini" in (row.model or ""), f"unexpected spend row model: {row.model}"
 
     @pytest.mark.covers("llm.responses.openai.tool_use.nonstream.works")
     def test_responses_returns_function_call(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY"),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _openai_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses_with_tools(
-            key,
-            model,
-            "What is the weather in San Francisco? Use the get_weather tool.",
-            [
-                ResponsesFunctionTool(
-                    name="get_weather",
-                    description="Get the weather for a location",
-                    parameters=FunctionParameters(
-                        properties={"location": FunctionParameterProperty(type="string")},
-                        required=["location"],
-                    ),
-                )
-            ],
+        response = client.responses.create(
+            model=model,
+            input="What is the weather in San Francisco? Use the get_weather tool.",
+            instructions=INSTRUCTIONS,
+            tools=[WEATHER_TOOL],
+            extra_body=NO_PROXY_CACHE,
         )
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        function_call = next(
-            (call for call in parsed.function_calls if call.name == "get_weather"),
-            None,
-        )
-        assert function_call is not None, f"no get_weather function call: {result.body[:500]}"
-        assert function_call.arguments is not None
-        raw_arguments = cast(object, json.loads(function_call.arguments))
-        arguments = WeatherArguments.model_validate(raw_arguments)
-        assert arguments.location, f"function call arguments missing location: {function_call.arguments}"
+        _assert_weather_call(response)
 
     @pytest.mark.covers("llm.responses.openai.vision.nonstream.works")
     def test_responses_vision_describes_image(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
+        model = _register(
+            proxy,
+            resources,
             LiteLLMParamsBody(model="openai/gpt-4o", api_key="os.environ/OPENAI_API_KEY"),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses_vision(
-            key,
-            model,
-            "What animal is shown in this image? Answer in one word",
-            "https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg",
+        vision_input: ResponseInputParam = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "input_text", "text": "What animal is shown in this image? Answer in one word"},
+                    {"type": "input_image", "image_url": CAT_IMAGE_URL, "detail": "auto"},
+                ],
+            }
+        ]
+        response = client.responses.create(
+            model=model, input=vision_input, instructions=INSTRUCTIONS, extra_body=NO_PROXY_CACHE
+        )
+        text = response.output_text.strip().lower()
+        assert text, f"/responses vision returned no output text: {response.output!r}"
+        assert any(keyword in text for keyword in ("cat", "feline")), (
+            f"vision response did not describe the image: {text[:300]}"
         )
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        text = parsed.text.strip().lower()
-        assert text, f"/responses vision returned no output text: {result.body[:300]}"
-        assert any(
-            keyword in text
-            for keyword in ("cat", "feline")
-        ), f"vision response did not describe the image: {parsed.text[:300]}"
 
     @pytest.mark.covers("llm.responses.anthropic.basic.nonstream.works")
     def test_responses_anthropic_returns_completion(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(
-                model="anthropic/claude-haiku-4-5", api_key="os.environ/ANTHROPIC_API_KEY"
-            ),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _anthropic_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses(key, model, "reply with one word")
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        assert parsed.text.strip(), f"/responses returned no output text: {result.body[:300]}"
+        response = client.responses.create(
+            model=model, input="reply with one word", instructions=INSTRUCTIONS, extra_body=NO_PROXY_CACHE
+        )
+        assert response.output_text.strip(), f"/responses returned no output text: {response.output!r}"
 
     @pytest.mark.covers("llm.responses.anthropic.tool_use.nonstream.works")
     def test_responses_anthropic_returns_function_call(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(
-                model="anthropic/claude-haiku-4-5", api_key="os.environ/ANTHROPIC_API_KEY"
-            ),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _anthropic_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses_with_tools(
-            key,
-            model,
-            "What is the weather in San Francisco? Use the get_weather tool.",
-            [
-                ResponsesFunctionTool(
-                    name="get_weather",
-                    description="Get the weather for a location",
-                    parameters=FunctionParameters(
-                        properties={"location": FunctionParameterProperty(type="string")},
-                        required=["location"],
-                    ),
-                )
-            ],
+        response = client.responses.create(
+            model=model,
+            input="What is the weather in San Francisco? Use the get_weather tool.",
+            instructions=INSTRUCTIONS,
+            tools=[WEATHER_TOOL],
+            extra_body=NO_PROXY_CACHE,
         )
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        function_call = next(
-            (call for call in parsed.function_calls if call.name == "get_weather"),
-            None,
-        )
-        assert function_call is not None, f"no get_weather function call: {result.body[:500]}"
-        assert function_call.arguments is not None
-        raw_arguments = cast(object, json.loads(function_call.arguments))
-        arguments = WeatherArguments.model_validate(raw_arguments)
-        assert arguments.location, f"function call arguments missing location: {function_call.arguments}"
+        _assert_weather_call(response)
 
     @pytest.mark.covers("llm.responses.bedrock_converse.basic.nonstream.works")
     def test_responses_bedrock_returns_completion(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(model, _bedrock_params())
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _bedrock_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses(key, model, "reply with one word")
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        assert parsed.text.strip(), f"/responses over bedrock returned no output text: {result.body[:300]}"
+        response = client.responses.create(
+            model=model, input="reply with one word", instructions=INSTRUCTIONS, extra_body=NO_PROXY_CACHE
+        )
+        assert response.output_text.strip(), f"/responses over bedrock returned no output text: {response.output!r}"
 
     @pytest.mark.covers("llm.responses.bedrock_converse.tool_use.nonstream.works")
     def test_responses_bedrock_returns_function_call(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
     ) -> None:
-        model = f"e2e-responses-{unique_marker()}"
-        model_id = endpoints_client.create_model(model, _bedrock_params())
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
-        key = resources.key()
+        model = _register(proxy, resources, _bedrock_params())
+        client = sdk.openai(resources.key())
 
-        result = endpoints_client.responses_with_tools(
-            key, model, "What is the weather in San Francisco? Use the get_weather tool.", [WEATHER_TOOL]
+        response = client.responses.create(
+            model=model,
+            input="What is the weather in San Francisco? Use the get_weather tool.",
+            instructions=INSTRUCTIONS,
+            tools=[WEATHER_TOOL],
+            extra_body=NO_PROXY_CACHE,
         )
-        require_successful_call(result)
-        parsed = ResponsesResult.model_validate_json(result.body)
-        function_call = next((call for call in parsed.function_calls if call.name == "get_weather"), None)
-        assert function_call is not None, f"no get_weather function call over bedrock: {result.body[:500]}"
-        assert function_call.arguments is not None
-        raw_arguments = cast(object, json.loads(function_call.arguments))
-        arguments = WeatherArguments.model_validate(raw_arguments)
-        assert arguments.location, f"function call arguments missing location: {function_call.arguments}"
+        _assert_weather_call(response)
 
     @pytest.mark.provider_edge_host
     @pytest.mark.parametrize("endpoint", ["/v1/responses", "/v1/chat/completions"])
     def test_bedrock_forwards_allowed_safety_identifier_as_additional_model_request_field(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager, endpoint: str
+        self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients, endpoint: str
     ) -> None:
+        """Judges the Converse bodies the edge captured, not the reply: Claude on
+        Bedrock rejects the forwarded field with a 400, which the chat leg's
+        ``Result`` carries as a value and the OpenAI SDK raises."""
         capture: Final = ConverseRequestCapture()
         edge: Final = start_provider_edge(
             LiveEdge(observe_request=capture.observe, sign=bedrock_signer(BEDROCK_EDGE_REGION)),
-            mounts=MappingProxyType({BEDROCK_EDGE_MOUNT: f"https://bedrock-runtime.{BEDROCK_EDGE_REGION}.amazonaws.com"}),
+            mounts=MappingProxyType(
+                {BEDROCK_EDGE_MOUNT: f"https://bedrock-runtime.{BEDROCK_EDGE_REGION}.amazonaws.com"}
+            ),
             bind_host=PROVIDER_EDGE_BIND_HOST,
             advertise_host=PROVIDER_EDGE_ADVERTISE_HOST,
         )
         resources.defer(edge.shutdown)
         model: Final = f"e2e-responses-{unique_marker()}"
-        model_id: Final = endpoints_client.create_model(
+        model_id: Final = proxy.create_model(
             model,
             LiteLLMParamsBody(
                 model=BEDROCK_CONVERSE_BACKEND,
@@ -353,14 +321,21 @@ class TestResponses:
                 allowed_openai_params=["safety_identifier"],
             ),
         )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+        resources.defer(lambda: proxy.delete_model(model_id))
         key: Final = resources.key()
         safety_identifier: Final = f"end-user-{unique_marker()}"
 
         if endpoint == "/v1/responses":
-            endpoints_client.responses(key, model, "reply with one word", safety_identifier=safety_identifier)
+            with contextlib.suppress(openai.BadRequestError):
+                sdk.openai(key).responses.create(
+                    model=model,
+                    input="reply with one word",
+                    instructions=INSTRUCTIONS,
+                    safety_identifier=safety_identifier,
+                    extra_body=NO_PROXY_CACHE,
+                )
         else:
-            endpoints_client.proxy.chat(
+            proxy.chat(
                 key,
                 ChatBody(
                     model=model,
@@ -375,59 +350,37 @@ class TestResponses:
             f"{endpoint} did not forward safety_identifier to Bedrock Converse on every attempt: {capture.bodies}"
         )
 
-    @pytest.mark.skip(reason="stage red: product gap, /v1/responses 500s (aresponses TypeError) on missing input instead of 400")
+    @pytest.mark.skip(
+        reason="stage red: product gap, /v1/responses 500s (aresponses TypeError) on missing input instead of 400"
+    )
     @pytest.mark.covers("llm.responses.openai.input_validation.nonstream.works")
-    def test_missing_input_returns_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model = f"e2e-responses-val-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY"),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+    def test_missing_input_returns_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model = _register(proxy, resources, _openai_params(), prefix="e2e-responses-val")
         key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+        result = proxy.transport.send(
             "/v1/responses",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalResponsesBody(model=model),
         )
         assert_client_error(result, "responses missing input")
 
     @pytest.mark.covers("llm.responses.openai.input_validation.nonstream.works")
-    def test_missing_model_returns_client_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
+    def test_missing_model_returns_client_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
         key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+        result = proxy.transport.send(
             "/v1/responses",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalResponsesBody(input="ping"),
         )
         assert_client_error(result, "responses missing model")
 
     @pytest.mark.covers("llm.responses.openai.input_validation.nonstream.works")
-    def test_empty_input_returns_client_error(
-        self, endpoints_client: EndpointsClient, resources: ResourceManager
-    ) -> None:
-        model = f"e2e-responses-val-{unique_marker()}"
-        model_id = endpoints_client.create_model(
-            model,
-            LiteLLMParamsBody(model="openai/gpt-4o-mini", api_key="os.environ/OPENAI_API_KEY"),
-        )
-        resources.defer(lambda: endpoints_client.delete_model(model_id))
+    def test_empty_input_returns_client_error(self, proxy: ProxyClient, resources: ResourceManager) -> None:
+        model = _register(proxy, resources, _openai_params(), prefix="e2e-responses-val")
         key = resources.key()
-        result = endpoints_client.proxy.transport.send(
+        result = proxy.transport.send(
             "/v1/responses",
-            headers=endpoints_client.proxy.transport.bearer(key),
+            headers=proxy.transport.bearer(key),
             json=_OptionalResponsesBody(model=model, input=""),
         )
         assert_client_error(result, "responses empty input")
-
-def _parse_stream_event(
-    event: str,
-) -> ResponsesOutputTextDeltaEvent | None:
-    try:
-        return ResponsesOutputTextDeltaEvent.model_validate_json(event)
-    except ValidationError:
-        return None

tests/e2e/models.py

@@ -697,6 +697,26 @@ class EmbedResponse(BaseModel):
     model: str | None = None
 
 
+# ---------- rerank ----------
+
+
+class RerankBody(BaseModel):
+    model: str
+    query: str
+    documents: list[str]
+    top_n: int
+    cache: dict[str, bool] | None = {"no-cache": True}
+
+
+class RerankItem(BaseModel):
+    index: int | None = None
+    relevance_score: float | None = None
+
+
+class RerankResponse(BaseModel):
+    results: list[RerankItem] = []
+
+
 # ---------- ocr ----------
 
 

tests/e2e/proxy_client.py

@@ -79,6 +79,8 @@ from models import (
     ModelUpdateBody,
     OcrBody,
     OcrResponse,
+    RerankBody,
+    RerankResponse,
     RouterCurrentValues,
     RouterSettingsResponse,
     SpendLogRow,
@@ -940,6 +942,16 @@ class ProxyClient:
             timeout=SLOW_PROVIDER_TIMEOUT_SECONDS,
         )
 
+    def rerank(self, key: str, body: RerankBody) -> Result[RerankResponse]:
+        """POST /v1/rerank (Cohere-format). No official OpenAI/Anthropic SDK
+        covers this route, so it stays on the shared typed transport."""
+        return self.transport.post(
+            "/v1/rerank",
+            headers=self.transport.bearer(key),
+            json=body,
+            response_type=RerankResponse,
+        )
+
     def count_tokens(self, key: str, body: CountTokensBody) -> Result[CountTokensResponse]:
         """POST /v1/messages/count_tokens (Anthropic-native). Sends the
         anthropic-version header so the native path accepts it; harmless on the

tests/integration/_support/client.py

@@ -34,12 +34,19 @@ def delete_key_if_present(candidate: Gateway, key: str) -> None:
     assert read_rows('SELECT token FROM "LiteLLM_VerificationToken" WHERE token=%s', (digest,)) == []
 
 
-def eventually(read: Callable[[], T], satisfied: Callable[[T], bool], seconds: float = 10) -> T:
+def eventually(
+    read: Callable[[], T],
+    satisfied: Callable[[T], bool],
+    seconds: float = 10,
+    return_last_on_timeout: bool = False,
+) -> T:
     deadline: Final = time.monotonic() + seconds
     while True:
         observed: Final = read()
         if satisfied(observed):
             return observed
+        if return_last_on_timeout and time.monotonic() >= deadline:
+            return observed
         assert time.monotonic() < deadline, f"State did not converge: {observed!r}"
         time.sleep(0.1)
 
@@ -58,12 +65,32 @@ class Gateway:
         *,
         key: str | None = None,
         params: Mapping[str, str] | None = None,
+        headers: Mapping[str, str] | None = None,
     ) -> httpx.Response:
+        request_headers: Final = {
+            "Authorization": f"Bearer {self.key if key is None else key}",
+            **(headers or {}),
+        }
         return self.client.request(
             method,
             path,
             json=body,
             params=params,
+            headers=request_headers,
+        )
+
+    def request_multipart(
+        self,
+        path: str,
+        fields: Mapping[str, str],
+        files: Mapping[str, tuple[str, bytes, str]],
+        *,
+        key: str | None = None,
+    ) -> httpx.Response:
+        return self.client.post(
+            path,
+            data=fields,
+            files=files,
             headers={"Authorization": f"Bearer {self.key if key is None else key}"},
         )
 

tests/integration/_support/upstream.py

@@ -1,32 +1,40 @@
 from __future__ import annotations
 
 import argparse
-from collections import deque
-from collections.abc import Mapping
+import asyncio
+import base64
 import json
-from dataclasses import dataclass, field
 import os
+import struct
+import uuid
+import zlib
+from collections import deque
+from collections.abc import AsyncIterator, Mapping
+from dataclasses import dataclass, field
 from pathlib import Path
 from queue import SimpleQueue
-import struct
 from typing import Final, cast
-import zlib
 
 import httpx
 import uvicorn
+from _fake_openai_endpoint_server import chat_completions, completions, embeddings, health, moderations
+from integration.cost_calculation.cost_tracking_case import (
+    BinaryResponse,
+    EventStreamEvent,
+    EventStreamResponse,
+    JsonResponse,
+    RealtimeResponse,
+    RoutedResponse,
+    SseResponse,
+    StoredResponse,
+    TextResponse,
+)
 from pydantic import BaseModel, JsonValue, TypeAdapter, ValidationError
 from starlette.applications import Starlette
 from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
-from starlette.routing import Route
-
-from _fake_openai_endpoint_server import chat_completions, completions, embeddings, health, moderations
-from integration.cost_calculation.cost_tracking_case import (
-    EventStreamResponse,
-    JsonResponse,
-    SseResponse,
-    StoredResponse,
-)
+from starlette.responses import JSONResponse, Response, StreamingResponse
+from starlette.routing import Route, WebSocketRoute
+from starlette.websockets import WebSocket
 
 JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
 CASES_FILE: Final = Path(__file__).resolve().parents[1] / "cost_calculation" / "cost_tracking_cases.json"
@@ -75,10 +83,15 @@ def _aws_str_header(name: str, value: str) -> bytes:
     )
 
 
-def _aws_event_frame(event_type: str, payload: Mapping[str, JsonValue], scenario_id: str) -> bytes:
+def _aws_event_frame(
+    event_type: str,
+    payload: Mapping[str, JsonValue],
+    scenario_id: str,
+    unique_id: str,
+) -> bytes:
     payload_bytes: Final = json.dumps(payload, separators=(",", ":")).replace(
         "$REQUEST_ID", scenario_id
-    ).encode()
+    ).replace("$UNIQUE_ID", unique_id).encode()
     headers_bytes: Final = (
         _aws_str_header(":event-type", event_type)
         + _aws_str_header(":content-type", "application/json")
@@ -193,32 +206,121 @@ class Provider:
 
     async def scripted(self, request: Request) -> Response:
         segments: Final = tuple(segment for segment in cast(str, request.path_params["path"]).split("/") if segment)
-        if not segments:
-            return JSONResponse({"error": "Unknown scenario"}, status_code=404)
-        scenario_id: Final = segments[0].split(":", 1)[0]
+        scenario_id: Final = (
+            segments[0].split(":", 1)[0]
+            if segments and self.scenario_store.get(segments[0].split(":", 1)[0]) is not None
+            else request.headers.get("x-scripted-scenario", "")
+        )
         response: Final = self.scenario_store.get(scenario_id)
         if response is None:
             return JSONResponse({"error": "Unknown scenario"}, status_code=404)
+        if isinstance(response, RoutedResponse):
+            route_key: Final = f"{request.method} /{'/'.join(segments[1:])}"
+            route: Final = next(
+                (
+                    candidate
+                    for key, candidate in response.routes.items()
+                    if key.replace("$REQUEST_ID", scenario_id) == route_key
+                ),
+                None,
+            )
+            if route is None:
+                return JSONResponse({"error": "Unknown scripted route"}, status_code=404)
+            return self._response(route, scenario_id)
         return self._response(response, scenario_id)
 
+    async def realtime(self, websocket: WebSocket) -> None:
+        scenario_id: Final = websocket.headers.get("authorization", "").removeprefix("Bearer ")
+        response: Final = self.scenario_store.get(scenario_id)
+        if not isinstance(response, RealtimeResponse):
+            await websocket.close(code=4404)
+            return
+        await websocket.accept()
+        model: Final = websocket.query_params.get("model", "")
+        await websocket.send_json(
+            {
+                "type": "session.created",
+                "session": {
+                    "id": f"sess_{scenario_id}",
+                    "model": response.session_model if response.session_model is not None else model,
+                },
+            }
+        )
+        event_index: Final = iter(response.events)
+        async for message in websocket.iter_json():
+            payload: Final = JSON_OBJECT.validate_python(message)
+            if payload.get("type") != "response.create":
+                continue
+            event: Final = next(event_index, None)
+            if event is None:
+                continue
+            rendered: Final = JSON_OBJECT.validate_json(
+                json.dumps(event, separators=(",", ":"))
+                .replace("$REQUEST_ID", scenario_id)
+                .replace("$UNIQUE_ID", f"{scenario_id}-{uuid.uuid4().hex[:8]}")
+            )
+            await websocket.send_json(rendered)
+
     @staticmethod
     def _response(response: StoredResponse, scenario_id: str) -> Response:
+        unique_id: Final = f"{scenario_id}-{uuid.uuid4().hex[:8]}"
         match response:
             case JsonResponse():
                 return Response(
                     content=json.dumps(response.body, separators=(",", ":")).replace(
                         "$REQUEST_ID", scenario_id
+                    ).replace(
+                        "$UNIQUE_ID", unique_id
                     ).encode(),
                     media_type=response.content_type,
+                    status_code=response.status,
+                )
+            case BinaryResponse():
+                return Response(
+                    content=b"\x00" * response.length,
+                    media_type=response.content_type,
+                )
+            case TextResponse():
+                return Response(
+                    content=response.body.replace("$REQUEST_ID", scenario_id).encode(),
+                    media_type=response.content_type,
+                    status_code=response.status,
                 )
             case SseResponse():
+                if response.frame_delay_ms > 0:
+                    async def stream() -> AsyncIterator[bytes]:
+                        for frame in response.frames:
+                            yield (
+                                f"{frame.replace('$REQUEST_ID', scenario_id).replace('$UNIQUE_ID', unique_id)}\n\n"
+                            ).encode()
+                            await asyncio.sleep(response.frame_delay_ms / 1000)
+
+                    return StreamingResponse(stream(), media_type=response.content_type)
                 stream_body: Final = ("\n\n".join(response.frames) + "\n\n").replace(
                     "$REQUEST_ID", scenario_id
-                )
+                ).replace("$UNIQUE_ID", unique_id)
                 return Response(content=stream_body.encode(), media_type=response.content_type)
             case EventStreamResponse():
+                events: Final = (
+                    tuple(
+                        EventStreamEvent(
+                            event_type="chunk",
+                            payload={
+                                "bytes": base64.b64encode(
+                                    json.dumps(event.payload, separators=(",", ":"))
+                                    .replace("$REQUEST_ID", scenario_id)
+                                    .replace("$UNIQUE_ID", unique_id)
+                                    .encode()
+                                ).decode(),
+                            },
+                        )
+                        for event in response.events
+                    )
+                    if response.framing == "invoke"
+                    else response.events
+                )
                 event_body: Final = b"".join(
-                    _aws_event_frame(event.event_type, event.payload, scenario_id) for event in response.events
+                    _aws_event_frame(event.event_type, event.payload, scenario_id, unique_id) for event in events
                 )
                 return Response(content=event_body, media_type=response.content_type)
 
@@ -237,6 +339,8 @@ class Provider:
                 Route("/v1/embeddings", embeddings, methods=["POST"]),
                 Route("/v1/moderations", moderations, methods=["POST"]),
                 Route("/{path:path}", self.scripted, methods=["POST"]),
+                Route("/{path:path}", self.scripted, methods=["GET"]),
+                WebSocketRoute("/v1/realtime", self.realtime),
             ]
         )
 

tests/integration/contracts.json

@@ -166,6 +166,9 @@
     "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_video_create_status_and_content_follow_queue_wire_contract": [
       "other.provider_wire.fal_ai.video_queue_create_status_and_content_download"
     ],
+    "tests/integration/providers/test_fal_ai_video_wire.py::test_fal_video_failed_result_reports_failed_status_and_fal_error": [
+      "other.provider_wire.fal_ai.video_failed_result_surfaces_fal_error"
+    ],
     "tests/integration/providers/test_fal_ai_image_wire.py::test_fal_gpt_image_25_generation_sends_quality_and_size_and_charges_keyed_row": [
       "other.provider_wire.fal_ai.gpt_image_generation_quality_size_wire_and_keyed_pricing"
     ],
@@ -241,6 +244,30 @@
     "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-input_text]": [
       "quota_management.spend_tracking.cost_matrix.logs_cost"
     ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.6-batch-halved_rates_when_map_has_no_batch_keys]": [
+      "quota_management.spend_tracking.batch_costs.fallback_rates"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.6-batch-cached_input_halved]": [
+      "quota_management.spend_tracking.batch_costs.cached_input"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.4-batch-explicit_batch_rates_bill_cached_at_batch_input_rate]": [
+      "quota_management.spend_tracking.batch_costs.explicit_rates"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_batch_costs[gpt-5.6-batch-all_requests_failed_zero_spend]": [
+      "quota_management.spend_tracking.batch_costs.failed_requests"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-single_turn_text_audio_cached]": [
+      "quota_management.spend_tracking.realtime_costs.single_turn"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-two_turns_summed_into_one_row]": [
+      "quota_management.spend_tracking.realtime_costs.multiple_turns"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-priced_from_session_created_model]": [
+      "quota_management.spend_tracking.realtime_costs.session_model"
+    ],
+    "tests/integration/cost_calculation/test_batch_realtime_cost.py::test_realtime_costs[gpt-realtime-mini-2025-12-15-realtime-session_without_turns_zero_spend]": [
+      "quota_management.spend_tracking.realtime_costs.session_without_turns"
+    ],
     "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-cache_read]": [
       "quota_management.spend_tracking.cost_matrix.logs_cost"
     ],
@@ -397,6 +424,15 @@
     "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-gpt-5.6-stream_full_usage]": [
       "quota_management.spend_tracking.scripted_wire.logs_cost"
     ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_native_json]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_500_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_429_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
     "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-input_text]": [
       "quota_management.spend_tracking.cost_matrix.logs_cost"
     ],
@@ -1327,6 +1363,333 @@
     "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-stream_full_usage]": [
       "quota_management.spend_tracking.scripted_wire.logs_cost"
     ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[whisper-next-transcriptions-per-second]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[whisper-verbose-next-transcriptions-duration]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-4o-transcribe-next-transcriptions-tokens]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[nova-next-transcriptions-per-second]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-whisper-next-transcriptions-deployment]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[tts-next-speech-per-character]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[tts-next-hd-speech-per-character]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-tts-next-speech-deployment]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-standard]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-hd]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-wide]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dall-e-3-next-images-two]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-image-next-images-low]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[imagen-next-images-one]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[amazon-nova-canvas-next-images-one]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-image-next-images-edit]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-text-embeddings-4-large-deployment]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-cohere-embeddings-v4]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-cohere-rerank-v4]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-embeddings-titan-v2]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-embeddings-v5]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-rerank-v4-one]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-rerank-v4-three]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-rerank-v4-total-tokens-fallback]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[fireworks-embeddings-v1]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-embeddings-002]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[omni-moderations-next-list]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[omni-moderations-next-single]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-completions-openai-basic]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-completions-openai-n-best]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-completions-openai-stream-usage]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-3-large-dimensions]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-4-small-batch]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-4-small-single]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[text-embeddings-4-small-token-array]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together-completions-v1]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[together-embeddings-v1]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[vertex-embeddings-text-006]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_cache_read]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_reasoning]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_stream_cache_read]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_incomplete]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_previous_response_id]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_web_search_medium]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.3-codex-responses_file_search]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_service_tier_flex]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_service_tier_priority]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_input_text]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_cache_read]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_cache_write_5m]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_cache_write_1h]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_web_search]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_stream_cache_read]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_tiered_input_above_200k]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-haiku-4-5-messages_input_text]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[us.anthropic.claude-opus-5-v1:0-messages_input_text]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-messages_cache_read]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-passthrough-generate_content_priced_via_gemini_key]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-3.1-pro-passthrough-stream_generate_content_priced_via_vertex_key]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-passthrough-messages]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-passthrough-messages_cache_read]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-passthrough-converse]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[anthropic.claude-sonnet-5-v1:0-passthrough-converse_stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_input]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_boundary_stays_lower_tier]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_second_tier]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[dashscope-qwen4-max-tiered_above_top_range]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-lite-input_below_128k]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gemini-gemini-3.8-flash-lite-input_above_128k]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-cache_creation_1h_above_200k]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[openrouter-anthropic-claude-sonnet-5-provider_reported_cost]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[openrouter-anthropic-claude-sonnet-5-token_priced]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[perplexity-sonar-next-no_search]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[deepseek-deepseek-v4-chat-prompt_cache_hit]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[deepseek-deepseek-v4-chat-no_cache_fields_bills_zero_cache]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[xai-grok-5-reasoning_folded_into_completion]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[xai-grok-5-live_search]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[xai-grok-5-provider_reported_cost]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-invoke-haiku-json]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-invoke-haiku-stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-profile-base-model]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-eu-regional-key]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-apac-bare-fallback]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-nova-2-pro]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[bedrock-converse-mistral-large-3-stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-ai-gpt-5.4-mini-latest]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-ai-gpt-5.4-mini-latest-stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[azure-pinned-gpt-5.4-mini-stream]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[groq-qwen-3.8-json]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[groq-qwen-3.8-stream_x_groq_recount]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[cohere-command-a-v2-tokens]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[mistral-medium-2604-json]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[openai-deployment-pricing-override]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_400_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_401_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-upstream_500_stream_request_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-responses_upstream_500_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[claude-sonnet-5-messages_upstream_500_zero_spend]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-fallback_billed_to_answering_deployment]": [
+      "quota_management.spend_tracking.routing.fallback_billing"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-n_2_choices]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-finish_reason_length]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_usage_in_empty_choices_chunk]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-stream_usage_in_last_delta_chunk]": [
+      "quota_management.spend_tracking.scripted_wire.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-unknown_model_response_model_unknown]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-unknown_model_response_model_known]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-chat_request_to_embedding_entry]": [
+      "quota_management.spend_tracking.cost_matrix.logs_cost"
+    ],
+    "tests/integration/cost_calculation/test_cost_tracking.py::test_case_bills_expected_cost[gpt-5.6-client_disconnect_mid_stream]": [
+      "quota_management.spend_tracking.scripted_wire.client_disconnect"
+    ],
     "tests/integration/mcp/test_mcp_lifecycle.py::test_health_intersects_route_restricted_key_grants_in_both_management_modes": [
       "other.mcp.health.restricted_keys_intersect_grants_in_both_modes"
     ],

tests/integration/cost_calculation/assertions.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import httpx
+from integration.cost_calculation.conftest import (
+    CostBreakdown,
+    CostRow,
+    approx_equal,
+    assert_total_is_sum_of_components,
+)
+from integration.cost_calculation.cost_tracking_case import ExactExpected, RecountExpected
+
+
+def assert_breakdown(
+    case_name: str,
+    response_content_type: str,
+    expected: ExactExpected,
+    breakdown: CostBreakdown,
+    response: httpx.Response | None,
+) -> None:
+    if response is None:
+        assert not expected.cost_header, f"{case_name}: cost headers require an HTTP response"
+    assert breakdown.input_cost is not None and approx_equal(breakdown.input_cost, expected.input_cost), (
+        f"{case_name}: input_cost {breakdown.input_cost} != expected {expected.input_cost}"
+    )
+    assert breakdown.output_cost is not None and approx_equal(breakdown.output_cost, expected.output_cost), (
+        f"{case_name}: output_cost {breakdown.output_cost} != expected {expected.output_cost}"
+    )
+    for field, header_name, actual_component, expected_component in (
+        (
+            "cache_read_cost",
+            "x-litellm-response-cost-cache-read",
+            breakdown.cache_read_cost,
+            expected.cache_read_cost,
+        ),
+        (
+            "cache_creation_cost",
+            "x-litellm-response-cost-cache-creation",
+            breakdown.cache_creation_cost,
+            expected.cache_creation_cost,
+        ),
+        (
+            "reasoning_cost",
+            "x-litellm-response-cost-reasoning",
+            breakdown.reasoning_cost,
+            expected.reasoning_cost,
+        ),
+        (
+            "tool_usage_cost",
+            "x-litellm-response-cost-tool-usage",
+            breakdown.tool_usage_cost,
+            expected.tool_usage_cost,
+        ),
+    ):
+        if expected_component is None:
+            continue
+        omitted_component_allowed: bool = expected_component == 0.0
+        assert (actual_component is None and omitted_component_allowed) or (
+            actual_component is not None and approx_equal(actual_component, expected_component)
+        ), f"{case_name}: {field} {actual_component} != expected {expected_component}"
+        if response is not None and expected.cost_header and response_content_type == "application/json":
+            header: str | None = response.headers.get(header_name)
+            assert (header is None and omitted_component_allowed) or (
+                header is not None and approx_equal(float(header), expected_component)
+            ), f"{case_name}: {header_name} {header} != expected {expected_component}"
+    if response is not None and expected.cost_header and response_content_type == "application/json" and any(
+        component is not None
+        for component in (
+            expected.cache_read_cost,
+            expected.cache_creation_cost,
+            expected.reasoning_cost,
+            expected.tool_usage_cost,
+        )
+    ):
+        input_header: str | None = response.headers.get("x-litellm-response-cost-input")
+        output_header: str | None = response.headers.get("x-litellm-response-cost-output")
+        expected_input_header: float = expected.input_cost - (
+            expected.cache_read_cost or 0.0
+        ) - (expected.cache_creation_cost or 0.0)
+        assert input_header is not None and approx_equal(float(input_header), expected_input_header), (
+            f"{case_name}: x-litellm-response-cost-input {input_header} != expected {expected_input_header}"
+        )
+        assert output_header is not None and approx_equal(float(output_header), expected.output_cost), (
+            f"{case_name}: x-litellm-response-cost-output {output_header} != expected {expected.output_cost}"
+        )
+
+
+def assert_exact(
+    case_name: str,
+    response_content_type: str,
+    expected: ExactExpected,
+    row: CostRow,
+    response: httpx.Response | None,
+) -> None:
+    assert row.spend is not None and approx_equal(row.spend, expected.spend), (
+        f"{case_name}: spend {row.spend} != expected {expected.spend} "
+        f"(breakdown {row.breakdown.model_dump() if row.breakdown is not None else None})"
+    )
+    breakdown: CostBreakdown | None = row.breakdown
+    if expected.breakdown_persisted:
+        assert breakdown is not None, f"{case_name}: no cost_breakdown persisted"
+    if breakdown is not None:
+        assert_breakdown(case_name, response_content_type, expected, breakdown, response)
+    assert row.prompt_tokens == expected.prompt_tokens, (
+        f"{case_name}: prompt_tokens {row.prompt_tokens} != expected {expected.prompt_tokens}"
+    )
+    assert row.completion_tokens == expected.completion_tokens, (
+        f"{case_name}: completion_tokens {row.completion_tokens} != expected {expected.completion_tokens}"
+    )
+    if breakdown is not None:
+        assert_total_is_sum_of_components(row, breakdown, case_name)
+
+
+def assert_recount(case_name: str, expected: RecountExpected, row: CostRow) -> None:
+    assert row.prompt_tokens is not None and row.prompt_tokens > 0, (
+        f"{case_name}: recount case counted no input tokens: prompt_tokens={row.prompt_tokens}"
+    )
+    assert row.completion_tokens is not None and row.completion_tokens > 0, (
+        f"{case_name}: recount case counted no output tokens: completion_tokens={row.completion_tokens}"
+    )
+    if expected.prompt_tokens is not None:
+        assert row.prompt_tokens == expected.prompt_tokens, (
+            f"{case_name}: prompt_tokens {row.prompt_tokens} != pinned {expected.prompt_tokens}"
+        )
+    if expected.completion_tokens is not None:
+        assert row.completion_tokens == expected.completion_tokens, (
+            f"{case_name}: completion_tokens {row.completion_tokens} != pinned {expected.completion_tokens}"
+        )
+    if expected.min_completion_tokens is not None:
+        assert row.completion_tokens >= expected.min_completion_tokens, (
+            f"{case_name}: completion_tokens {row.completion_tokens} < minimum {expected.min_completion_tokens}"
+        )
+    if expected.max_completion_tokens is not None:
+        assert row.completion_tokens <= expected.max_completion_tokens, (
+            f"{case_name}: completion_tokens {row.completion_tokens} > maximum {expected.max_completion_tokens}"
+        )
+    recount: float = row.prompt_tokens * expected.recount.input_cost_per_token + (
+        row.completion_tokens * expected.recount.output_cost_per_token
+    )
+    assert row.spend is not None and approx_equal(row.spend, recount), (
+        f"{case_name}: spend {row.spend} != recount {recount} at map rates"
+    )
+    assert row.breakdown is not None, f"{case_name}: no cost_breakdown persisted"
+    assert_total_is_sum_of_components(row, row.breakdown, case_name)

tests/integration/cost_calculation/conftest.py

@@ -3,18 +3,18 @@ from __future__ import annotations
 import functools
 import json
 import os
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
 from hashlib import sha256
 from typing import Final
 
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
-from pydantic import BaseModel, ConfigDict
-
 from integration._support.client import JSON_OBJECT, Scenario, eventually, object_value, string_value
 from integration._support.database import read_rows
-from integration._support.upstream import delete_scenario, register_scenario
-from integration.cost_calculation.cost_tracking_case import CostTrackingTestCase
+from integration._support.upstream import ScenarioHandle, delete_scenario, register_scenario
+from integration.cost_calculation.cost_tracking_case import CostTrackingTestCase, StoredResponse
+from pydantic import BaseModel, ConfigDict
 
 
 class CostBreakdown(BaseModel):
@@ -40,22 +40,52 @@ class CostRow(BaseModel):
     model_config = ConfigDict(extra="ignore")
 
     spend: float | None = None
+    status: str | None = None
     prompt_tokens: int | None = None
     completion_tokens: int | None = None
+    model_id: str | None = None
+    call_type: str | None = None
     metadata: CostMetadata | None = None
 
     @property
-    def breakdown(self) -> CostBreakdown:
-        assert self.metadata is not None and self.metadata.cost_breakdown is not None
-        return self.metadata.cost_breakdown
+    def breakdown(self) -> CostBreakdown | None:
+        return self.metadata.cost_breakdown if self.metadata is not None else None
+
+
+class FailureRow(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    spend: float
+    status: str
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+
+
+class DailySpend(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    spend: float
+    prompt_tokens: int
+    completion_tokens: int
+    api_requests: int
+
+
+class Rollups(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    key_spend: float
+    team_spend: float
+    user_spend: float
+    end_user_spend: float
+    daily_user: DailySpend
+    daily_team: DailySpend
 
 
 def approx_equal(actual: float, expected: float) -> bool:
     return abs(actual - expected) <= max(1e-9, abs(expected) * 1e-2)
 
 
-def assert_total_is_sum_of_components(row: CostRow, context: str) -> None:
-    breakdown: Final = row.breakdown
+def assert_total_is_sum_of_components(row: CostRow, breakdown: CostBreakdown, context: str) -> None:
     total: Final = sum(
         cost or 0.0
         for cost in (breakdown.input_cost, breakdown.output_cost, breakdown.tool_usage_cost)
@@ -74,7 +104,7 @@ def _row(value: Mapping[str, object]) -> CostRow | None:
     metadata_value: Final = value.get("metadata")
     metadata: Final = json.loads(metadata_value) if isinstance(metadata_value, str) else metadata_value
     parsed: Final = CostRow.model_validate({**value, "metadata": metadata})
-    return parsed if parsed.metadata and parsed.metadata.cost_breakdown else None
+    return parsed if parsed.metadata is not None or (parsed.spend is not None and parsed.status is not None) else None
 
 
 def poll_cost_row(key: str) -> CostRow:
@@ -82,7 +112,8 @@ def poll_cost_row(key: str) -> CostRow:
 
     def read() -> CostRow | None:
         rows: Final = read_rows(
-            'SELECT spend, metadata, prompt_tokens, completion_tokens FROM "LiteLLM_SpendLogs" WHERE api_key=%s',
+            'SELECT spend, status, metadata, prompt_tokens, completion_tokens, model_id, call_type '
+            'FROM "LiteLLM_SpendLogs" WHERE api_key=%s',
             (digest,),
         )
         return next((parsed for row in rows if (parsed := _row(row)) is not None), None)
@@ -92,6 +123,128 @@ def poll_cost_row(key: str) -> CostRow:
     return result
 
 
+def read_rows_now(key: str) -> tuple[CostRow, ...]:
+    digest: Final = sha256(key.encode()).hexdigest()
+    rows: Final = read_rows(
+        'SELECT spend, status, metadata, prompt_tokens, completion_tokens, model_id, call_type '
+        'FROM "LiteLLM_SpendLogs" WHERE api_key=%s ORDER BY "startTime"',
+        (digest,),
+    )
+    return tuple(parsed for row in rows if (parsed := _row(row)) is not None)
+
+
+def poll_rows(key: str, count: int) -> tuple[CostRow, ...]:
+    return poll_rows_where(key, count, lambda _row: True)
+
+
+def poll_rows_where(
+    key: str,
+    count: int,
+    predicate: Callable[[CostRow], bool],
+) -> tuple[CostRow, ...]:
+    result: Final = eventually(
+        lambda: tuple(row for row in read_rows_now(key) if predicate(row)),
+        lambda rows: len(rows) >= count,
+        seconds=60,
+    )
+    return result
+
+
+def poll_rollups(
+    key: str,
+    team_id: str,
+    user_id: str,
+    end_user_id: str,
+    target_spend: float,
+    target_requests: int,
+) -> Rollups:
+    digest: Final = sha256(key.encode()).hexdigest()
+
+    def read() -> Rollups | None:
+        key_rows: Final = read_rows(
+            'SELECT spend FROM "LiteLLM_VerificationToken" WHERE token=%s',
+            (digest,),
+        )
+        team_rows: Final = read_rows(
+            'SELECT spend FROM "LiteLLM_TeamTable" WHERE team_id=%s',
+            (team_id,),
+        )
+        user_rows: Final = read_rows(
+            'SELECT spend FROM "LiteLLM_UserTable" WHERE user_id=%s',
+            (user_id,),
+        )
+        end_user_rows: Final = read_rows(
+            'SELECT spend FROM "LiteLLM_EndUserTable" WHERE user_id=%s',
+            (end_user_id,),
+        )
+        daily_user_rows: Final = read_rows(
+            'SELECT spend, prompt_tokens, completion_tokens, api_requests '
+            'FROM "LiteLLM_DailyUserSpend" WHERE user_id=%s AND api_key=%s AND date=CURRENT_DATE::text',
+            (user_id, digest),
+        )
+        daily_team_rows: Final = read_rows(
+            'SELECT spend, prompt_tokens, completion_tokens, api_requests '
+            'FROM "LiteLLM_DailyTeamSpend" WHERE team_id=%s AND api_key=%s AND date=CURRENT_DATE::text',
+            (team_id, digest),
+        )
+        if not all((key_rows, team_rows, user_rows, end_user_rows, daily_user_rows, daily_team_rows)):
+            return None
+        rollups: Final = Rollups(
+            key_spend=float(key_rows[0]["spend"]),
+            team_spend=float(team_rows[0]["spend"]),
+            user_spend=float(user_rows[0]["spend"]),
+            end_user_spend=float(end_user_rows[0]["spend"]),
+            daily_user=DailySpend.model_validate(daily_user_rows[0]),
+            daily_team=DailySpend.model_validate(daily_team_rows[0]),
+        )
+        return rollups
+
+    def settled(value: Rollups | None) -> bool:
+        return value is not None and all(
+            (
+                approx_equal(value.key_spend, target_spend),
+                approx_equal(value.team_spend, target_spend),
+                approx_equal(value.user_spend, target_spend),
+                approx_equal(value.end_user_spend, target_spend),
+                approx_equal(value.daily_user.spend, target_spend),
+                approx_equal(value.daily_team.spend, target_spend),
+                value.daily_user.api_requests == target_requests,
+                value.daily_team.api_requests == target_requests,
+            )
+        )
+
+    result: Final = eventually(
+        read,
+        settled,
+        seconds=20,
+        return_last_on_timeout=True,
+    )
+    assert result is not None
+    return result
+
+
+def poll_failure_row(key: str) -> FailureRow:
+    digest: Final = sha256(key.encode()).hexdigest()
+
+    def read() -> FailureRow | None:
+        rows: Final = read_rows(
+            'SELECT spend, status, prompt_tokens, completion_tokens FROM "LiteLLM_SpendLogs" WHERE api_key=%s',
+            (digest,),
+        )
+        return next(
+            (
+                parsed
+                for row in rows
+                if (parsed := FailureRow.model_validate(row)).status == "failure"
+            ),
+            None,
+        )
+
+    result: Final = eventually(read, lambda row: row is not None, seconds=60)
+    assert result is not None
+    return result
+
+
 @functools.cache
 def _vertex_private_key_pem() -> str:
     return rsa.generate_private_key(public_exponent=65537, key_size=2048).private_bytes(
@@ -116,32 +269,57 @@ def _vertex_service_account_json(url: str) -> str:
     )
 
 
+@dataclass(frozen=True, slots=True)
+class RegisteredDeployment:
+    model_name: str
+    identity: str
+    handle: ScenarioHandle
+
+
 def register_scenario_deployment(
     scenario: Scenario,
     case: CostTrackingTestCase,
     marker: str,
     key: str,
-) -> str:
+    *,
+    response: StoredResponse | None = None,
+    marker_suffix: str = "",
+) -> RegisteredDeployment:
     control_url: Final = os.environ["INTEGRATION_UPSTREAM_URL"].rstrip("/")
     run_marker: Final = sha256(key.encode()).hexdigest()[:12]
-    handle: Final = register_scenario(f"sc-{marker}-{run_marker}", case.response)
+    handle: Final = register_scenario(
+        f"sc-{marker}{marker_suffix}-{run_marker}",
+        case.response if response is None else response,
+    )
     scenario.cleanups.callback(delete_scenario, handle)
-    model_name: Final = f"cost-{marker}-{run_marker}"
+    registered_model_name: Final = f"cost-{marker}{marker_suffix}-{run_marker}"
     parameters: Final = {
         "model": case.litellm_model,
         "api_key": case.api_key,
         "api_base": handle.api_base(),
         **case.litellm_params,
+        **(
+            {
+                key: value
+                for key, value in (
+                    ("input_cost_per_token", case.deployment.input_cost_per_token),
+                    ("output_cost_per_token", case.deployment.output_cost_per_token),
+                )
+                if value is not None
+            }
+            if case.deployment is not None
+            else {}
+        ),
         **(
             {"vertex_credentials": _vertex_service_account_json(control_url)}
-            if case.rates.litellm_provider == "vertex_ai-language-models"
+            if case.rates.litellm_provider.startswith("vertex_ai")
             else {}
         ),
     }
     created: Final = scenario.gateway.post(
         "/model/new",
         JSON_OBJECT.validate_python({
-            "model_name": model_name,
+            "model_name": registered_model_name,
             "litellm_params": parameters,
             "model_info": (
                 {"base_model": case.base_model}
@@ -152,4 +330,4 @@ def register_scenario_deployment(
     )
     identity: Final = string_value(object_value(created["model_info"])["id"])
     scenario.cleanups.callback(scenario.delete_model, identity)
-    return model_name
+    return RegisteredDeployment(model_name=registered_model_name, identity=identity, handle=handle)

tests/integration/cost_calculation/cost_tracking_case.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from types import MappingProxyType
 from typing import Annotated, Final, Literal, TypeAlias
 
-from pydantic import BaseModel, ConfigDict, Field, JsonValue
+from pydantic import BaseModel, ConfigDict, Field, JsonValue, field_validator, model_validator
 
 CASES_PATH: Final = Path(__file__).resolve().parent / "cost_tracking_cases.json"
 
@@ -25,6 +25,14 @@ class ProviderSpecificEntry(BaseModel):
     us: float | None = None
 
 
+class TieredPrice(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    range: tuple[float, float]
+    input_cost_per_token: float
+    output_cost_per_token: float
+
+
 class CostMapEntry(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
@@ -35,19 +43,36 @@ class CostMapEntry(BaseModel):
     max_output_tokens: int | None = None
     supports_function_calling: bool | None = None
     input_cost_per_token: float | None = None
+    input_cost_per_query: float | None = None
     output_cost_per_token: float | None = None
+    input_cost_per_token_batches: float | None = None
+    output_cost_per_token_batches: float | None = None
+    input_cost_per_token_above_128k_tokens: float | None = None
+    output_cost_per_token_above_128k_tokens: float | None = None
+    output_vector_size: int | None = None
+    input_cost_per_token_batches: float | None = None
     cache_read_input_token_cost: float | None = None
     cache_creation_input_token_cost: float | None = None
     cache_creation_input_token_cost_above_1hr: float | None = None
+    cache_creation_input_token_cost_above_1hr_above_200k_tokens: float | None = None
     cache_read_input_token_cost_above_200k_tokens: float | None = None
     cache_creation_input_token_cost_above_200k_tokens: float | None = None
-    output_cost_per_reasoning_token: float | None = None
-    input_cost_per_audio_token: float | None = None
-    output_cost_per_audio_token: float | None = None
-    input_cost_per_image_token: float | None = None
-    input_cost_per_video_token: float | None = None
     input_cost_per_token_above_200k_tokens: float | None = None
     output_cost_per_token_above_200k_tokens: float | None = None
+    cache_read_input_audio_token_cost: float | None = None
+    tiered_pricing: tuple[TieredPrice, ...] | None = None
+    output_cost_per_reasoning_token: float | None = None
+    input_cost_per_audio_token: float | None = None
+    input_cost_per_second: float | None = None
+    output_cost_per_second: float | None = None
+    input_cost_per_character: float | None = None
+    output_cost_per_character: float | None = None
+    input_cost_per_image: float | None = None
+    output_cost_per_image: float | None = None
+    output_cost_per_audio_token: float | None = None
+    input_cost_per_image_token: float | None = None
+    output_cost_per_image_token: float | None = None
+    input_cost_per_video_token: float | None = None
     input_cost_per_token_flex: float | None = None
     output_cost_per_token_flex: float | None = None
     input_cost_per_token_priority: float | None = None
@@ -64,6 +89,24 @@ class Deployment(BaseModel):
 
     model: str | None = None
     base_model: str | None = None
+    input_cost_per_token: float | None = None
+    output_cost_per_token: float | None = None
+
+
+class WavUpload(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["wav"]
+    seconds: float
+
+
+class PngUpload(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["png"]
+
+
+Upload: TypeAlias = Annotated[WavUpload | PngUpload, Field(discriminator="kind")]
 
 
 class JsonResponse(BaseModel):
@@ -71,6 +114,7 @@ class JsonResponse(BaseModel):
 
     content_type: Literal["application/json"]
     body: dict[str, JsonValue]
+    status: int = 200
 
 
 class SseResponse(BaseModel):
@@ -78,6 +122,7 @@ class SseResponse(BaseModel):
 
     content_type: Literal["text/event-stream"]
     frames: tuple[str, ...]
+    frame_delay_ms: int = Field(default=0, ge=0)
 
 
 class EventStreamEvent(BaseModel):
@@ -92,10 +137,41 @@ class EventStreamResponse(BaseModel):
 
     content_type: Literal["application/vnd.amazon.eventstream"]
     events: tuple[EventStreamEvent, ...]
+    framing: Literal["converse", "invoke"] = "converse"
+
+
+class BinaryResponse(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    content_type: Literal["audio/mpeg"]
+    length: int
+
+
+class TextResponse(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    content_type: Literal["application/jsonl"]
+    body: str
+    status: int = 200
+
+
+class RoutedResponse(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    content_type: Literal["application/x-routed"]
+    routes: dict[str, JsonResponse | TextResponse]
+
+
+class RealtimeResponse(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    content_type: Literal["application/x-realtime"]
+    events: tuple[dict[str, JsonValue], ...]
+    session_model: str | None = None
 
 
 StoredResponse: TypeAlias = Annotated[
-    JsonResponse | SseResponse | EventStreamResponse,
+    JsonResponse | SseResponse | EventStreamResponse | BinaryResponse | RoutedResponse | RealtimeResponse,
     Field(discriminator="content_type"),
 ]
 
@@ -108,6 +184,13 @@ class ExactExpected(BaseModel):
     output_cost: float
     prompt_tokens: int
     completion_tokens: int
+    cache_read_cost: float | None = None
+    cache_creation_cost: float | None = None
+    reasoning_cost: float | None = None
+    tool_usage_cost: float | None = None
+    breakdown_persisted: bool = True
+    cost_header: bool = True
+    rollups: bool = False
 
 
 class RecountRates(BaseModel):
@@ -121,9 +204,25 @@ class RecountExpected(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     recount: RecountRates
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    min_completion_tokens: int | None = None
+    max_completion_tokens: int | None = None
 
 
-Expected: TypeAlias = ExactExpected | RecountExpected
+class FailureDetails(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    status: int
+
+
+class FailureExpected(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    failure: FailureDetails
+
+
+Expected: TypeAlias = ExactExpected | RecountExpected | FailureExpected
 
 
 class CostTrackingTestCase(BaseModel):
@@ -132,10 +231,29 @@ class CostTrackingTestCase(BaseModel):
     name: str
     covers: str
     model: str
+    endpoint: (
+        Literal[
+            "/v1/chat/completions",
+            "/v1/responses",
+            "/v1/messages",
+            "/v1/embeddings",
+            "/v1/rerank",
+            "/v1/completions",
+            "/v1/moderations",
+            "/v1/audio/transcriptions",
+            "/v1/audio/speech",
+            "/v1/images/generations",
+            "/v1/images/edits",
+        ]
+        | Annotated[str, Field(pattern=r"^/(gemini|anthropic|bedrock)/")]
+    ) = "/v1/chat/completions"
     deployment: Deployment | None = None
+    upload: Upload | None = None
     request: dict[str, JsonValue]
     response: StoredResponse
     expected: Expected
+    fallback_from: StoredResponse | None = None
+    disconnect_after_frames: int | None = Field(default=None, ge=1)
 
     @property
     def rates(self) -> CostMapEntry:
@@ -146,16 +264,23 @@ class CostTrackingTestCase(BaseModel):
         provider: Final = self.rates.litellm_provider
         prefix: Final = (
             "openai"
-            if provider == "openai" and self.rates.mode == "chat"
+            if provider == "openai"
+            and (
+                self.endpoint == "/v1/responses"
+                or self.rates.mode
+                in {"chat", "embedding", "moderation", "audio_transcription", "audio_speech", "image_generation"}
+            )
             else "openai/responses"
             if provider == "openai"
             else _PROVIDER_PREFIXES.get(provider)
         )
         if prefix is None:
             raise ValueError(f"unsupported cost-map provider {provider} for {self.model}")
-        return self.deployment.model if self.deployment and self.deployment.model is not None else (
-            self.model if prefix == "" else f"{prefix}/{self.model}"
-        )
+        if self.deployment and self.deployment.model is not None:
+            return self.deployment.model
+        if prefix == "" or self.model.startswith(f"{prefix}/"):
+            return self.model
+        return f"{prefix}/{self.model}"
 
     @property
     def litellm_params(self) -> Mapping[str, str]:
@@ -169,28 +294,222 @@ class CostTrackingTestCase(BaseModel):
     def base_model(self) -> str | None:
         return self.deployment.base_model if self.deployment else None
 
+    @property
+    def passthrough_provider(self) -> Literal["gemini", "anthropic", "bedrock"] | None:
+        provider: Final = self.endpoint.removeprefix("/").split("/", 1)[0]
+        if provider == "gemini":
+            return "gemini"
+        if provider == "anthropic":
+            return "anthropic"
+        if provider == "bedrock":
+            return "bedrock"
+        return None
+
+    @property
+    def reports_provider_cost(self) -> bool:
+        if not isinstance(self.response, JsonResponse):
+            return False
+        usage: Final = self.response.body.get("usage")
+        return isinstance(usage, dict) and isinstance(usage.get("cost"), (int, float))
+
+
+class BatchOutputLine(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    status_code: int
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    cached_tokens: int | None = None
+
+    @field_validator("status_code")
+    @classmethod
+    def validate_status_code(cls, value: int) -> int:
+        if value != 200 and not 400 <= value <= 499:
+            raise ValueError("status_code must be 200 or a 4xx status")
+        return value
+
+    @model_validator(mode="after")
+    def validate_success_tokens(self) -> BatchOutputLine:
+        if self.status_code == 200 and (self.prompt_tokens is None or self.completion_tokens is None):
+            raise ValueError("successful batch output lines require prompt and completion tokens")
+        return self
+
+    def render(self, index: int, model: str, request_id: str) -> dict[str, JsonValue]:
+        if self.status_code != 200:
+            return {
+                "id": f"batch_req_{index}",
+                "custom_id": f"r{index}",
+                "response": None,
+                "error": {"code": "bad_request", "message": "failed"},
+            }
+        if self.prompt_tokens is None or self.completion_tokens is None:
+            raise ValueError("successful batch output lines require prompt and completion tokens")
+        usage: Final = {
+            "prompt_tokens": self.prompt_tokens,
+            "completion_tokens": self.completion_tokens,
+            "total_tokens": self.prompt_tokens + self.completion_tokens,
+            **(
+                {"prompt_tokens_details": {"cached_tokens": self.cached_tokens}}
+                if self.cached_tokens is not None
+                else {}
+            ),
+        }
+        return {
+            "id": f"batch_req_{index}",
+            "custom_id": f"r{index}",
+            "response": {
+                "status_code": 200,
+                "request_id": f"{request_id}-{index}",
+                "body": {
+                    "id": f"chatcmpl-{request_id}-{index}",
+                    "object": "chat.completion",
+                    "model": model,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {"role": "assistant", "content": "ok"},
+                            "finish_reason": "stop",
+                        }
+                    ],
+                    "usage": usage,
+                },
+            },
+            "error": None,
+        }
+
+
+class BatchCostCase(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str
+    covers: str
+    model: str
+    litellm_model: str
+    output_lines: tuple[BatchOutputLine, ...]
+    expected: ExactExpected
+
+    @property
+    def request_count(self) -> int:
+        return len(self.output_lines) or 2
+
+    @property
+    def completed_count(self) -> int:
+        return sum(line.status_code == 200 for line in self.output_lines)
+
+    @property
+    def failed_count(self) -> int:
+        return self.request_count - self.completed_count
+
+
+class RealtimeTurn(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    input_tokens: int
+    output_tokens: int
+    input_text_tokens: int
+    input_audio_tokens: int
+    input_cached_tokens: int
+    output_text_tokens: int
+    output_audio_tokens: int
+
+    @model_validator(mode="after")
+    def validate_token_totals(self) -> RealtimeTurn:
+        if self.input_text_tokens + self.input_audio_tokens != self.input_tokens:
+            raise ValueError("input text and audio tokens must equal input_tokens")
+        if self.output_text_tokens + self.output_audio_tokens != self.output_tokens:
+            raise ValueError("output text and audio tokens must equal output_tokens")
+        if self.input_cached_tokens > self.input_text_tokens:
+            raise ValueError("input_cached_tokens must not exceed input_text_tokens")
+        return self
+
+    def render(self, index: int, request_id: str) -> dict[str, JsonValue]:
+        return {
+            "type": "response.done",
+            "event_id": f"evt_{request_id}_{index}",
+            "response": {
+                "id": f"resp_{request_id}_{index}",
+                "object": "realtime.response",
+                "status": "completed",
+                "output": [],
+                "usage": {
+                    "total_tokens": self.input_tokens + self.output_tokens,
+                    "input_tokens": self.input_tokens,
+                    "output_tokens": self.output_tokens,
+                    "input_token_details": {
+                        "text_tokens": self.input_text_tokens,
+                        "audio_tokens": self.input_audio_tokens,
+                        "cached_tokens": self.input_cached_tokens,
+                        "cached_tokens_details": {
+                            "text_tokens": self.input_cached_tokens,
+                            "audio_tokens": 0,
+                        },
+                    },
+                    "output_token_details": {
+                        "text_tokens": self.output_text_tokens,
+                        "audio_tokens": self.output_audio_tokens,
+                    },
+                },
+            },
+        }
+
+
+class RealtimeCostCase(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str
+    covers: str
+    model: str
+    litellm_model: str
+    turns: tuple[RealtimeTurn, ...] = Field(min_length=0)
+    session_model: str | None = None
+    expected: ExactExpected
+
 
 class _CasesFile(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     cost_map: dict[str, CostMapEntry]
     cases: tuple[CostTrackingTestCase, ...]
+    batch_cases: tuple[BatchCostCase, ...] = ()
+    realtime_cases: tuple[RealtimeCostCase, ...] = ()
 
 
 _PROVIDER_PREFIXES: Final[Mapping[str, str]] = MappingProxyType(
     {
         "anthropic": "anthropic",
+        "bedrock": "bedrock",
         "bedrock_converse": "bedrock/converse",
+        "deepgram": "deepgram",
+        "text-completion-openai": "text-completion-openai",
+        "cohere": "cohere",
         "vertex_ai-language-models": "vertex_ai",
+        "vertex_ai-image-models": "vertex_ai",
+        "vertex_ai-embedding-models": "vertex_ai",
         "gemini": "",
         "together_ai": "",
         "fireworks_ai": "",
         "azure": "",
+        "dashscope": "",
+        "openrouter": "",
+        "perplexity": "",
+        "deepseek": "",
+        "xai": "",
+        "azure_ai": "azure_ai",
+        "groq": "groq",
+        "mistral": "mistral",
+        "cohere_chat": "cohere_chat",
     }
 )
 _LITELLM_PARAMS: Final[Mapping[str, Mapping[str, str]]] = MappingProxyType(
     {
         "anthropic": MappingProxyType({}),
+        "bedrock": MappingProxyType(
+            {
+                "aws_access_key_id": "AKIASCRIPTEDPROVIDER",
+                "aws_secret_access_key": "scripted-secret",
+                "aws_region_name": "us-east-1",
+            }
+        ),
         "bedrock_converse": MappingProxyType(
             {
                 "aws_access_key_id": "AKIASCRIPTEDPROVIDER",
@@ -198,32 +517,57 @@ _LITELLM_PARAMS: Final[Mapping[str, Mapping[str, str]]] = MappingProxyType(
                 "aws_region_name": "us-east-1",
             }
         ),
+        "deepgram": MappingProxyType({}),
+        "text-completion-openai": MappingProxyType({}),
+        "cohere": MappingProxyType({}),
         "vertex_ai-language-models": MappingProxyType(
             {"vertex_project": "cc-scripted-project", "vertex_location": "us-central1"}
         ),
+        "vertex_ai-image-models": MappingProxyType(
+            {"vertex_project": "cc-scripted-project", "vertex_location": "us-central1"}
+        ),
+        "vertex_ai-embedding-models": MappingProxyType(
+            {"vertex_project": "cc-scripted-project", "vertex_location": "us-central1"}
+        ),
         "gemini": MappingProxyType({}),
         "together_ai": MappingProxyType({}),
         "fireworks_ai": MappingProxyType({}),
         "azure": MappingProxyType({"api_version": "2025-04-01-preview"}),
         "openai": MappingProxyType({}),
+        "dashscope": MappingProxyType({}),
+        "openrouter": MappingProxyType({}),
+        "perplexity": MappingProxyType({}),
+        "deepseek": MappingProxyType({}),
+        "xai": MappingProxyType({}),
+        "azure_ai": MappingProxyType({}),
+        "groq": MappingProxyType({}),
+        "mistral": MappingProxyType({}),
+        "cohere_chat": MappingProxyType({}),
     }
 )
 
 _LOADED: Final = _CasesFile.model_validate_json(CASES_PATH.read_bytes())
 COST_MAP: Final[Mapping[str, CostMapEntry]] = MappingProxyType(dict(_LOADED.cost_map))
 CASES: Final[tuple[CostTrackingTestCase, ...]] = _LOADED.cases
-_LITELLM_MODELS: Final = tuple(case.litellm_model for case in CASES)
+BATCH_CASES: Final[tuple[BatchCostCase, ...]] = _LOADED.batch_cases
+REALTIME_CASES: Final[tuple[RealtimeCostCase, ...]] = _LOADED.realtime_cases
+_ALL_CASES: Final = CASES + BATCH_CASES + REALTIME_CASES
+_LITELLM_MODELS: Final = tuple(case.litellm_model for case in _ALL_CASES)
 
 
 def data_errors() -> tuple[str, ...]:
-    case_models: Final = frozenset(case.model for case in CASES)
-    unknown_models: Final = sorted(case.model for case in CASES if case.model not in COST_MAP)
+    case_models: Final = frozenset(case.model for case in _ALL_CASES) | frozenset(
+        case.session_model for case in REALTIME_CASES if case.session_model is not None
+    )
+    unknown_models: Final = sorted(model for model in case_models if model not in COST_MAP)
     missing_cases: Final = sorted(model for model in COST_MAP if model not in case_models)
     duplicate_names: Final = sorted(
-        name for name in {case.name for case in CASES} if sum(case.name == name for case in CASES) > 1
+        name for name in {case.name for case in _ALL_CASES} if sum(case.name == name for case in _ALL_CASES) > 1
     )
     input_rates: Final = tuple(
-        (entry.input_cost_per_token, model) for model, entry in COST_MAP.items()
+        (entry.input_cost_per_token, model)
+        for model, entry in COST_MAP.items()
+        if entry.mode != "realtime"
     )
     shared_input_rates: Final = sorted(
         f"{rate}: {tuple(model for value, model in input_rates if value == rate)}"
@@ -240,6 +584,103 @@ def data_errors() -> tuple[str, ...]:
             or case.expected.recount.output_cost_per_token != (COST_MAP[case.model].output_cost_per_token or 0.0)
         )
     )
+    component_mismatches: Final = sorted(
+        case.name
+        for case in CASES
+        if isinstance(case.expected, ExactExpected)
+        and any(
+            component is not None
+            for component in (
+                case.expected.cache_read_cost,
+                case.expected.cache_creation_cost,
+                case.expected.reasoning_cost,
+                case.expected.tool_usage_cost,
+            )
+        )
+        and (
+            (case.expected.cache_read_cost or 0.0) + (case.expected.cache_creation_cost or 0.0)
+            > case.expected.input_cost
+            or (case.expected.reasoning_cost or 0.0) > case.expected.output_cost
+            or not _approx_equal(
+                case.expected.input_cost
+                + case.expected.output_cost
+                + (case.expected.tool_usage_cost or 0.0),
+                case.expected.spend,
+            )
+        )
+    )
+    failure_response_mismatches: Final = sorted(
+        case.name
+        for case in CASES
+        if (
+            isinstance(case.expected, FailureExpected)
+            and (
+                not isinstance(case.response, JsonResponse)
+                or not 400 <= case.response.status <= 599
+                or not 400 <= case.expected.failure.status <= 599
+            )
+        )
+        or (
+            not isinstance(case.expected, FailureExpected)
+            and isinstance(case.response, JsonResponse)
+            and case.response.status != 200
+        )
+    )
+    invalid_opt_outs: Final = sorted(
+        case.name
+        for case in CASES
+        if isinstance(case.expected, ExactExpected)
+        and (
+            (
+                not case.expected.breakdown_persisted
+                and case.passthrough_provider is None
+                and case.rates.mode != "image_generation"
+                and not case.reports_provider_cost
+            )
+            or (
+                not case.expected.cost_header
+                and case.passthrough_provider is None
+                and not isinstance(case.response, SseResponse)
+                and case.expected.spend != 0.0
+            )
+        )
+    )
+    invalid_fallbacks: Final = sorted(
+        case.name
+        for case in CASES
+        if case.fallback_from is not None
+        and (
+            not isinstance(case.fallback_from, JsonResponse)
+            or not 400 <= case.fallback_from.status <= 599
+        )
+    )
+    invalid_disconnects: Final = sorted(
+        case.name
+        for case in CASES
+        if case.disconnect_after_frames is not None
+        and (
+            not isinstance(case.response, SseResponse)
+            or case.response.frame_delay_ms <= 0
+            or not isinstance(case.expected, RecountExpected)
+        )
+    )
+    invalid_rollup_ids: Final = sorted(
+        case.name
+        for case in CASES
+        if isinstance(case.expected, ExactExpected)
+        and case.expected.rollups
+        and "$UNIQUE_ID" not in case.response.model_dump_json()
+    )
+    invalid_pinned_tool_ids: Final = sorted(
+        case.name
+        for case in CASES
+        if isinstance(case.expected, RecountExpected)
+        and (case.expected.prompt_tokens is not None or case.expected.completion_tokens is not None)
+        and any(
+            marker in case.response.model_dump_json()
+            for marker in ('"id": "call_$REQUEST_ID"', '"id": "toolu_$REQUEST_ID"')
+        )
+    )
     return tuple(
         message
         for message in (
@@ -248,6 +689,21 @@ def data_errors() -> tuple[str, ...]:
             f"duplicate case names: {duplicate_names}" if duplicate_names else None,
             f"cost-map entries share input_cost_per_token: {shared_input_rates}" if shared_input_rates else None,
             f"recount rates differ from cost-map rates: {recount_mismatches}" if recount_mismatches else None,
+            f"breakdown components are inconsistent: {component_mismatches}" if component_mismatches else None,
+            f"failure response statuses are inconsistent: {failure_response_mismatches}"
+            if failure_response_mismatches
+            else None,
+            f"invalid passthrough opt-outs: {invalid_opt_outs}" if invalid_opt_outs else None,
+            f"invalid fallback responses: {invalid_fallbacks}" if invalid_fallbacks else None,
+            f"invalid disconnect cases: {invalid_disconnects}" if invalid_disconnects else None,
+            f"rollup responses lack $UNIQUE_ID: {invalid_rollup_ids}" if invalid_rollup_ids else None,
+            f"pinned tool IDs contain $REQUEST_ID: {invalid_pinned_tool_ids}"
+            if invalid_pinned_tool_ids
+            else None,
         )
         if message is not None
     )
+
+
+def _approx_equal(actual: float, expected: float) -> bool:
+    return abs(actual - expected) <= max(1e-9, abs(expected) * 1e-2)

tests/integration/cost_calculation/test_batch_realtime_cost.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+from hashlib import sha256
+from typing import Final
+
+import pytest
+import websockets
+from integration._support.client import JSON_OBJECT, Gateway, Scenario, object_value, string_value
+from integration._support.upstream import delete_scenario, register_scenario
+from integration.cost_calculation.assertions import assert_exact
+from integration.cost_calculation.conftest import poll_rows, poll_rows_where, read_rows_now
+from integration.cost_calculation.cost_tracking_case import (
+    BATCH_CASES,
+    REALTIME_CASES,
+    BatchCostCase,
+    JsonResponse,
+    RealtimeCostCase,
+    RealtimeResponse,
+    RoutedResponse,
+    TextResponse,
+)
+from pydantic import JsonValue
+
+
+def _register_deployment(
+    scenario: Scenario,
+    litellm_model: str,
+    response: JsonResponse | TextResponse | RealtimeResponse,
+    marker: str,
+    *,
+    realtime: bool,
+) -> tuple[str, str]:
+    scenario_id: Final = f"cost-{marker}-{sha256(os.urandom(16)).hexdigest()[:12]}"
+    handle: Final = register_scenario(scenario_id, response)
+    scenario.cleanups.callback(delete_scenario, handle)
+    control_url: Final = os.environ["INTEGRATION_UPSTREAM_URL"].rstrip("/")
+    created: Final = scenario.gateway.post(
+        "/model/new",
+        JSON_OBJECT.validate_python(
+            {
+                "model_name": f"cost-{marker}-{sha256(scenario_id.encode()).hexdigest()[:12]}",
+                "litellm_params": {
+                    "model": litellm_model,
+                    "api_key": scenario_id if realtime else "sk-scripted-provider",
+                    "api_base": control_url if realtime else handle.api_base(),
+                },
+            }
+        ),
+    )
+    identity: Final = string_value(object_value(created["model_info"])["id"])
+    scenario.cleanups.callback(scenario.delete_model, identity)
+    return string_value(created["model_name"]), identity
+
+
+def _batch_response(case: BatchCostCase) -> JsonResponse | RoutedResponse:
+    request_id: Final = "$REQUEST_ID"
+    lines: Final = tuple(
+        json.dumps(line.render(index, case.model, request_id), separators=(",", ":"))
+        for index, line in enumerate(case.output_lines, start=1)
+    )
+    counts: Final = {
+        "total": case.request_count,
+        "completed": case.completed_count,
+        "failed": case.failed_count,
+    }
+    has_output: Final = any(line.status_code == 200 for line in case.output_lines)
+    has_failed: Final = any(line.status_code != 200 for line in case.output_lines)
+    batch: Final = {
+        "id": "batch-$REQUEST_ID",
+        "object": "batch",
+        "endpoint": "/v1/chat/completions",
+        "errors": None,
+        "input_file_id": "file-in-$REQUEST_ID",
+        "completion_window": "24h",
+        "status": "completed",
+        "output_file_id": "file-out-$REQUEST_ID" if has_output else None,
+        "error_file_id": "file-err-$REQUEST_ID" if has_failed else None,
+        "created_at": 1,
+        "in_progress_at": 1,
+        "completed_at": 1,
+        "expires_at": 1,
+        "request_counts": counts,
+        "metadata": None,
+    }
+    routes: Final = {
+        "POST /files": JsonResponse(
+            content_type="application/json",
+            body={
+                "id": "file-in-$REQUEST_ID",
+                "object": "file",
+                "purpose": "batch",
+                "bytes": 100,
+                "created_at": 1,
+                "filename": "in.jsonl",
+                "status": "processed",
+            },
+        ),
+        "POST /batches": JsonResponse(
+            content_type="application/json",
+            body={
+                **batch,
+                "status": "validating",
+                "output_file_id": None,
+                "error_file_id": None,
+            },
+        ),
+        "GET /batches/batch-$REQUEST_ID": JsonResponse(
+            content_type="application/json",
+            body=batch,
+        ),
+        **(
+            {
+                "GET /files/file-out-$REQUEST_ID/content": TextResponse(
+                    content_type="application/jsonl",
+                    body="\n".join(lines) + ("\n" if lines else ""),
+                )
+            }
+            if has_output
+            else {}
+        ),
+    }
+    return RoutedResponse(
+        content_type="application/x-routed",
+        routes=routes,
+    )
+
+
+def _batch_input_lines(case: BatchCostCase, model_name: str) -> bytes:
+    count: Final = case.request_count
+    return (
+        "\n".join(
+            json.dumps(
+                {
+                    "custom_id": f"r{index}",
+                    "method": "POST",
+                    "url": "/v1/chat/completions",
+                    "body": {
+                        "model": model_name,
+                        "messages": [{"role": "user", "content": "batch integration"}],
+                    },
+                },
+                separators=(",", ":"),
+            )
+            for index in range(1, count + 1)
+        )
+        + "\n"
+    ).encode()
+
+
+@pytest.mark.parametrize(
+    "case",
+    tuple(pytest.param(case, marks=pytest.mark.covers(case.covers), id=case.name) for case in BATCH_CASES),
+)
+def test_batch_costs(gateway: Gateway, case: BatchCostCase) -> None:
+    with gateway.scenario() as scenario:
+        key: Final = scenario.key()
+        model_name, identity = _register_deployment(
+            scenario,
+            case.litellm_model,
+            _batch_response(case),
+            case.name,
+            realtime=False,
+        )
+        file_response: Final = gateway.request_multipart(
+            "/v1/files",
+            {"purpose": "batch", "model": model_name},
+            {"file": ("in.jsonl", _batch_input_lines(case, model_name), "application/jsonl")},
+            key=key,
+        )
+        assert file_response.is_success, file_response.text
+        file_body: Final = JSON_OBJECT.validate_json(file_response.content)
+        batch_response: Final = gateway.request(
+            "POST",
+            "/v1/batches",
+            {
+                "input_file_id": string_value(file_body["id"]),
+                "endpoint": "/v1/chat/completions",
+                "completion_window": "24h",
+                "model": model_name,
+            },
+            key=key,
+        )
+        assert batch_response.is_success, batch_response.text
+        batch_body: Final = JSON_OBJECT.validate_json(batch_response.content)
+        batch_id: Final = string_value(batch_body["id"])
+        first_retrieval: Final = gateway.request("GET", f"/v1/batches/{batch_id}", key=key)
+        second_retrieval: Final = gateway.request("GET", f"/v1/batches/{batch_id}", key=key)
+        assert first_retrieval.is_success, first_retrieval.text
+        assert second_retrieval.is_success, second_retrieval.text
+        retrieval_rows: Final = poll_rows_where(key, 1, lambda row: row.call_type == "aretrieve_batch")
+        assert len(retrieval_rows) == 1
+        rows: Final = read_rows_now(key)
+        assert all(row.spend == 0.0 for row in rows if row.call_type != "aretrieve_batch")
+        row: Final = retrieval_rows[0]
+        assert row.status == "success"
+        assert row.call_type == "aretrieve_batch"
+        assert row.model_id == identity
+        assert_exact(case.name, "application/json", case.expected, row, second_retrieval)
+        time.sleep(3)
+        assert len(tuple(row for row in read_rows_now(key) if row.call_type == "aretrieve_batch")) == 1
+
+
+def _realtime_response(case: RealtimeCostCase) -> RealtimeResponse:
+    return RealtimeResponse(
+        content_type="application/x-realtime",
+        session_model=case.session_model,
+        events=tuple(turn.render(index, "$REQUEST_ID") for index, turn in enumerate(case.turns, start=1)),
+    )
+
+
+async def _run_realtime(url: str, key: str, model_name: str, turn_count: int) -> dict[str, JsonValue]:
+    async with websockets.connect(
+        f"{url.replace('http://', 'ws://').replace('https://', 'wss://')}/v1/realtime?model={model_name}",
+        additional_headers={"Authorization": f"Bearer {key}"},
+    ) as websocket:
+        session: Final = JSON_OBJECT.validate_json(await websocket.recv())
+        for _ in range(turn_count):
+            await websocket.send(json.dumps({"type": "response.create"}))
+            while True:
+                event: Final = JSON_OBJECT.validate_json(await websocket.recv())
+                if event.get("type") == "response.done":
+                    break
+        return session
+
+
+@pytest.mark.parametrize(
+    "case",
+    tuple(pytest.param(case, marks=pytest.mark.covers(case.covers), id=case.name) for case in REALTIME_CASES),
+)
+def test_realtime_costs(gateway: Gateway, case: RealtimeCostCase) -> None:
+    with gateway.scenario() as scenario:
+        key: Final = scenario.key()
+        model_name, identity = _register_deployment(
+            scenario,
+            case.litellm_model,
+            _realtime_response(case),
+            case.name,
+            realtime=True,
+        )
+        session: Final = asyncio.run(
+            _run_realtime(
+                os.environ["INTEGRATION_PROXY_URL"].rstrip("/"),
+                key,
+                model_name,
+                len(case.turns),
+            )
+        )
+        session_model: Final = object_value(session["session"])["model"]
+        assert session_model == (case.session_model or case.model)
+        row: Final = poll_rows(key, 1)[0]
+        assert row.status == "success"
+        assert row.call_type == "_arealtime"
+        assert row.model_id == identity
+        assert_exact(case.name, "application/json", case.expected, row, None)

tests/integration/cost_calculation/test_cost_tracking.py

@@ -2,25 +2,41 @@
 
 from __future__ import annotations
 
+import io
+import json
+import struct
+import time
+import uuid
+import wave
+import zlib
 from hashlib import sha256
+from itertools import islice
 from typing import Final, cast
 
+import httpx
 import pytest
-
 from integration._support.client import JSON_OBJECT, Gateway
+from integration._support.upstream import delete_scenario, register_scenario
+from integration.cost_calculation.assertions import assert_exact, assert_recount
 from integration.cost_calculation.conftest import (
     approx_equal,
-    assert_total_is_sum_of_components,
     poll_cost_row,
+    poll_failure_row,
+    poll_rollups,
+    poll_rows,
+    read_rows_now,
     register_scenario_deployment,
 )
 from integration.cost_calculation.cost_tracking_case import (
     CASES,
+    BinaryResponse,
     CostTrackingTestCase,
     ExactExpected,
+    FailureExpected,
     RecountExpected,
     data_errors,
 )
+from pydantic import JsonValue
 
 if _data_errors := data_errors():
     raise ValueError("\n".join(_data_errors))
@@ -32,6 +48,47 @@ _CASES: Final = tuple(
 )
 
 
+def _wav_bytes(seconds: float) -> bytes:
+    frame_count: Final = round(16000 * seconds)
+    output: Final = io.BytesIO()
+    with wave.open(output, "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(16000)
+        wav.writeframes(b"\x00\x00" * frame_count)
+    return output.getvalue()
+
+
+def _png_bytes() -> bytes:
+    def chunk(kind: bytes, payload: bytes) -> bytes:
+        return (
+            struct.pack(">I", len(payload))
+            + kind
+            + payload
+            + struct.pack(">I", zlib.crc32(kind + payload) & 0xFFFFFFFF)
+        )
+
+    return (
+        b"\x89PNG\r\n\x1a\n"
+        + chunk(b"IHDR", struct.pack(">IIBBBBB", 1, 1, 8, 6, 0, 0, 0))
+        + chunk(b"IDAT", zlib.compress(b"\x00\x00\x00\x00\x00"))
+        + chunk(b"IEND", b"")
+    )
+
+
+def _multipart_request(gateway: Gateway, case: CostTrackingTestCase, model_name: str, key: str) -> httpx.Response:
+    assert case.upload is not None
+    fields: Final = {
+        field: value if isinstance(value, str) else json.dumps(value, separators=(",", ":"))
+        for field, value in {**case.request, "model": model_name}.items()
+    }
+    if case.upload.kind == "wav":
+        files: Final = {"file": ("audio.wav", _wav_bytes(case.upload.seconds), "audio/wav")}
+    else:
+        files = {"image": ("image.png", _png_bytes(), "image/png")}
+    return gateway.request_multipart(case.endpoint, fields, files, key=key)
+
+
 def _assert_stream_has_no_error(response_text: str) -> None:
     for line in response_text.splitlines():
         if not line.startswith("data:"):
@@ -40,62 +97,212 @@ def _assert_stream_has_no_error(response_text: str) -> None:
         if payload == "[DONE]":
             continue
         parsed = JSON_OBJECT.validate_json(payload)
-        assert "error" not in parsed, f"stream carried an error event: {parsed}"
+        assert (
+            "error" not in parsed and parsed.get("type") not in {"error", "response.failed"}
+        ), f"stream carried an error event: {parsed}"
+
+
+def _replace_model(value: JsonValue, model_name: str) -> JsonValue:
+    if isinstance(value, str):
+        return value.replace("$MODEL", model_name)
+    if isinstance(value, list):
+        return [_replace_model(item, model_name) for item in value]
+    if isinstance(value, dict):
+        return {key: _replace_model(item, model_name) for key, item in value.items()}
+    return value
 
 
 @pytest.mark.parametrize("case", _CASES)
 def test_case_bills_expected_cost(gateway: Gateway, case: CostTrackingTestCase) -> None:
     marker: Final = sha256(case.name.encode()).hexdigest()[:12]
     with gateway.scenario() as scenario:
-        key: Final = scenario.key()
-        model_name: Final = register_scenario_deployment(scenario, case, marker, key)
-        response: Final = gateway.request(
-            "POST",
-            "/v1/chat/completions",
-            {**case.request, "model": model_name},
-            key=key,
+        expected: Final = case.expected
+        team_id: Final = scenario.team() if isinstance(expected, ExactExpected) and expected.rollups else None
+        user_id: Final = (
+            scenario.user(team_id=team_id)
+            if team_id is not None
+            else None
         )
+        key: Final = (
+            scenario.key(team_id=team_id, user_id=user_id)
+            if team_id is not None and user_id is not None
+            else scenario.key()
+        )
+        passthrough_provider: Final = case.passthrough_provider
+        scenario_id: Final = f"sc-{marker}-{sha256(key.encode()).hexdigest()[:12]}"
+        scenario_handle: Final = (
+            register_scenario(scenario_id, case.response)
+            if passthrough_provider in {"gemini", "anthropic"}
+            else None
+        )
+        if scenario_handle is not None:
+            scenario.cleanups.callback(delete_scenario, scenario_handle)
+        deployment: Final = (
+            register_scenario_deployment(scenario, case, marker, key)
+            if passthrough_provider not in {"gemini", "anthropic"}
+            else None
+        )
+        fallback_deployment: Final = (
+            register_scenario_deployment(
+                scenario,
+                case,
+                marker,
+                key,
+                response=case.fallback_from,
+                marker_suffix="-fb",
+            )
+            if case.fallback_from is not None
+            else None
+        )
+        model_name: Final = (
+            case.model
+            if passthrough_provider in {"gemini", "anthropic"}
+            else deployment.model_name if deployment is not None else None
+        )
+        assert model_name is not None
+        request_model: Final = (
+            case.model.rsplit("/", 1)[-1]
+            if passthrough_provider in {"gemini", "anthropic"}
+            else fallback_deployment.model_name if fallback_deployment is not None else model_name
+        )
+        base_request_values: Final = (
+            _replace_model(case.request, request_model)
+            if passthrough_provider is not None
+            else {**case.request, "model": model_name}
+        )
+        end_user_id: Final = (
+            f"end-user-{uuid.uuid4()}"
+            if isinstance(expected, ExactExpected) and expected.rollups
+            else None
+        )
+        request_body: Final = JSON_OBJECT.validate_python(
+            {
+                **base_request_values,
+                **(
+                    {"model": fallback_deployment.model_name, "fallbacks": [model_name]}
+                    if fallback_deployment is not None
+                    else {}
+                ),
+                **(
+                    {"user": end_user_id, "cache": {"no-cache": True}}
+                    if end_user_id is not None
+                    else {}
+                ),
+            }
+        )
+        request_headers: Final = (
+            {
+                "x-pass-x-scripted-scenario": scenario_id,
+                **(
+                    {"x-goog-api-key": key}
+                    if passthrough_provider == "gemini"
+                    else {}
+                ),
+            }
+            if passthrough_provider is not None
+            else {}
+        )
+        request_path: Final = (
+            case.endpoint.replace("$MODEL", request_model)
+            if passthrough_provider is not None
+            else case.endpoint
+        )
+        if case.disconnect_after_frames is not None:
+            with gateway.client.stream(
+                "POST",
+                request_path,
+                json=request_body,
+                headers={"Authorization": f"Bearer {key}", **request_headers},
+            ) as stream_response:
+                frames: Final = tuple(
+                    islice(
+                        (line for line in stream_response.iter_lines() if line.startswith("data:")),
+                        case.disconnect_after_frames,
+                    )
+                )
+                assert len(frames) == case.disconnect_after_frames
+            row: Final = poll_cost_row(key)
+            assert isinstance(expected, RecountExpected)
+            assert row.status == "success", f"{case.name}: disconnect row status was {row.status}"
+            assert_recount(case.name, expected, row)
+            return
+        responses: Final = tuple(
+            (
+                _multipart_request(gateway, case, model_name, key)
+                if case.upload is not None
+                else gateway.request("POST", request_path, request_body, key=key, headers=request_headers)
+            )
+            for _ in range(3 if isinstance(expected, ExactExpected) and expected.rollups else 1)
+        )
+        response: Final = responses[0]
+        if isinstance(expected, FailureExpected):
+            assert response.status_code == case.expected.failure.status, (
+                f"{case.name}: proxy returned {response.status_code}, expected {case.expected.failure.status}: "
+                f"{response.text[:400]}"
+            )
+            response_cost: Final = response.headers.get("x-litellm-response-cost")
+            assert response_cost is None or approx_equal(float(response_cost), 0.0), (
+                f"{case.name}: failure response cost was {response_cost}"
+            )
+            row: Final = poll_failure_row(key)
+            assert row.spend == 0, f"{case.name}: failure spend was {row.spend}"
+            return
         assert response.is_success, f"{case.name}: proxy returned {response.status_code}: {response.text[:400]}"
         if case.response.content_type == "text/event-stream":
             _assert_stream_has_no_error(response.text)
-        row: Final = poll_cost_row(key)
-        if isinstance(case.expected, RecountExpected):
-            assert row.prompt_tokens is not None and row.prompt_tokens > 0, (
-                f"{case.name}: recount case counted no input tokens: prompt_tokens={row.prompt_tokens}"
-            )
-            assert row.completion_tokens is not None and row.completion_tokens > 0, (
-                f"{case.name}: recount case counted no output tokens: completion_tokens={row.completion_tokens}"
-            )
-            recount: Final = row.prompt_tokens * case.expected.recount.input_cost_per_token + (
-                row.completion_tokens * case.expected.recount.output_cost_per_token
-            )
-            assert row.spend is not None and approx_equal(row.spend, recount), (
-                f"{case.name}: spend {row.spend} != recount {recount} at map rates"
-            )
-            assert_total_is_sum_of_components(row, case.name)
+        rows: Final = poll_rows(key, len(responses))
+        if isinstance(expected, RecountExpected):
+            row: Final = rows[0]
+            assert_recount(case.name, expected, row)
             return
-        expected: Final = case.expected
         assert isinstance(expected, ExactExpected)
-        if case.response.content_type == "application/json":
+        if fallback_deployment is not None:
+            assert deployment is not None
+            time.sleep(3)
+            settled_rows: Final = read_rows_now(key)
+            assert len(settled_rows) == 1
+            assert settled_rows[0].status == "success"
+            assert settled_rows[0].model_id == deployment.identity
+        if isinstance(case.response, BinaryResponse):
+            header: Final = response.headers.get("x-litellm-response-cost")
+            if header is not None:
+                assert approx_equal(float(header), expected.spend), (
+                    f"{case.name}: x-litellm-response-cost {header} != expected {expected.spend}"
+                )
+        elif case.response.content_type == "application/json":
             header: Final = cast(str | None, response.headers.get("x-litellm-response-cost"))
-            assert header is not None and approx_equal(float(header), expected.spend), (
-                f"{case.name}: x-litellm-response-cost {header} != expected {expected.spend}"
+            if expected.cost_header and expected.spend != 0:
+                assert header is not None and approx_equal(float(header), expected.spend), (
+                    f"{case.name}: x-litellm-response-cost {header} != expected {expected.spend}"
+                )
+            elif header is not None:
+                assert approx_equal(float(header), expected.spend), (
+                    f"{case.name}: x-litellm-response-cost {header} != expected {expected.spend}"
+                )
+        for row in rows:
+            assert_exact(case.name, case.response.content_type, expected, row, response)
+        if expected.rollups:
+            assert deployment is not None and team_id is not None and user_id is not None
+            assert end_user_id is not None
+            target_spend: Final = expected.spend * 3
+            target_requests: Final = 3
+            rollups: Final = poll_rollups(
+                key,
+                team_id,
+                user_id,
+                end_user_id,
+                target_spend,
+                target_requests,
             )
-        assert row.spend is not None and approx_equal(row.spend, expected.spend), (
-            f"{case.name}: spend {row.spend} != expected {expected.spend} "
-            f"(breakdown {row.breakdown.model_dump()})"
-        )
-        breakdown: Final = row.breakdown
-        assert breakdown.input_cost is not None and approx_equal(breakdown.input_cost, expected.input_cost), (
-            f"{case.name}: input_cost {breakdown.input_cost} != expected {expected.input_cost}"
-        )
-        assert breakdown.output_cost is not None and approx_equal(breakdown.output_cost, expected.output_cost), (
-            f"{case.name}: output_cost {breakdown.output_cost} != expected {expected.output_cost}"
-        )
-        assert row.prompt_tokens == expected.prompt_tokens, (
-            f"{case.name}: prompt_tokens {row.prompt_tokens} != expected {expected.prompt_tokens}"
-        )
-        assert row.completion_tokens == expected.completion_tokens, (
-            f"{case.name}: completion_tokens {row.completion_tokens} != expected {expected.completion_tokens}"
-        )
-        assert_total_is_sum_of_components(row, case.name)
+            assert approx_equal(rollups.key_spend, target_spend)
+            assert approx_equal(rollups.team_spend, target_spend)
+            assert approx_equal(rollups.user_spend, target_spend)
+            assert approx_equal(rollups.end_user_spend, target_spend)
+            assert approx_equal(rollups.daily_user.spend, target_spend)
+            assert approx_equal(rollups.daily_team.spend, target_spend)
+            assert rollups.daily_user.prompt_tokens == expected.prompt_tokens * 3
+            assert rollups.daily_user.completion_tokens == expected.completion_tokens * 3
+            assert rollups.daily_user.api_requests == 3
+            assert rollups.daily_team.prompt_tokens == expected.prompt_tokens * 3
+            assert rollups.daily_team.completion_tokens == expected.completion_tokens * 3
+            assert rollups.daily_team.api_requests == 3

tests/integration/providers/test_fal_ai_video_wire.py

@@ -66,6 +66,7 @@ def test_fal_video_create_status_and_content_follow_queue_wire_contract(gateway:
             ("POST", f"/{_MODEL}"),
             ("GET", f"/bytedance/seedance-2.5/requests/{request_id}/status"),
             ("GET", f"/bytedance/seedance-2.5/requests/{request_id}"),
+            ("GET", f"/bytedance/seedance-2.5/requests/{request_id}"),
             ("GET", f"/files/{request_id}.mp4"),
         ]
 
@@ -119,5 +120,57 @@ def test_fal_h3_video_create_uses_canonical_body_and_status_path(gateway: Gatewa
             ("POST", f"/{_H3_MODEL}"),
             ("GET", f"/minimax/h3/requests/{request_id}/status"),
             ("GET", f"/minimax/h3/requests/{request_id}"),
+            ("GET", f"/minimax/h3/requests/{request_id}"),
             ("GET", f"/files/{request_id}.mp4"),
         ]
+
+
+@pytest.mark.covers("other.provider_wire.fal_ai.video_failed_result_surfaces_fal_error")
+def test_fal_video_failed_result_reports_failed_status_and_fal_error(gateway: Gateway) -> None:
+    request_id: Final = "fal-failed-req-" + uuid.uuid4().hex
+    error_body: Final = {
+        "detail": [
+            {
+                "loc": ["body", "input.reference_image_urls"],
+                "msg": "Failed to download the file. Please check if the URL is accessible and try again.",
+                "type": "file_download_error",
+            }
+        ]
+    }
+
+    def respond(request: Request) -> Reply:
+        assert request.headers["authorization"] == "Key synthetic-fal-key"
+        if request.method == "POST":
+            assert request.target == f"/{_MODEL}"
+            return Reply(
+                body=json.dumps({"status": "IN_QUEUE", "request_id": request_id, "queue_position": 0}).encode()
+            )
+        assert request.method == "GET"
+        if request.target == f"/bytedance/seedance-2.5/requests/{request_id}/status":
+            return Reply(body=json.dumps({"status": "COMPLETED", "request_id": request_id}).encode())
+        assert request.target == f"/bytedance/seedance-2.5/requests/{request_id}"
+        return Reply(status=422, body=json.dumps(error_body).encode())
+
+    with wire_server(respond) as wire, gateway.scenario() as scenario:
+        model: Final = scenario.model(
+            model=f"fal_ai/{_MODEL}",
+            api_base=wire.url,
+            api_key="synthetic-fal-key",
+        )
+        created: Final = gateway.post(
+            "/v1/videos",
+            {
+                "model": model,
+                "prompt": "a cat playing volleyball on a beach",
+                "seconds": "4",
+                "size": "1280x720",
+            },
+        )
+        assert created["status"] == "queued"
+        video_id: Final = created["id"]
+        status: Final = gateway.get(f"/v1/videos/{video_id}")
+        assert status["status"] == "failed"
+        assert "input.reference_image_urls: Failed to download the file" in status["error"]["message"]
+        content: Final = gateway.request("GET", f"/v1/videos/{video_id}/content")
+        assert content.status_code == 422, content.text
+        assert "Failed to download the file" in content.text

tests/test_litellm/integrations/otel/test_otel_v2_sources_of_truth.py

@@ -872,6 +872,45 @@ def test_chat_choices_win_over_a_responses_output_list():
     assert data.finish_reasons == ("stop",)
 
 
+def _ocr_payload(pages: list[object]):
+    return _sample_payload(
+        call_type="aocr",
+        custom_llm_provider="mistral",
+        model="mistral-ocr-latest",
+        messages=None,
+        response={"object": "ocr", "model": "mistral-ocr-latest", "pages": pages, "usage_info": {"pages_processed": 2}},
+    )
+
+
+def test_ocr_pages_become_one_assistant_choice_joined_in_page_order():
+    data = LLMCallSpanData.from_standard_logging_payload(
+        _ocr_payload([{"index": 0, "markdown": "# Invoice"}, {"index": 1, "markdown": "Total: 42"}]),
+        capture_content=True,
+    )
+
+    assert data.choices_out == (
+        {
+            "message": {"role": "assistant", "content": "# Invoice\n\nTotal: 42", "refusal": None, "tool_calls": None},
+            "finish_reason": None,
+        },
+    )
+    assert data.finish_reasons == ()
+
+
+def test_ocr_output_follows_the_content_capture_gate():
+    data = LLMCallSpanData.from_standard_logging_payload(_ocr_payload([{"index": 0, "markdown": "# Invoice"}]))
+
+    assert data.choices_out == ()
+
+
+def test_ocr_pages_without_markdown_stay_empty():
+    data = LLMCallSpanData.from_standard_logging_payload(
+        _ocr_payload([{"index": 0, "images": []}, "not-a-page"]), capture_content=True
+    )
+
+    assert data.choices_out == ()
+
+
 def test_request_identity_prefers_canonical_team_keys():
     from litellm.integrations.otel.model.payloads import RequestIdentity
 

tests/test_litellm/integrations/otel/test_otel_v2_vendor_mappers.py

@@ -227,6 +227,28 @@ def test_langfuse_mapper_renders_a_responses_api_call_from_the_standard_logging_
     assert attrs["langfuse.observation.type"] == "generation"
 
 
+def test_langfuse_mapper_renders_an_ocr_call_with_the_page_markdown_as_output():
+    payload = {
+        "call_type": "aocr",
+        "custom_llm_provider": "mistral",
+        "model": "mistral-ocr-latest",
+        "messages": None,
+        "response": {
+            "object": "ocr",
+            "model": "mistral-ocr-latest",
+            "pages": [{"index": 0, "markdown": "# Invoice"}, {"index": 1, "markdown": "Total: 42"}],
+            "usage_info": {"pages_processed": 2},
+        },
+    }
+    data = LLMCallSpanData.from_standard_logging_payload(payload, capture_content=True)
+    attrs = LangfuseMapper().map(data)
+
+    assert json.loads(attrs["langfuse.observation.output"]) == [
+        {"role": "assistant", "content": "# Invoice\n\nTotal: 42", "refusal": None, "tool_calls": None}
+    ]
+    assert attrs["langfuse.observation.type"] == "generation"
+
+
 # --------------------------------------------------------------------------- #
 #  Weave
 # --------------------------------------------------------------------------- #

tests/test_litellm/litellm_core_utils/test_litellm_logging.py

@@ -25,7 +25,7 @@ from litellm.litellm_core_utils.litellm_logging import (
     set_callbacks,
 )
 from litellm.llms.base_llm.ocr.transformation import OCRUsageInfo
-from litellm.types.llms.openai import ResponseAPIUsage, ResponsesAPIResponse
+from litellm.types.llms.openai import ResponseAPIUsage, ResponseCompletedEvent, ResponsesAPIResponse
 from litellm.types.utils import (
     CallTypes,
     LiteLLMRealtimeStreamLoggingObject,
@@ -7415,3 +7415,55 @@ class TestAzurePTUSpilloverCost:
         finally:
             litellm.model_cost.pop(custom_model_id, None)
             self._unregister_models()
+
+
+def _completed_responses_event(usage: ResponseAPIUsage) -> ResponseCompletedEvent:
+    return ResponseCompletedEvent(
+        type="response.completed",
+        response=ResponsesAPIResponse(
+            id="resp-1", created_at=1, object="response", status="completed", model="codex-mini-latest", output=[], usage=usage
+        ),
+    )
+
+
+def _responses_stream_logging_obj() -> LitellmLogging:
+    logging_obj = _make_logging_obj(stream=True)
+    logging_obj.update_environment_variables(
+        model="openai/codex-mini-latest", user="", optional_params={}, litellm_params={"api_base": ""}
+    )
+    return logging_obj
+
+
+def test_get_assembled_streaming_response_bills_a_provider_reported_usage_cost():
+    """A Responses stream whose completed event carries ``usage.cost`` is billed that number,
+    the way an assembled chat stream already is, instead of a price-map estimate."""
+    logging_obj = _responses_stream_logging_obj()
+    now = datetime.datetime.now()
+
+    assembled = logging_obj._get_assembled_streaming_response(
+        result=_completed_responses_event(ResponseAPIUsage(input_tokens=12, output_tokens=2, total_tokens=14, cost=0.0042)),
+        start_time=now,
+        end_time=now,
+        is_async=True,
+        streaming_chunks=[],
+    )
+
+    assert assembled._hidden_params["additional_headers"]["llm_provider-x-litellm-response-cost"] == 0.0042
+    assert logging_obj._response_cost_calculator(result=assembled) == 0.0042
+
+
+def test_get_assembled_streaming_response_without_usage_cost_leaves_pricing_to_the_price_map():
+    logging_obj = _responses_stream_logging_obj()
+    now = datetime.datetime.now()
+
+    assembled = logging_obj._get_assembled_streaming_response(
+        result=_completed_responses_event(ResponseAPIUsage(input_tokens=12, output_tokens=2, total_tokens=14)),
+        start_time=now,
+        end_time=now,
+        is_async=True,
+        streaming_chunks=[],
+    )
+
+    assert "additional_headers" not in assembled._hidden_params
+    price_map_cost = logging_obj._response_cost_calculator(result=assembled)
+    assert price_map_cost is not None and 0 < price_map_cost != 0.0042

tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_experimental_pass_through_messages_handler.py

@@ -2,7 +2,7 @@ import asyncio
 import json
 import os
 import uuid
-from typing import Any, Dict, List
+from typing import Any, Dict, Final, List
 
 import httpx
 import pytest
@@ -1584,3 +1584,104 @@ async def test_anthropic_messages_streaming_forwards_safeguards_and_keeps_safegu
     assert captured["body"]["safeguards"] == safeguards
     assert events[0]["message"]["safeguard_results"] == safeguard_results
     assert [e for e in events if e["type"] == "message_delta"][0]["delta"]["safeguard_results"] == safeguard_results
+
+
+def _claude_code_auto_mode_request() -> tuple[list[dict[str, object]], list[dict[str, object]]]:
+    """Shapes are what Claude Code 2.1.278 sends and Bedrock Invoke / Vertex rawPredict return, captured 2026-09-21."""
+    safeguards = [{"type": "dangerous_tool_use", "classifier_context": {"v": 1, "permission_mode": "auto"}}]
+    tool_verdicts = {"toolu_01": {"type": "evaluated", "outcome": "not_flagged"}}
+    safeguard_results = [{"type": "dangerous_tool_use", "status": {"type": "available", "tool_uses": tool_verdicts}}]
+    return safeguards, safeguard_results
+
+
+def _upstream_answering_with(safeguard_results: list[dict[str, object]], captured: dict[str, object]) -> AsyncHTTPHandler:
+    def upstream_records_the_request(request: httpx.Request) -> httpx.Response:
+        captured["body"] = json.loads(request.content)
+        captured["anthropic-beta"] = request.headers.get("anthropic-beta")
+        return httpx.Response(
+            200,
+            json={
+                "id": "msg_1",
+                "type": "message",
+                "role": "assistant",
+                "model": "claude-sonnet-5",
+                "content": [{"type": "text", "text": "ok"}],
+                "stop_reason": "end_turn",
+                "stop_sequence": None,
+                "usage": {"input_tokens": 1, "output_tokens": 1},
+                "safeguard_results": safeguard_results,
+            },
+            request=request,
+        )
+
+    upstream = AsyncHTTPHandler()
+    upstream.client = httpx.AsyncClient(transport=httpx.MockTransport(upstream_records_the_request))
+    return upstream
+
+
+_CLIENT_BETA_HEADERS: Final = (
+    pytest.param({"anthropic-beta": "dangerous-tool-use-2026-09-03,interleaved-thinking-2025-05-14"}, id="client_sends_beta"),
+    pytest.param({"anthropic-beta": "interleaved-thinking-2025-05-14"}, id="client_omits_beta"),
+    pytest.param({}, id="client_sends_no_beta_header"),
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("client_headers", _CLIENT_BETA_HEADERS)
+async def test_anthropic_messages_forwards_safeguards_and_dangerous_tool_use_beta_to_bedrock_invoke(
+    local_beta_headers_config, client_headers
+):
+    """Bedrock Invoke takes betas in the body's `anthropic_beta` and 400s on `safeguards` without the beta, so the beta rides along with the field."""
+    from litellm.llms.anthropic.experimental_pass_through.messages import handler
+
+    safeguards, safeguard_results = _claude_code_auto_mode_request()
+    captured: dict[str, object] = {}
+
+    response = await handler.anthropic_messages(
+        max_tokens=16,
+        messages=[{"role": "user", "content": "hi"}],
+        model="bedrock/us.anthropic.claude-sonnet-5",
+        custom_llm_provider="bedrock",
+        aws_access_key_id="test-access-key",
+        aws_secret_access_key="test-secret-key",
+        aws_region_name="us-east-1",
+        client=_upstream_answering_with(safeguard_results, captured),
+        safeguards=safeguards,
+        extra_headers=client_headers,
+    )
+
+    assert captured["body"]["safeguards"] == safeguards
+    assert captured["body"]["anthropic_beta"] == ["dangerous-tool-use-2026-09-03"]
+    assert response["safeguard_results"] == safeguard_results
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("client_headers", _CLIENT_BETA_HEADERS)
+async def test_anthropic_messages_forwards_safeguards_and_dangerous_tool_use_beta_to_vertex(
+    local_beta_headers_config, client_headers
+):
+    """Vertex rawPredict takes the beta as the `anthropic-beta` header and 400s on `safeguards` without it, so the beta rides along with the field."""
+    from litellm.llms.anthropic.experimental_pass_through.messages import handler
+    from litellm.llms.vertex_ai.vertex_llm_base import VertexBase
+
+    safeguards, safeguard_results = _claude_code_auto_mode_request()
+    captured: dict[str, object] = {}
+
+    with patch.object(VertexBase, "_ensure_access_token", return_value=("test-token", "test-project")):
+        response = await handler.anthropic_messages(
+            max_tokens=16,
+            messages=[{"role": "user", "content": "hi"}],
+            model="vertex_ai/claude-sonnet-5",
+            custom_llm_provider="vertex_ai",
+            vertex_project="test-project",
+            vertex_location="global",
+            vertex_credentials="{}",
+            client=_upstream_answering_with(safeguard_results, captured),
+            safeguards=safeguards,
+            extra_headers=client_headers,
+        )
+
+    assert captured["body"]["safeguards"] == safeguards
+    assert "anthropic_beta" not in captured["body"]
+    assert captured["anthropic-beta"].split(",").count("dangerous-tool-use-2026-09-03") == 1
+    assert response["safeguard_results"] == safeguard_results

tests/test_litellm/llms/bedrock/messages/invoke_transformations/test_anthropic_claude3_transformation.py

@@ -1651,6 +1651,92 @@ def test_bedrock_messages_allowlist_filters_anthropic_only_fields():
     assert set(result).issubset(cfg.BEDROCK_INVOKE_ALLOWED_TOP_LEVEL_FIELDS)
 
 
+@pytest.mark.parametrize(
+    "client_beta_header",
+    ["dangerous-tool-use-2026-09-03,interleaved-thinking-2025-05-14", "interleaved-thinking-2025-05-14"],
+    ids=["client_sends_beta", "client_omits_beta"],
+)
+def test_bedrock_messages_forwards_safeguards_with_dangerous_tool_use_beta(local_beta_headers_config, client_beta_header):
+    """
+    Claude Code's server-side auto-mode classifier sends `safeguards` alongside the
+    dangerous-tool-use-2026-09-03 beta. Bedrock Invoke accepts the pair, answers
+    "safeguards: Extra inputs are not permitted" for the field alone, and returns
+    `safeguard_results: []` for the beta alone, so the field reaches it unchanged
+    and the beta rides along whether or not the client sent it, as every other
+    body-driven beta does here.
+    """
+    from litellm.types.router import GenericLiteLLMParams
+
+    cfg = AmazonAnthropicClaudeMessagesConfig()
+    safeguards = [{"type": "dangerous_tool_use", "classifier_context": {"v": 1, "permission_mode": "auto"}}]
+
+    result = cfg.transform_anthropic_messages_request(
+        model="us.anthropic.claude-sonnet-5",
+        messages=[{"role": "user", "content": [{"type": "text", "text": "Hello"}]}],
+        anthropic_messages_optional_request_params={"max_tokens": 64, "safeguards": safeguards},
+        litellm_params=GenericLiteLLMParams(),
+        headers={"anthropic-beta": client_beta_header},
+    )
+
+    assert result["safeguards"] == safeguards
+    assert result["anthropic_beta"].count("dangerous-tool-use-2026-09-03") == 1
+
+
+def test_bedrock_messages_does_not_add_dangerous_tool_use_beta_without_safeguards(local_beta_headers_config):
+    from litellm.types.router import GenericLiteLLMParams
+
+    cfg = AmazonAnthropicClaudeMessagesConfig()
+
+    result = cfg.transform_anthropic_messages_request(
+        model="us.anthropic.claude-sonnet-5",
+        messages=[{"role": "user", "content": [{"type": "text", "text": "Hello"}]}],
+        anthropic_messages_optional_request_params={"max_tokens": 64},
+        litellm_params=GenericLiteLLMParams(),
+        headers={},
+    )
+
+    assert "safeguards" not in result
+    assert "dangerous-tool-use-2026-09-03" not in result.get("anthropic_beta", [])
+
+
+def test_bedrock_messages_stream_decoder_keeps_safeguard_results():
+    """Bedrock streams the classifier verdicts on message_start and on the final message_delta, exactly as api.anthropic.com does."""
+    decoder = AmazonAnthropicClaudeMessagesStreamDecoder(model="us.anthropic.claude-sonnet-5")
+    tool_verdicts = {"toolu_01": {"type": "evaluated", "outcome": "not_flagged"}}
+    safeguard_results = [{"type": "dangerous_tool_use", "status": {"type": "available", "tool_uses": tool_verdicts}}]
+
+    message_start = decoder._chunk_parser(
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01",
+                "type": "message",
+                "role": "assistant",
+                "model": "claude-sonnet-5",
+                "content": [],
+                "stop_reason": None,
+                "usage": {"input_tokens": 3, "output_tokens": 0},
+                "safeguard_results": safeguard_results,
+            },
+        }
+    )
+
+    assert isinstance(message_start, dict)
+    assert message_start["message"]["safeguard_results"] == safeguard_results
+
+    message_delta = decoder._chunk_parser(
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn", "stop_sequence": None, "safeguard_results": safeguard_results},
+            "usage": {"output_tokens": 1},
+            "amazon-bedrock-invocationMetrics": {"inputTokenCount": 3, "outputTokenCount": 1},
+        }
+    )
+
+    assert isinstance(message_delta, dict)
+    assert message_delta["delta"]["safeguard_results"] == safeguard_results
+
+
 def test_bedrock_messages_filters_user_provided_unsupported_beta_header():
     """
     In proxy deployments the client (e.g. Claude Code) doesn't know the backend

tests/test_litellm/llms/bedrock_mantle/test_bedrock_mantle_messages_transformation.py

@@ -439,6 +439,19 @@ class TestBetaHeadersOnTheWire:
         assert _sent_betas(route) == ["context-1m-2025-08-07", "context-management-2025-06-27"]
         assert _sent_body(route)["context_management"] == {"edits": [{"type": "clear_tool_uses_20250919"}]}
 
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_safeguards_reach_mantle_with_the_dangerous_tool_use_beta(self):
+        """Mantle answers 400 "safeguards: Extra inputs are not permitted" when the field
+        arrives without dangerous-tool-use-2026-09-03 (probed 2026-09-21), so the beta
+        has to ride along even when the client never sent the header."""
+        safeguards = [{"type": "dangerous_tool_use", "classifier_context": {"v": 1, "permission_mode": "auto"}}]
+
+        route = await self._send(safeguards=safeguards)
+
+        assert _sent_betas(route) == ["dangerous-tool-use-2026-09-03"]
+        assert _sent_body(route)["safeguards"] == safeguards
+
     @pytest.mark.asyncio
     @respx.mock
     async def test_betas_and_version_never_travel_in_the_body(self):