chore: sync main with upstream failure-handler repair

.github/workflows/test-unit.yml

@@ -216,10 +216,12 @@ jobs:
 
           - shard: llms-providers
             test-path: |-
+              tests/unit/llms/test_api_base_trailing_slash_routes.py
               tests/unit/llms/test_cache_control_and_reasoning.py
               tests/unit/llms/test_custom_llm.py
               tests/unit/llms/test_file_content_block.py
               tests/unit/llms/test_file_search_responses.py
+              tests/unit/llms/test_get_complete_url_trailing_slash.py
               tests/unit/llms/test_lifecycle_fix.py
               tests/unit/llms/test_oss_decision.py
               tests/unit/llms/test_polling_url_origin_match.py

Dockerfile

@@ -1,10 +1,10 @@
 # syntax=docker/dockerfile:1.7
 
 # Base image for building
-ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 
 # Runtime image
-ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.11.7@sha256:240fb85ab0f263ef12f492d8476aa3a2e4e1e333f7d67fbdd923d00a506a516a
 # Pinned by digest like the other base images; bump explicitly on Node upgrades.
 ARG UI_BUILD_IMAGE=node:24.19-alpine3.24@sha256:d32cdf619f63fe0471182d08996dd516c6275bb5fd31ae06e55a570bd9e1ad43
@@ -141,7 +141,7 @@ USER root
 RUN echo "https://packages.wolfi.dev/os" >> /etc/apk/repositories
 
 # node (without npm) is required by the prisma CLI at runtime
-RUN apk add --no-cache bash openssl tzdata nodejs python-3.13 libsndfile libevent
+RUN apk add --no-cache bash openssl libssl3 tzdata nodejs python-3.13 libsndfile libevent
 COPY --from=pgbouncer-builder /usr/local/bin/pgbouncer /usr/local/bin/pgbouncer
 
 WORKDIR /app

SECURITY.md

@@ -79,7 +79,7 @@ To qualify for a bounty, reports must include clear reproduction steps, a reprod
 - Audit Logs with retention policy
 - Control Allowed IP Addresses that can access your Cloud LiteLLM Instance
 
-For security inquiries, please contact us at support@berri.ai
+For security inquiries, please contact us at security@berri.ai
 
 #### Supported data regions for LiteLLM Cloud
 

backend/Dockerfile

@@ -1,5 +1,5 @@
-ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
-ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
+ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.11.7@sha256:240fb85ab0f263ef12f492d8476aa3a2e4e1e333f7d67fbdd923d00a506a516a
 
 FROM $UV_IMAGE AS uvbin
@@ -109,7 +109,7 @@ ENV LITELLM_RELEASE_TAG=${LITELLM_RELEASE_TAG}
 USER root
 
 RUN for i in 1 2 3; do \
-      apk add --no-cache bash openssl tzdata python-3.13 libsndfile libatomic && break; \
+      apk add --no-cache bash openssl libssl3 tzdata python-3.13 libsndfile libatomic && break; \
       [ $i = 3 ] && { echo "apk add failed after 3 retries" >&2; exit 1; }; \
       sleep 5; \
     done

docker/Dockerfile.database

@@ -1,10 +1,10 @@
 # syntax=docker/dockerfile:1.7
 
 # Base image for building
-ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 
 # Runtime image
-ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.11.7@sha256:240fb85ab0f263ef12f492d8476aa3a2e4e1e333f7d67fbdd923d00a506a516a
 # Pinned by digest like the other base images; bump explicitly on Node upgrades.
 ARG UI_BUILD_IMAGE=node:24.19-alpine3.24@sha256:d32cdf619f63fe0471182d08996dd516c6275bb5fd31ae06e55a570bd9e1ad43
@@ -122,7 +122,7 @@ ENV LITELLM_RELEASE_TAG=${LITELLM_RELEASE_TAG}
 USER root
 
 # node (without npm) is required by the prisma CLI at runtime
-RUN apk add --no-cache bash openssl tzdata nodejs python-3.13 libsndfile libevent
+RUN apk add --no-cache bash openssl libssl3 tzdata nodejs python-3.13 libsndfile libevent
 COPY --from=pgbouncer-builder /usr/local/bin/pgbouncer /usr/local/bin/pgbouncer
 
 WORKDIR /app

docker/Dockerfile.non_root

@@ -1,8 +1,8 @@
 # syntax=docker/dockerfile:1.7
 
 # Base images
-ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
-ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
+ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.11.7@sha256:240fb85ab0f263ef12f492d8476aa3a2e4e1e333f7d67fbdd923d00a506a516a
 # Pinned by digest like the other base images; bump explicitly on Node upgrades.
 ARG UI_BUILD_IMAGE=node:24.19-alpine3.24@sha256:d32cdf619f63fe0471182d08996dd516c6275bb5fd31ae06e55a570bd9e1ad43
@@ -134,7 +134,7 @@ RUN for i in 1 2 3; do \
       apk upgrade --no-cache && break || sleep 5; \
     done && \
     for i in 1 2 3; do \
-      apk add --no-cache python-3.13 bash openssl tzdata libsndfile nodejs libevent && break || sleep 5; \
+      apk add --no-cache python-3.13 bash openssl libssl3 tzdata libsndfile nodejs libevent && break || sleep 5; \
     done
 COPY --from=pgbouncer-builder /usr/local/bin/pgbouncer /usr/local/bin/pgbouncer
 

gateway/Dockerfile

@@ -1,5 +1,5 @@
-ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
-ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:1d95114038f76513a9ace6fca107d5582b08c65981f81f61cb56bf7fd2ef216d
+ARG LITELLM_BUILD_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
+ARG LITELLM_RUNTIME_IMAGE=cgr.dev/chainguard/wolfi-base@sha256:81211e15a86ea1d5357f284482af45730c51de45eaf10ad9ce205d6bfc2df323
 ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.11.7@sha256:240fb85ab0f263ef12f492d8476aa3a2e4e1e333f7d67fbdd923d00a506a516a
 # Checksum from https://www.pgbouncer.org/downloads/ (the Wolfi repo only carries 1.24.x)
 ARG PGBOUNCER_VERSION=1.26.0
@@ -125,7 +125,7 @@ FROM $LITELLM_RUNTIME_IMAGE AS runtime
 USER root
 
 RUN for i in 1 2 3; do \
-      apk add --no-cache bash openssl tzdata python-3.13 libsndfile libatomic libevent && break; \
+      apk add --no-cache bash openssl libssl3 tzdata python-3.13 libsndfile libatomic libevent && break; \
       [ $i = 3 ] && { echo "apk add failed after 3 retries" >&2; exit 1; }; \
       sleep 5; \
     done

litellm-rust/Cargo.lock

@@ -8202,18 +8202,18 @@ dependencies = [
 
 [[package]]
 name = "webpki-root-certs"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
+checksum = "58ec80e73fd8baf57bf0d9615554c75348bda990d6d5bbeab964dd068319fecb"
 dependencies = [
  "rustls-pki-types",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+checksum = "1c1c8e20c8a38fc7d65abfe74eb7280e4aa667e8eec8bc84996d2874810748d9"
 dependencies = [
  "rustls-pki-types",
 ]

litellm-rust/Cargo.toml

@@ -124,7 +124,7 @@ moka = { version = "0.12.16", features = ["future"] }
 strum = { version = "0.28.0", features = ["derive"] }
 url = "2.5.8"
 percent-encoding = "2.3"
-webpki-roots = "1"
+webpki-roots = "1.0.10"
 time = { version = "0.3.53", features = ["parsing"] }
 criterion = "0.8.2"
 fancy-regex = "0.19.2"

litellm-rust/crates/gateway-inference/src/caching.rs

@@ -72,26 +72,26 @@ fn duration(seconds: f64) -> Result<Duration, Error> {
 #[derive(Clone, Default)]
 pub(crate) struct CacheHeaders(std::sync::Arc<std::sync::OnceLock<String>>);
 
-impl litellm_host::interceptors::Interceptors<litellm_inference::RouteError> for CacheHeaders {
+impl litellm_host::interceptors::Interceptors<litellm_inference::Error> for CacheHeaders {
     async fn before_provider_request(
         &self,
         wire: litellm_host::interceptors::WireRequest,
         _: litellm_host::interceptors::RequestContext,
-    ) -> Result<litellm_host::interceptors::WireRequest, litellm_inference::RouteError> {
+    ) -> Result<litellm_host::interceptors::WireRequest, litellm_inference::Error> {
         Ok(wire)
     }
 
     async fn after_provider_response(
         &self,
         _: litellm_host::interceptors::RawResponse,
-    ) -> Result<(), litellm_inference::RouteError> {
+    ) -> Result<(), litellm_inference::Error> {
         Ok(())
     }
 
     async fn result_ready(
         &self,
         facts: litellm_host::interceptors::ExecutionFacts,
-    ) -> Result<(), litellm_inference::RouteError> {
+    ) -> Result<(), litellm_inference::Error> {
         if let litellm_host::interceptors::ResultSource::Cache { key } = facts.source {
             let _ = self.0.set(key);
         }

litellm-rust/crates/gateway-inference/src/error.rs

@@ -4,7 +4,7 @@ use axum::{
     response::{IntoResponse, Response},
 };
 use litellm_http::transport::Error as TransportError;
-use litellm_inference::RouteError;
+use litellm_inference::Error as InferenceError;
 use litellm_llms::base_llm::ocr::error::Error as OcrError;
 use serde_json::{Map, Value, json};
 
@@ -19,7 +19,7 @@ pub enum Error {
     )]
     UnknownModel(String),
     #[error(transparent)]
-    Route(#[from] RouteError),
+    Route(#[from] InferenceError),
     #[error(transparent)]
     Ocr(#[from] OcrError),
     #[error("{0} is not implemented by the Rust gateway")]
@@ -36,8 +36,8 @@ impl IntoResponse for Error {
     }
 }
 
-impl From<litellm_host_http::Error<RouteError>> for Error {
-    fn from(error: litellm_host_http::Error<RouteError>) -> Self {
+impl From<litellm_host_http::Error<InferenceError>> for Error {
+    fn from(error: litellm_host_http::Error<InferenceError>) -> Self {
         match error {
             litellm_host_http::Error::Call(error) => Self::Route(error),
             litellm_host_http::Error::Protocol => Self::Internal(error.to_string()),
@@ -50,7 +50,7 @@ impl Error {
         match self {
             Self::Auth(error) => error.status(),
             Self::Unsupported(_)
-            | Self::Route(RouteError::Unsupported(_))
+            | Self::Route(InferenceError::Unsupported(_))
             | Self::Ocr(OcrError::Unsupported(_)) => StatusCode::NOT_IMPLEMENTED,
             Self::BodyTooLarge => StatusCode::PAYLOAD_TOO_LARGE,
             Self::Ocr(
@@ -64,10 +64,10 @@ impl Error {
                 .and_then(|status| StatusCode::from_u16(status).ok())
                 .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
             Self::InvalidBody(_) | Self::UnknownModel(_) => StatusCode::BAD_REQUEST,
-            Self::Route(RouteError::Transport(TransportError::Http { status, .. })) => {
+            Self::Route(InferenceError::Transport(TransportError::Http { status, .. })) => {
                 StatusCode::from_u16(*status).unwrap_or(StatusCode::BAD_GATEWAY)
             }
-            Self::Route(RouteError::Auth(litellm_auth::Error::MissingApiKey { .. })) => {
+            Self::Route(InferenceError::Auth(litellm_auth::Error::MissingApiKey { .. })) => {
                 StatusCode::UNAUTHORIZED
             }
             Self::Route(error) if error.is_request() => StatusCode::BAD_REQUEST,
@@ -97,7 +97,9 @@ impl Error {
     /// body already in that shape passes through, any other has its message extracted.
     pub fn body(&self, request_id: Option<&str>) -> Value {
         let raw = match self {
-            Self::Route(RouteError::Transport(TransportError::Http { body, .. })) => body.clone(),
+            Self::Route(InferenceError::Transport(TransportError::Http { body, .. })) => {
+                body.clone()
+            }
             other => other.to_string(),
         };
         let parsed = serde_json::from_str::<Value>(&raw).ok();
@@ -175,7 +177,7 @@ mod tests {
     use super::*;
 
     fn upstream(status: u16, body: &str) -> Error {
-        Error::Route(RouteError::Transport(TransportError::Http {
+        Error::Route(InferenceError::Transport(TransportError::Http {
             status,
             body: body.into(),
         }))
@@ -225,16 +227,16 @@ mod tests {
 
     #[rstest]
     #[case::upstream_status(upstream(429, ""), StatusCode::TOO_MANY_REQUESTS)]
-    #[case::rejected_request(Error::Route(RouteError::InvalidRequest("top_k".into())), StatusCode::BAD_REQUEST)]
+    #[case::rejected_request(Error::Route(InferenceError::InvalidRequest("top_k".into())), StatusCode::BAD_REQUEST)]
     #[case::missing_key(
-        Error::Route(RouteError::Auth(litellm_auth::Error::MissingApiKey {
+        Error::Route(InferenceError::Auth(litellm_auth::Error::MissingApiKey {
             provider: "Anthropic",
             environment_variable: "ANTHROPIC_API_KEY",
         })),
         StatusCode::UNAUTHORIZED,
     )]
     #[case::lost_connection(
-        Error::Route(RouteError::Transport(TransportError::Network("reset".into()))),
+        Error::Route(InferenceError::Transport(TransportError::Network("reset".into()))),
         StatusCode::INTERNAL_SERVER_ERROR,
     )]
     fn status_follows_who_is_at_fault(#[case] error: Error, #[case] status: StatusCode) {

litellm-rust/crates/inference-chat/src/lib.rs

@@ -1,7 +1,7 @@
 use litellm_host::observation::ObservationSender;
 pub mod route;
 pub mod types;
-pub use litellm_inference::RouteError as Error;
+pub use litellm_inference::Error;
 mod common_utils;
 pub mod constants;
 pub(crate) mod handler;

litellm-rust/crates/inference-chat/tests/caching.rs

@@ -21,7 +21,7 @@ use litellm_host::{
     lifecycle::{CallEvent, ExecutionEvent},
     observation::observation_channel,
 };
-use litellm_inference::RouteError;
+use litellm_inference::Error;
 use rstest::{fixture, rstest};
 use serde_json::{Value, json};
 
@@ -166,12 +166,12 @@ struct ChangingHooks {
     facts: std::sync::Mutex<Vec<ExecutionFacts>>,
 }
 
-impl Interceptors<RouteError> for ChangingHooks {
+impl Interceptors<Error> for ChangingHooks {
     async fn before_provider_request(
         &self,
         mut wire: WireRequest,
         _: RequestContext,
-    ) -> Result<WireRequest, RouteError> {
+    ) -> Result<WireRequest, Error> {
         let call = self.calls.fetch_add(1, Ordering::SeqCst);
         if self.rewrite {
             wire.body["temperature"] = json!(if call < 2 { 0.1 } else { 0.8 });
@@ -179,11 +179,11 @@ impl Interceptors<RouteError> for ChangingHooks {
         Ok(wire)
     }
 
-    async fn after_provider_response(&self, _: RawResponse) -> Result<(), RouteError> {
+    async fn after_provider_response(&self, _: RawResponse) -> Result<(), Error> {
         Ok(())
     }
 
-    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), RouteError> {
+    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), Error> {
         self.facts.lock().unwrap().push(facts);
         Ok(())
     }

litellm-rust/crates/inference-messages/src/lib.rs

@@ -14,7 +14,7 @@ use std::sync::Arc;
 
 use crate::common_utils::messages_provider;
 
-pub use litellm_inference::RouteError as Error;
+pub use litellm_inference::Error;
 pub use types::{
     MessagesCall, MessagesCallResponse, MessagesSettings, MessagesShaping, litellm_params,
     messages_body,

litellm-rust/crates/inference-messages/tests/caching.rs

@@ -17,7 +17,7 @@ use litellm_host::interceptors::{
     ResultSource, WireRequest,
 };
 use litellm_inference::{
-    RouteError,
+    Error,
     caching::{CacheRequest, execute_unary},
 };
 use rstest::{fixture, rstest};
@@ -133,12 +133,12 @@ struct ChangingHooks {
     facts: std::sync::Mutex<Vec<ExecutionFacts>>,
 }
 
-impl Interceptors<RouteError> for ChangingHooks {
+impl Interceptors<Error> for ChangingHooks {
     async fn before_provider_request(
         &self,
         mut wire: WireRequest,
         _: RequestContext,
-    ) -> Result<WireRequest, RouteError> {
+    ) -> Result<WireRequest, Error> {
         let call = self.calls.fetch_add(1, Ordering::SeqCst);
         if self.rewrite {
             wire.body["temperature"] = json!(if call < 2 { 0.1 } else { 0.8 });
@@ -146,11 +146,11 @@ impl Interceptors<RouteError> for ChangingHooks {
         Ok(wire)
     }
 
-    async fn after_provider_response(&self, _: RawResponse) -> Result<(), RouteError> {
+    async fn after_provider_response(&self, _: RawResponse) -> Result<(), Error> {
         Ok(())
     }
 
-    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), RouteError> {
+    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), Error> {
         self.facts.lock().unwrap().push(facts);
         Ok(())
     }

litellm-rust/crates/inference-ocr/AGENTS.md

@@ -3,4 +3,4 @@
 - The route returns its completed response directly
 - Route closures supply OCR-specific host capabilities, such as the caller's Azure AD token provider (`src/route.rs`)
 - Provider code reaches the caller's hooks mid-call only through `litellm_llms::base_llm::ocr::handler::CallHooks`, which this crate implements over its host until it folds into `litellm_host::interceptors::Interceptors`
-- OCR failures use `base_llm/ocr/error.rs`, the recorded exception to `litellm_inference::RouteError` until OCR folds into `litellm_llms::Error`
+- OCR failures use `base_llm/ocr/error.rs`, the recorded exception to `litellm_inference::Error` until OCR folds into `litellm_llms::Error`

litellm-rust/crates/inference-ocr/src/provider_config.rs

@@ -249,7 +249,7 @@ pub(crate) fn resolve_provider_config<'a>(
                 provider: LlmProviders::Mistral,
             }
         }
-        Err(litellm_inference::RouteError::InvalidProvider(provider)) => {
+        Err(litellm_inference::Error::InvalidProvider(provider)) => {
             return Err(Error::InvalidProvider(provider));
         }
         Err(error) => return Err(Error::InvalidProvider(error.to_string())),

litellm-rust/crates/inference-responses/src/lib.rs

@@ -1,5 +1,5 @@
 use litellm_host::observation::ObservationSender;
-pub use litellm_inference::RouteError as Error;
+pub use litellm_inference::Error;
 
 pub mod ids;
 pub mod route;

litellm-rust/crates/inference-responses/tests/caching.rs

@@ -18,7 +18,7 @@ use litellm_host::interceptors::{
     WireRequest,
 };
 use litellm_inference::{
-    RouteError,
+    Error,
     caching::{CacheRequest, execute_unary},
 };
 use rstest::{fixture, rstest};
@@ -124,12 +124,12 @@ struct ChangingHooks {
     facts: std::sync::Mutex<Vec<ExecutionFacts>>,
 }
 
-impl Interceptors<RouteError> for ChangingHooks {
+impl Interceptors<Error> for ChangingHooks {
     async fn before_provider_request(
         &self,
         mut wire: WireRequest,
         _: RequestContext,
-    ) -> Result<WireRequest, RouteError> {
+    ) -> Result<WireRequest, Error> {
         let call = self.calls.fetch_add(1, Ordering::SeqCst);
         if self.rewrite {
             wire.body["temperature"] = json!(if call < 2 { 0.1 } else { 0.8 });
@@ -137,11 +137,11 @@ impl Interceptors<RouteError> for ChangingHooks {
         Ok(wire)
     }
 
-    async fn after_provider_response(&self, _: RawResponse) -> Result<(), RouteError> {
+    async fn after_provider_response(&self, _: RawResponse) -> Result<(), Error> {
         Ok(())
     }
 
-    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), RouteError> {
+    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), Error> {
         self.facts.lock().unwrap().push(facts);
         Ok(())
     }

litellm-rust/crates/inference-transcription/src/lib.rs

@@ -1,5 +1,5 @@
 pub mod types;
-pub use litellm_inference::RouteError as Error;
+pub use litellm_inference::Error;
 mod constants;
 mod handler;
 

litellm-rust/crates/inference/AGENTS.md

@@ -2,7 +2,7 @@
 
 - `gateway-inference` (serving) -> `inference-<fmt>` (one API's call) -> `inference` (shared base)
 - This crate is the shared base every format crate builds on
-  - `RouteError` (`src/error.rs`), `CallOptions` (`src/lib.rs`), `CallContext` (`src/context.rs`)
+  - `Error` (`src/error.rs`), `CallOptions` (`src/lib.rs`), `CallContext` (`src/context.rs`)
   - diagnostic spans (`src/diagnostic.rs`), outbound send and signing (`src/outbound.rs`), provider resolution (`src/provider.rs`), `CoreResources` (`src/resources.rs`)
   - response caching (`src/caching.rs`): `Cachable`, `StreamCachable`, `CacheRequest`, `CallCache`, `execute_unary`, `execute_streaming`, stream capture
   - Shared test helpers belong in litellm-inference-testing, used only as a dev dependency
@@ -49,14 +49,14 @@
 - `litellm-inference-<fmt>` mirrors the route packages (`litellm/ocr/`, `litellm/messages/`, ...)
 - Provider code never imports from `inference` or `inference-*`
 - Handlers belong in `inference-*` or `llms`, never in a host crate
-- Import every item from its canonical path. Never re-export another crate's items or give an item a second public path. The only allowed re-exports are a private submodule surfacing its item at its module root (`mod error; pub use error::Error;`) and each format crate's `pub use litellm_inference::RouteError as Error;`, which keeps the pre-split `<fmt>::Error` name
+- Import every item from its canonical path. Never re-export another crate's items or give an item a second public path. The only allowed re-exports are a private submodule surfacing its item at its module root (`mod error; pub use error::Error;`) and each format crate's `pub use litellm_inference::Error;`, which keeps the pre-split `<fmt>::Error` name
 
 ## Error placement
 
 - The workspace `Error definitions` rules shape each crate's error. This section decides which crate and module a failure belongs to
 - A failure is declared once, by the lowest crate that raises it
   - every crate above nests it unchanged (`#[error(transparent)] Auth(#[from] litellm_auth::Error)`) or maps it once at its boundary, as `src/error.rs` does for `litellm_llms::Error`
-  - `RouteError` collects route failures for every format crate and never re-declares a variant a lower crate raises
+  - `Error` collects route failures for every format crate and never re-declares a variant a lower crate raises
 - Scope follows the concept, not the first caller
   - an error type under `litellm-llms`'s `<provider>/` is private to that provider: no other provider and nothing in `base_llm` may import it
   - a failure two providers or two routes can hit (wire framing, stream event decoding, a malformed provider response) belongs to the crate that owns the concept: `litellm-framer` for framing, `litellm_llms::Error` for the transformation layer

litellm-rust/crates/inference/src/caching.rs

@@ -24,9 +24,9 @@ use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use serde_json::Value;
 use tokio_util::codec::Decoder;
 
-use crate::RouteError;
+use crate::Error;
 
-pub trait Cachable: Protocol<Error = RouteError> {
+pub trait Cachable: Protocol<Error = Error> {
     const SURFACE: &'static str;
 
     fn reusable(_response: &Self::Response) -> bool {
@@ -145,15 +145,15 @@ pub async fn execute_unary<P, F, Fut>(
     request: CacheRequest,
     cache: Option<Arc<dyn ResponseCacheService>>,
     options: Option<CacheOptions>,
-    interceptors: &impl Interceptors<RouteError>,
+    interceptors: &impl Interceptors<Error>,
     observers: Option<&ObservationSender>,
     provider: F,
-) -> Result<P::Response, RouteError>
+) -> Result<P::Response, Error>
 where
     P: Cachable,
     P::Response: Serialize + DeserializeOwned,
     F: FnOnce() -> Fut,
-    Fut: Future<Output = Result<P::Response, RouteError>>,
+    Fut: Future<Output = Result<P::Response, Error>>,
 {
     let identity = request.identity.clone();
     crate::diagnostic::provider(&identity.model, &identity.provider);
@@ -191,15 +191,15 @@ pub async fn execute_streaming<P, F, Fut>(
     request: CacheRequest,
     cache: Option<Arc<dyn ResponseCacheService>>,
     options: Option<CacheOptions>,
-    interceptors: &impl Interceptors<RouteError>,
+    interceptors: &impl Interceptors<Error>,
     observers: Option<&ObservationSender>,
     provider: F,
-) -> Result<OutputOf<P>, RouteError>
+) -> Result<OutputOf<P>, Error>
 where
     P: StreamCachable,
     P::Response: Serialize + DeserializeOwned,
     F: FnOnce() -> Fut,
-    Fut: Future<Output = Result<OutputOf<P>, RouteError>>,
+    Fut: Future<Output = Result<OutputOf<P>, Error>>,
 {
     let identity = request.identity.clone();
     crate::diagnostic::provider(&identity.model, &identity.provider);
@@ -299,9 +299,9 @@ impl<P: StreamCachable> CallCache<P> {
 }
 
 fn capture_stream<P: StreamCachable>(
-    chunks: futures_util::stream::BoxStream<'static, Result<P::Chunk, RouteError>>,
+    chunks: futures_util::stream::BoxStream<'static, Result<P::Chunk, Error>>,
     session: CacheSession,
-) -> futures_util::stream::BoxStream<'static, Result<P::Chunk, RouteError>> {
+) -> futures_util::stream::BoxStream<'static, Result<P::Chunk, Error>> {
     stream::try_unfold(
         (chunks, Some(Vec::<u8>::new()), session),
         |(mut chunks, captured, session)| async move {
@@ -330,7 +330,7 @@ fn capture_stream<P: StreamCachable>(
                     {
                         session.store(entry).await;
                     }
-                    Ok::<_, RouteError>(None)
+                    Ok::<_, Error>(None)
                 }
             }
         },
@@ -369,9 +369,9 @@ fn successful_stream(text: &str, terminal: &str) -> bool {
 
 async fn publish(
     facts: ExecutionFacts,
-    interceptors: &impl Interceptors<RouteError>,
+    interceptors: &impl Interceptors<Error>,
     observers: Option<&ObservationSender>,
-) -> Result<(), RouteError> {
+) -> Result<(), Error> {
     if let Some(observers) = observers {
         observers.emit(CallEvent::Execution(ExecutionEvent::ResultReady {
             facts: facts.clone(),

litellm-rust/crates/inference/src/context.rs

@@ -5,7 +5,7 @@ use litellm_host::{
     observation::ObservationSender,
 };
 
-use crate::{CallOptions, RouteError};
+use crate::{CallOptions, Error};
 
 pub struct CallContext<'a, I> {
     pub interceptors: &'a I,
@@ -13,7 +13,7 @@ pub struct CallContext<'a, I> {
     pub cache: CachePolicy,
 }
 
-impl<'a, I: Interceptors<RouteError>> CallContext<'a, I> {
+impl<'a, I: Interceptors<Error>> CallContext<'a, I> {
     pub fn new(interceptors: &'a I, options: CallOptions) -> Self {
         Self {
             interceptors,
@@ -22,7 +22,7 @@ impl<'a, I: Interceptors<RouteError>> CallContext<'a, I> {
         }
     }
 
-    pub async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), RouteError> {
+    pub async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), Error> {
         if let Some(observers) = &self.observers {
             observers.emit(CallEvent::Execution(ExecutionEvent::ResultReady {
                 facts: facts.clone(),
@@ -31,7 +31,7 @@ impl<'a, I: Interceptors<RouteError>> CallContext<'a, I> {
         self.interceptors.result_ready(facts).await
     }
 
-    pub async fn response_received(&self, body: &str) -> Result<(), RouteError> {
+    pub async fn response_received(&self, body: &str) -> Result<(), Error> {
         let raw = RawResponse {
             body: body.to_owned(),
         };
@@ -43,6 +43,6 @@ impl<'a, I: Interceptors<RouteError>> CallContext<'a, I> {
         self.interceptors
             .after_provider_response(raw)
             .await
-            .map_err(RouteError::post_call)
+            .map_err(Error::post_call)
     }
 }

litellm-rust/crates/inference/src/error.rs

@@ -11,7 +11,7 @@ use litellm_http::transport::Error as TransportError;
 use litellm_llms::Error as LlmError;
 
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
-pub enum RouteError {
+pub enum Error {
     #[error("expected {expected}, got {actual}")]
     InvalidType {
         expected: &'static str,
@@ -38,10 +38,10 @@ pub enum RouteError {
     #[error(transparent)]
     Secret(#[from] SecretError),
     #[error("post-call hook failed: {0}")]
-    PostCallHook(#[source] Arc<RouteError>),
+    PostCallHook(#[source] Arc<Error>),
 }
 
-impl From<litellm_host::machine::MachineFault> for RouteError {
+impl From<litellm_host::machine::MachineFault> for Error {
     fn from(fault: litellm_host::machine::MachineFault) -> Self {
         use litellm_host::machine::MachineFault;
         Self::InvalidRequest(match fault {
@@ -51,7 +51,7 @@ impl From<litellm_host::machine::MachineFault> for RouteError {
     }
 }
 
-impl RouteError {
+impl Error {
     pub fn post_call(error: Self) -> Self {
         Self::PostCallHook(Arc::new(error))
     }
@@ -76,7 +76,7 @@ impl RouteError {
     }
 }
 
-impl From<LlmError> for RouteError {
+impl From<LlmError> for Error {
     fn from(error: LlmError) -> Self {
         match error {
             LlmError::InvalidType { expected, actual } => Self::InvalidType { expected, actual },
@@ -99,7 +99,7 @@ impl SecretError {
     }
 }
 
-impl From<litellm_secrets::Error> for RouteError {
+impl From<litellm_secrets::Error> for Error {
     fn from(error: litellm_secrets::Error) -> Self {
         Self::Secret(SecretError(Arc::new(error)))
     }
@@ -115,22 +115,22 @@ impl Eq for SecretError {}
 
 #[cfg(test)]
 mod tests {
-    use super::RouteError;
+    use super::Error;
     use litellm_llms::{Error as LlmError, ErrorDetail};
     use rstest::rstest;
 
     #[test]
     fn a_missing_api_key_is_the_environment_not_the_request() {
         assert!(
-            !RouteError::Auth(litellm_auth::Error::MissingApiKey {
+            !Error::Auth(litellm_auth::Error::MissingApiKey {
                 provider: "Anthropic",
                 environment_variable: "ANTHROPIC_API_KEY",
             })
             .is_request()
         );
-        assert!(RouteError::Auth(litellm_auth::Error::InvalidHeader).is_request());
-        assert!(RouteError::InvalidRequest("top_k".into()).is_request());
-        assert!(!RouteError::InvalidResponse("bad json".into()).is_request());
+        assert!(Error::Auth(litellm_auth::Error::InvalidHeader).is_request());
+        assert!(Error::InvalidRequest("top_k".into()).is_request());
+        assert!(!Error::InvalidResponse("bad json".into()).is_request());
     }
     #[rstest]
     #[case::request(true)]
@@ -139,7 +139,7 @@ mod tests {
         let source = serde_json::from_str::<serde_json::Value>("{").unwrap_err();
         let source_message = source.to_string();
         let detail = ErrorDetail::invalid("test payload", source);
-        let error = RouteError::from(if request {
+        let error = Error::from(if request {
             LlmError::InvalidRequest(detail)
         } else {
             LlmError::InvalidResponse(detail)

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

@@ -7,7 +7,7 @@ pub mod outbound;
 pub mod provider;
 pub mod resources;
 
-pub use error::RouteError;
+pub use error::Error;
 
 #[derive(Clone, Default)]
 pub struct CallOptions {

litellm-rust/crates/inference/src/provider.rs

@@ -2,7 +2,7 @@ use litellm_core_utils::get_llm_provider_logic::{
     CustomLlmProvider, LlmProviders, get_custom_llm_provider,
 };
 
-use crate::error::RouteError as Error;
+use crate::error::Error;
 
 #[derive(Debug)]
 pub struct ResolvedProvider<'a> {

litellm-rust/crates/inference/tests/caching.rs

@@ -25,7 +25,7 @@ use litellm_host::{
     protocol::Protocol,
 };
 use litellm_inference::{
-    RouteError,
+    Error,
     caching::{Cachable, CacheRequest, StreamCachable, execute_streaming, execute_unary},
 };
 use rstest::{fixture, rstest};
@@ -36,7 +36,7 @@ struct TestRoute;
 impl Protocol for TestRoute {
     type Request = Value;
     type Response = Value;
-    type Error = RouteError;
+    type Error = Error;
     type HostCall = Infallible;
     type Chunk = Bytes;
     type StreamHead = ();
@@ -204,7 +204,7 @@ async fn streamed(
                 .chunks(3)
                 .map(|bytes| Ok(Bytes::copy_from_slice(bytes)))
                 .collect::<Vec<_>>();
-            let ending = fail.then_some(Err(RouteError::Unsupported("test transport failure")));
+            let ending = fail.then_some(Err(Error::Unsupported("test transport failure")));
             Ok(CallOutput::Stream {
                 head: (),
                 chunks: stream::iter(chunks.into_iter().chain(ending)).boxed(),
@@ -215,7 +215,7 @@ async fn streamed(
     .unwrap()
 }
 
-async fn consume(output: OutputOf<TestRoute>) -> Result<Vec<u8>, RouteError> {
+async fn consume(output: OutputOf<TestRoute>) -> Result<Vec<u8>, Error> {
     let CallOutput::Stream { chunks, .. } = output else {
         panic!("expected a stream");
     };
@@ -315,7 +315,7 @@ async fn a_provider_failure_never_populates_the_cache(cache: Arc<dyn ResponseCac
         None,
         || async {
             calls.fetch_add(1, Ordering::SeqCst);
-            Err(RouteError::Unsupported("test provider failure"))
+            Err(Error::Unsupported("test provider failure"))
         },
     )
     .await;
@@ -467,8 +467,8 @@ struct CacheHitAccounting {
     reject: bool,
 }
 
-impl Interceptors<RouteError> for CacheHitAccounting {
-    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), RouteError> {
+impl Interceptors<Error> for CacheHitAccounting {
+    async fn result_ready(&self, facts: ExecutionFacts) -> Result<(), Error> {
         self.calls.fetch_add(1, Ordering::SeqCst);
         let ResultSource::Cache { key } = facts.source else {
             panic!("expected cache source")
@@ -482,7 +482,7 @@ impl Interceptors<RouteError> for CacheHitAccounting {
         );
         self.key.set(key).unwrap();
         if self.reject {
-            return Err(RouteError::Unsupported("cache accounting rejected"));
+            return Err(Error::Unsupported("cache accounting rejected"));
         }
         Ok(())
     }
@@ -491,11 +491,11 @@ impl Interceptors<RouteError> for CacheHitAccounting {
         &self,
         wire: WireRequest,
         _: RequestContext,
-    ) -> Result<WireRequest, RouteError> {
+    ) -> Result<WireRequest, Error> {
         Ok(wire)
     }
 
-    async fn after_provider_response(&self, _: RawResponse) -> Result<(), RouteError> {
+    async fn after_provider_response(&self, _: RawResponse) -> Result<(), Error> {
         Ok(())
     }
 }
@@ -571,7 +571,7 @@ async fn cache_hits_notify_accounting_once_and_propagate_its_failure(
     if reject {
         assert!(matches!(
             result,
-            Err(RouteError::Unsupported("cache accounting rejected"))
+            Err(Error::Unsupported("cache accounting rejected"))
         ));
     } else {
         assert_eq!(result.unwrap(), expected);
@@ -590,7 +590,7 @@ async fn cache_hits_notify_accounting_once_and_propagate_its_failure(
 impl Protocol for UnaryTestRoute {
     type Request = Value;
     type Response = Value;
-    type Error = RouteError;
+    type Error = Error;
     type HostCall = Infallible;
     type Chunk = Infallible;
     type StreamHead = Infallible;

litellm-rust/crates/python-bridge/src/errors.rs

@@ -1,5 +1,5 @@
 use litellm_http::transport::Error as TransportError;
-use litellm_inference::RouteError;
+use litellm_inference::Error;
 use pyo3::{
     exceptions::{PyRuntimeError, PyValueError},
     prelude::*,
@@ -19,9 +19,9 @@ pyo3::create_exception!(
     "The provider call was already issued and failed. Args are (status, message); status is 0 when there was no HTTP response."
 );
 
-pub(crate) fn route_error_to_pyerr(error: RouteError) -> PyErr {
+pub(crate) fn route_error_to_pyerr(error: Error) -> PyErr {
     match error {
-        RouteError::Transport(TransportError::Http { status, body }) => {
+        Error::Transport(TransportError::Http { status, body }) => {
             RustUpstreamError::new_err((status, body))
         }
         other => by_fault(other.is_request(), other.to_string()),
@@ -42,13 +42,13 @@ mod tests {
     use super::*;
 
     #[rstest::rstest]
-    #[case::unsupported(RouteError::Unsupported("test capability"), true)]
-    #[case::invalid_provider(RouteError::InvalidProvider("unknown".into()), true)]
-    #[case::invalid_request(RouteError::InvalidRequest("empty messages".into()), true)]
+    #[case::unsupported(Error::Unsupported("test capability"), true)]
+    #[case::invalid_provider(Error::InvalidProvider("unknown".into()), true)]
+    #[case::invalid_request(Error::InvalidRequest("empty messages".into()), true)]
     #[case::connection(TransportError::Connect("unreachable".into()).into(), false)]
     #[case::network(TransportError::Network("timed out".into()).into(), false)]
-    #[case::invalid_response(RouteError::InvalidResponse("missing usage".into()), false)]
-    fn route_failures_are_terminal(#[case] error: RouteError, #[case] is_request: bool) {
+    #[case::invalid_response(Error::InvalidResponse("missing usage".into()), false)]
+    fn route_failures_are_terminal(#[case] error: Error, #[case] is_request: bool) {
         Python::initialize();
         Python::attach(|py| {
             let failure = route_error_to_pyerr(error);
@@ -86,14 +86,12 @@ mod tests {
     fn missing_api_key_stays_a_runtime_error_while_other_auth_failures_are_value_errors() {
         Python::initialize();
         Python::attach(|py| {
-            let missing =
-                route_error_to_pyerr(RouteError::Auth(litellm_auth::Error::MissingApiKey {
-                    provider: "Anthropic",
-                    environment_variable: "ANTHROPIC_API_KEY",
-                }));
+            let missing = route_error_to_pyerr(Error::Auth(litellm_auth::Error::MissingApiKey {
+                provider: "Anthropic",
+                environment_variable: "ANTHROPIC_API_KEY",
+            }));
             assert!(missing.is_instance_of::<PyRuntimeError>(py));
-            let invalid =
-                route_error_to_pyerr(RouteError::Auth(litellm_auth::Error::InvalidHeader));
+            let invalid = route_error_to_pyerr(Error::Auth(litellm_auth::Error::InvalidHeader));
             assert!(invalid.is_instance_of::<PyValueError>(py));
         });
     }

litellm-rust/crates/python-bridge/src/routes/inference.rs

@@ -7,7 +7,7 @@ use litellm_core_utils::get_llm_provider_logic::get_custom_llm_provider;
 use litellm_host::{call::HostedMachine, protocol::Protocol};
 use litellm_host_python::{PythonBinding, PythonHostCalls, from_py};
 use litellm_http::transport::Error as TransportError;
-use litellm_inference::RouteError;
+use litellm_inference::Error;
 use litellm_secrets::source::SecretSource;
 use pyo3::{
     exceptions::PyValueError,
@@ -119,14 +119,14 @@ impl InferenceHost {
         public_response(py, self.module, response)
     }
 
-    pub fn error(&self, py: Python<'_>, error: RouteError) -> PyResult<PyErr> {
-        if let RouteError::Secret(source) = &error
+    pub fn error(&self, py: Python<'_>, error: Error) -> PyResult<PyErr> {
+        if let Error::Secret(source) = &error
             && let Some(original) = crate::secrets::python_error(py, source.source_error())
         {
             return Ok(original);
         }
         let native = match error {
-            RouteError::Transport(TransportError::Http { status, body }) => {
+            Error::Transport(TransportError::Http { status, body }) => {
                 let error = RustUpstreamError::new_err((status, body));
                 error
                     .value(py)
@@ -144,7 +144,7 @@ impl InferenceHost {
 }
 
 pub(super) trait InferenceRoute: Sized + 'static {
-    type Protocol: Protocol<Error = RouteError>;
+    type Protocol: Protocol<Error = Error>;
     const OPERATION: LoggingOperation;
     const SYNC_CALL_TYPE: &'static str;
     const ASYNC_CALL_TYPE: &'static str;

litellm/constants.py

@@ -611,6 +611,7 @@ NON_LLM_CONNECTION_TIMEOUT: Final = get_env_int(
 )  # timeout for adjacent services (e.g. jwt auth)
 MAX_EXCEPTION_MESSAGE_LENGTH: Final = get_env_int("MAX_EXCEPTION_MESSAGE_LENGTH", 2000)
 MAX_STRING_LENGTH_PROMPT_IN_DB: Final = get_env_int("MAX_STRING_LENGTH_PROMPT_IN_DB", 2048)
+MAX_STRING_LENGTH_COMPACTION_SUMMARY_IN_DB: Final = 64 * 1024
 BEDROCK_MAX_POLICY_SIZE: Final = get_env_int("BEDROCK_MAX_POLICY_SIZE", 75)
 # One entry per distinct AWS credential-argument set. Per-user cost attribution passes the attributed
 # identity as aws_session_name, so this bounds how many attributed identities keep a cached STS session.

litellm/cost_calculator.py

@@ -1673,8 +1673,10 @@ def completion_cost(
                     verbose_logger.debug("selected model name for cost calculation: %s", model)
 
                 if completion_response is not None and (
-                    isinstance(completion_response, BaseModel) or isinstance(completion_response, dict)
-                ):  # tts returns a custom class
+                    isinstance(completion_response, (BaseModel, dict))
+                    or isinstance(completion_response, HttpxBinaryResponseContent)
+                    and completion_response.usage is not None
+                ):
                     if isinstance(completion_response, dict):
                         usage_obj: dict | Usage | None = completion_response.get("usage", {})
                     else:

litellm/endpoints/speech/speech_to_completion_bridge/handler.py

@@ -122,6 +122,7 @@ class SpeechToCompletionBridgeHandler:
         if isinstance(result, ModelResponse):
             return self.transformation_handler.transform_response(
                 model_response=result,
+                model=model,
                 response_format=requested_response_format if isinstance(requested_response_format, str) else None,
             )
         else:

litellm/endpoints/speech/speech_to_completion_bridge/transformation.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Final, cast
 from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 from litellm.constants import OPENAI_CHAT_COMPLETION_PARAMS
+from litellm.litellm_core_utils.core_helpers import drops_unsupported_params
 from litellm.litellm_core_utils.hidden_params import get_hidden_params, served_from_cache, set_hidden_param
 
 if TYPE_CHECKING:
@@ -38,6 +39,11 @@ class ChatAudioParam(TypedDict):
     format: ReadOnly[NotRequired[str]]
 
 
+class ChatSpeechConfigAudioParam(TypedDict):
+    speech_config: ReadOnly[Mapping[str, object]]
+    format: ReadOnly[str]
+
+
 class SpeechToCompletionBridgeTransformationHandler:
     def _validate_response_format(
         self, model: str, custom_llm_provider: str, optional_params: Mapping[str, object]
@@ -49,6 +55,20 @@ class SpeechToCompletionBridgeTransformationHandler:
             return
         from litellm.exceptions import BadRequestError
 
+        if custom_llm_provider.startswith("vertex_ai"):
+            from litellm.llms.vertex_ai.text_to_speech.transformation import VertexAITextToSpeechConfig
+
+            vertex_supported: Final = ", ".join(
+                sorted({*GEMINI_TTS_SUPPORTED_RESPONSE_FORMATS, *VertexAITextToSpeechConfig.GEMINI_FORMAT_MAPPINGS})
+            )
+            raise BadRequestError(
+                message=(
+                    f"Vertex AI Gemini TTS does not support response_format='{response_format}'."
+                    f" Supported response formats: {vertex_supported}."
+                ),
+                model=model,
+                llm_provider=custom_llm_provider,
+            )
         supported: Final = ", ".join(sorted(GEMINI_TTS_SUPPORTED_RESPONSE_FORMATS))
         raise BadRequestError(
             message=(
@@ -75,8 +95,27 @@ class SpeechToCompletionBridgeTransformationHandler:
         return response_format if isinstance(response_format, str) else None
 
     def _chat_audio_param(
-        self, model: str, voice: str | Mapping[str, object] | None, optional_params: Mapping[str, object]
-    ) -> ChatAudioParam | None:
+        self,
+        model: str,
+        voice: str | Mapping[str, object] | None,
+        optional_params: Mapping[str, object],
+        drop_params: bool,
+        custom_llm_provider: str,
+    ) -> ChatAudioParam | ChatSpeechConfigAudioParam | None:
+        import litellm
+
+        if isinstance(voice, Mapping) and self._is_gemini_tts_model(litellm.model_alias_map.get(model, model)):
+            from litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import (
+                normalize_gemini_speech_config,
+                reject_unknown_gemini_tts_voice_keys,
+            )
+
+            reject_unknown_gemini_tts_voice_keys(model, voice, drop_params, custom_llm_provider)
+            speech_audio: Final[ChatSpeechConfigAudioParam] = {
+                "speech_config": normalize_gemini_speech_config(voice, drops_unsupported_params(drop_params)),
+                "format": GEMINI_TTS_CHAT_AUDIO_FORMAT,
+            }
+            return speech_audio
         if not isinstance(voice, str):
             return None
         audio_format: Final = self._chat_audio_format(model, optional_params)
@@ -90,9 +129,9 @@ class SpeechToCompletionBridgeTransformationHandler:
         self,
         model: str,
         input: str,
-        voice: str | dict | None,
-        optional_params: dict,
-        litellm_params: dict,
+        voice: str | Mapping[str, object] | None,
+        optional_params: Mapping[str, object],
+        litellm_params: Mapping[str, object],
         headers: dict,
         litellm_logging_obj: "LiteLLMLoggingObj",
         custom_llm_provider: str,
@@ -104,7 +143,13 @@ class SpeechToCompletionBridgeTransformationHandler:
             "messages": [user_message],
             "modalities": ["audio"],
             **self._chat_completion_params(optional_params),
-            "audio": self._chat_audio_param(model, voice, optional_params),
+            "audio": self._chat_audio_param(
+                model,
+                voice,
+                optional_params,
+                drops_unsupported_params(litellm_params.get("drop_params")),
+                custom_llm_provider,
+            ),
             **litellm_params,
             "headers": headers,
             "litellm_logging_obj": litellm_logging_obj,
@@ -153,8 +198,9 @@ class SpeechToCompletionBridgeTransformationHandler:
         return wav_header + pcm_data
 
     def _is_gemini_tts_model(self, model: str) -> bool:
-        """Check if the model is a Gemini TTS model that returns PCM16 data."""
-        return "gemini" in model.lower() and ("tts" in model.lower() or "preview-tts" in model.lower())
+        from litellm.utils import is_gemini_tts_model
+
+        return is_gemini_tts_model(model)
 
     def _gemini_tts_response_body(self, decoded_audio: bytes, response_format: str | None) -> tuple[bytes, str]:
         if response_format == GEMINI_TTS_RAW_RESPONSE_FORMAT:
@@ -162,7 +208,7 @@ class SpeechToCompletionBridgeTransformationHandler:
         return self._convert_pcm16_to_wav(decoded_audio), "audio/wav"
 
     def transform_response(
-        self, model_response: "ModelResponse", response_format: str | None
+        self, model_response: "ModelResponse", model: str, response_format: str | None
     ) -> "HttpxBinaryResponseContent":
         import base64
 
@@ -176,10 +222,9 @@ class SpeechToCompletionBridgeTransformationHandler:
             raise ValueError("No audio part found in the response")
         decoded_audio: Final = base64.b64decode(audio_part.data)
 
-        model: Final = getattr(model_response, "model", "")
         content, content_type = (
             self._gemini_tts_response_body(decoded_audio, response_format)
-            if self._is_gemini_tts_model(model)
+            if self._is_gemini_tts_model(model) or self._is_gemini_tts_model(model_response.model or "")
             else (decoded_audio, "audio/mpeg")
         )
         response: Final = httpx.Response(

litellm/integrations/deepeval/types.py

@@ -1,6 +1,6 @@
 # Duplicate -> https://github.com/confident-ai/deepeval/blob/main/deepeval/tracing/api.py
 from enum import Enum
-from typing import Any, ClassVar, Literal
+from typing import ClassVar, Literal
 
 from pydantic import ConfigDict, Field
 
@@ -55,7 +55,7 @@ class TraceApi(LiteLLMBaseModel):
     tool_spans: list[BaseApiSpan] = Field(alias="toolSpans")
     start_time: str = Field(alias="startTime")
     end_time: str = Field(alias="endTime")
-    metadata: dict[str, Any] | None = Field(None)
+    metadata: dict[str, object] | None = Field(None)
     tags: list[str] | None = Field(None)
     environment: str | None = Field(None)
 

litellm/interactions/litellm_responses_transformation/streaming_iterator.py

@@ -3,8 +3,8 @@ Streaming iterator for transforming Responses API stream to Interactions API str
 """
 
 from collections import deque
-from collections.abc import AsyncIterator, Iterator
-from typing import Any, Final, cast
+from collections.abc import AsyncIterator, Iterator, Mapping
+from typing import Final, cast
 
 from litellm.responses.streaming_iterator import (
     BaseResponsesAPIStreamingIterator,
@@ -44,7 +44,7 @@ class LiteLLMResponsesInteractionsStreamingIterator:
         request_input: InteractionInput | None,
         optional_params: InteractionsAPIOptionalRequestParams,
         custom_llm_provider: str | None = None,
-        litellm_metadata: dict[str, Any] | None = None,
+        litellm_metadata: Mapping[str, object] | None = None,
     ):
         self.model = model
         self.responses_stream_iterator = litellm_custom_stream_wrapper

litellm/litellm_core_utils/core_helpers.py

@@ -329,11 +329,14 @@ def add_missing_spend_metadata_to_litellm_metadata(litellm_metadata: dict, metad
     Helper to get litellm metadata for spend tracking
 
     PATCH for issue where both `litellm_metadata` and `metadata` are present in the kwargs
-    and user_api_key values are in 'metadata'.
+    and user_api_key values are in 'metadata'. The proxy receive stamp rides along for the same
+    reason: a guardrail hook can plant `litellm_metadata` on a chat request after the proxy stamped
+    `metadata`, and the response timing headers anchor on that stamp.
     """
     potential_spend_tracking_metadata_substring: Final = "user_api_key"
     for key, value in dict(metadata).items():
-        if potential_spend_tracking_metadata_substring in key:
+        carry_receive_stamp = key == "litellm_received_at" and key not in litellm_metadata
+        if potential_spend_tracking_metadata_substring in key or carry_receive_stamp:
             litellm_metadata[key] = value
     return litellm_metadata
 

litellm/litellm_core_utils/litellm_logging.py

@@ -604,6 +604,10 @@ def _timestamp_seconds(moment: object) -> float | None:
     return None
 
 
+def same_attempt_marker(first: object, second: object) -> bool:
+    return first is second or first == second
+
+
 class Logging(LiteLLMLoggingBaseClass):
     global \
         supabaseClient, \
@@ -625,6 +629,7 @@ class Logging(LiteLLMLoggingBaseClass):
     classifier_input: Mapping[str, JsonValue] | None = None
     baseline_cache_context: "BaselineCacheContext | None" = None
     baseline_observation: "CapturedBaselineObservation | None" = None
+    _on_failure_payload_built: "Callable[[], None] | None" = None
 
     @property
     def _defer_async_logging(self) -> bool:
@@ -852,6 +857,7 @@ class Logging(LiteLLMLoggingBaseClass):
             "litellm_call_id": litellm_call_id,
             "start_time": start_time,
             "first_api_call_start_time": None,
+            "current_attempt_api_call_start_time": None,
             "litellm_params": litellm_params,
         }
         new_call.streaming_chunks = []
@@ -1602,7 +1608,9 @@ class Logging(LiteLLMLoggingBaseClass):
             # A proxy-gate failure (auth, rate limit, client disconnect) fires pre_call for its callbacks
             # without any provider handoff, so it must not stamp the handoff instants.
             if LITELLM_LOGGING_NO_UPSTREAM_LLM_CALL not in self.model_call_details:
-                self.model_call_details["api_call_start_time"] = datetime.datetime.now()
+                api_call_start_time: Final = datetime.datetime.now()
+                self.model_call_details["api_call_start_time"] = api_call_start_time
+                self.model_call_details["current_attempt_api_call_start_time"] = api_call_start_time
                 # Set-once first provider-handoff instant. api_call_start_time
                 # is overwritten on every retry, so it can't measure one-time
                 # preprocessing; pinning the first attempt excludes retry loops
@@ -1610,9 +1618,7 @@ class Logging(LiteLLMLoggingBaseClass):
                 # litellm_params["metadata"] (caller request metadata, typed
                 # Dict[str, str], echoed downstream; a datetime breaks it).
                 if self.model_call_details.get("first_api_call_start_time") is None:
-                    self.model_call_details["first_api_call_start_time"] = self.model_call_details[
-                        "api_call_start_time"
-                    ]
+                    self.model_call_details["first_api_call_start_time"] = api_call_start_time
             # Input Integration Logging -> If you want to log the fact that an attempt to call the model was made
             callbacks: Final = (
                 *self._without_replaced_global_callbacks(litellm.input_callback),
@@ -2474,12 +2480,37 @@ class Logging(LiteLLMLoggingBaseClass):
         attempt.model_call_details = dict(self.model_call_details)
         return attempt
 
+    def dispatch_attempt_failure_handlers(
+        self, exception: Exception, traceback_exception: str
+    ) -> Coroutine[None, None, None]:
+        shared_payload: Final = self.model_call_details.get("standard_logging_object")
+        attempt_marker: Final = self.model_call_details.get("current_attempt_api_call_start_time")
+        attempt: Final = self.attempt_scoped_copy()
+
+        def publish() -> None:
+            attempt_payload: Final = attempt.model_call_details.get("standard_logging_object")
+            current_marker: Final = self.model_call_details.get("current_attempt_api_call_start_time")
+            if (
+                attempt_payload is not None
+                and self.model_call_details.get("standard_logging_object") is shared_payload
+                and same_attempt_marker(current_marker, attempt_marker)
+            ):
+                self.model_call_details["standard_logging_object"] = attempt_payload
+
+        attempt._on_failure_payload_built = publish
+
+        async def dispatch() -> None:
+            await attempt.dispatch_failure_handlers(exception, traceback_exception, prefer_async_handlers=True)
+
+        return dispatch()
+
     def carry_failed_attempt_usage(self) -> None:
         """Move what a failed earlier attempt stashed off the retry sharing this logging object, so the retry logs its
         own usage while the request's failure log still bills every attempt."""
         usage: Final = self.model_call_details.pop("combined_usage_object", None)
         response_cost: Final = self.model_call_details.pop("response_cost", None)
         if isinstance(usage, Usage):
+            self.model_call_details["current_attempt_api_call_start_time"] = None
             self.model_call_details["failed_attempts_usage"] = (
                 *self.model_call_details.get("failed_attempts_usage", ()),
                 (usage, float(response_cost) if isinstance(response_cost, (int, float)) else 0.0),
@@ -2593,6 +2624,10 @@ class Logging(LiteLLMLoggingBaseClass):
             """
             return
         self.model_call_details[f"has_logged_{event_type}"] = True
+        if event_type == "async_failure":
+            self.model_call_details["async_failure_logged_attempt"] = self.model_call_details.get(
+                "current_attempt_api_call_start_time"
+            )
         return
 
     def has_run_logging(
@@ -4410,7 +4445,8 @@ class Logging(LiteLLMLoggingBaseClass):
             start_time=start_time,
             end_time=end_time,
         )
-
+        if self._on_failure_payload_built is not None:
+            self._on_failure_payload_built()
         callbacks: Final = self.get_combined_callback_list(
             dynamic_success_callbacks=self.dynamic_async_failure_callbacks,
             global_callbacks=litellm._async_failure_callback,

litellm/litellm_core_utils/redact_messages.py

@@ -24,6 +24,7 @@ from litellm.litellm_core_utils.core_helpers import (
     get_metadata_variable_name_from_kwargs,
 )
 from litellm.litellm_core_utils.served_output_texts import SERVED_OUTPUT_TEXTS_KEY
+from litellm.llms.base_llm.guardrail_translation.utils import stream_item_field, stream_item_items
 from litellm.llms.vertex_ai.common_utils import (
     redact_vertex_ai_metadata_from_litellm_params,
     redact_vertex_ai_metadata_from_logged_object,
@@ -41,6 +42,8 @@ if TYPE_CHECKING:
 else:
     LiteLLMLoggingObject = Any
 
+MESSAGE_REDACTION_ENABLE_HEADERS: Final = ("litellm-enable-message-redaction", "x-litellm-enable-message-redaction")
+
 
 def _opted_out_of_message_logging(custom_logger: CustomLogger) -> bool:
     return hasattr(custom_logger, "message_logging") and custom_logger.message_logging is not True
@@ -195,33 +198,45 @@ def _redacted_provider_specific_fields(fields: Mapping[str, object]) -> Mapping[
     return {
         **fields,
         **({"reasoning_content": REDACTED_BY_LITELLM} if fields.get("reasoning_content") is not None else {}),
-        **{key: None for key in ("thinking_blocks", "reasoningContentBlocks", "citations") if key in fields},
+        **{
+            key: None
+            for key in (
+                "thinking_blocks",
+                "reasoningContentBlocks",
+                "citations",
+                "compaction_blocks",
+                "compaction_delta",
+            )
+            if key in fields
+        },
     }
 
 
+def _redact_field_when_present(item: object, field: str) -> None:
+    if getattr(item, field, None) is not None:
+        setattr(item, field, REDACTED_BY_LITELLM)
+
+
 def _redact_responses_api_output(output_items):
     """Helper to redact ResponsesAPIResponse output items."""
     for output_item in output_items:
+        output_type = stream_item_field(output_item, "type")
         if getattr(output_item, "text", None) is not None:
             output_item.text = REDACTED_BY_LITELLM
 
-        if hasattr(output_item, "content") and isinstance(output_item.content, list):
-            for content_part in output_item.content:
-                if getattr(content_part, "text", None) is not None:
-                    content_part.text = REDACTED_BY_LITELLM
-                if getattr(content_part, "refusal", None) is not None:
-                    content_part.refusal = REDACTED_BY_LITELLM
+        for content_part in stream_item_items(output_item, "content"):
+            _redact_field_when_present(content_part, "text")
+            _redact_field_when_present(content_part, "refusal")
 
-        # Redact reasoning items in output array
-        if hasattr(output_item, "type") and output_item.type == "reasoning":
-            if hasattr(output_item, "summary") and isinstance(output_item.summary, list):
-                for summary_item in output_item.summary:
-                    if getattr(summary_item, "text", None) is not None:
-                        summary_item.text = REDACTED_BY_LITELLM
+        if output_type == "reasoning":
+            for summary_item in stream_item_items(output_item, "summary"):
+                _redact_field_when_present(summary_item, "text")
 
-        if hasattr(output_item, "type") and output_item.type == "function_call" and hasattr(output_item, "arguments"):
+        if output_type == "compaction" and hasattr(output_item, "encrypted_content"):
+            output_item.encrypted_content = REDACTED_BY_LITELLM
+        if output_type == "function_call" and hasattr(output_item, "arguments"):
             output_item.arguments = REDACTED_BY_LITELLM
-        if hasattr(output_item, "type") and output_item.type == "custom_tool_call" and hasattr(output_item, "input"):
+        if output_type == "custom_tool_call" and hasattr(output_item, "input"):
             output_item.input = REDACTED_BY_LITELLM
 
 
@@ -262,6 +277,11 @@ def _redacted_responses_api_output_item(item: object, redacted_str: str) -> obje
             if item_mapping.get("type") == "reasoning" and isinstance(summary, list)
             else {}
         ),
+        **(
+            {"encrypted_content": redacted_str}
+            if item_mapping.get("type") == "compaction" and "encrypted_content" in item_mapping
+            else {}
+        ),
         **(
             {"arguments": redacted_str}
             if item_mapping.get("type") == "function_call" and "arguments" in item_mapping
@@ -556,13 +576,8 @@ def should_redact_message_logging(model_call_details: dict) -> bool:
         # User explicitly disabled redaction via header
         return False
 
-    possible_enable_headers: Final = [
-        "litellm-enable-message-redaction",  # old header. maintain backwards compatibility
-        "x-litellm-enable-message-redaction",  # new header
-    ]
-
     is_redaction_enabled_via_header = False
-    for header in possible_enable_headers:
+    for header in MESSAGE_REDACTION_ENABLE_HEADERS:
         if bool(request_headers.get(header, False)):
             is_redaction_enabled_via_header = True
             break

litellm/litellm_core_utils/streaming_handler.py

@@ -2283,12 +2283,7 @@ class CustomStreamWrapper:
             traceback_exception = traceback.format_exc()
             ## ADD DEBUG INFORMATION - E.G. LITELLM REQUEST TIMEOUT
             traceback_exception += f"\nLiteLLM Default Request Timeout - {litellm.request_timeout}"
-            if self.logging_obj is not None:
-                self._record_partial_usage_for_failure()
-                ## LOGGING
-                self._failure_logging = asyncio.create_task(
-                    self.logging_obj.dispatch_failure_handlers(e, traceback_exception, prefer_async_handlers=True)
-                )
+            self._dispatch_stream_failure(e, traceback_exception)
             await self.aclose()
             self._handle_stream_fallback_error(e)
         except (httpx.ReadError, httpx.RemoteProtocolError) as e:
@@ -2389,16 +2384,20 @@ class CustomStreamWrapper:
             return processed_chunk
 
     def _log_stream_failure_and_raise(self, e: Exception) -> NoReturn:
-        traceback_exception: Final = traceback.format_exc()
-        if self.logging_obj is not None:
-            self._record_partial_usage_for_failure()
-            ## LOGGING
-            self._failure_logging = asyncio.create_task(
-                self.logging_obj.dispatch_failure_handlers(e, traceback_exception, prefer_async_handlers=True)
-            )
+        self._dispatch_stream_failure(e, traceback.format_exc())
         self._handle_stream_fallback_error(e)
 
-    async def wait_for_failure_logging(self, timeout: float) -> None:
+    def _dispatch_stream_failure(self, e: Exception, traceback_exception: str) -> None:
+        self._record_partial_usage_for_failure()
+        self._failure_logging = asyncio.create_task(
+            self.logging_obj.dispatch_attempt_failure_handlers(e, traceback_exception)
+        )
+
+    @property
+    def has_dispatched_failure_logging(self) -> bool:
+        return self._failure_logging is not None
+
+    async def wait_for_failure_logging(self, timeout: float | None) -> None:
         """Let this stream's failure log read its own deployment before a fallback reuses the logging object."""
         if self._failure_logging is None:
             return
@@ -2412,9 +2411,9 @@ class CustomStreamWrapper:
         A stream that breaks mid-flight still billed the provider for the chunks
         already delivered. Recover that partial usage from the chunks seen so
         far and stash it, with its cost, on the logging object so the failure
-        handler records the real partial spend instead of zero. A request that
-        later recovers via a router fallback overwrites this with the combined
-        success log on the same request id, so this never double counts.
+        handler records the real partial spend instead of zero. The router
+        moves it into terminal failure usage before opening the next attempt,
+        so a recovered attempt logs its own usage.
         """
         if self.logging_obj is None or not self.chunks:
             return

litellm/litellm_core_utils/url_utils.py

@@ -23,7 +23,7 @@ import asyncio
 import socket
 from ipaddress import ip_address, ip_network
 from typing import Any, Final, Protocol
-from urllib.parse import quote, urlparse, urlunparse
+from urllib.parse import quote, urlparse, urlsplit, urlunparse
 
 import httpx
 from typing_extensions import ReadOnly, TypedDict
@@ -129,6 +129,28 @@ def encode_url_path_segments(value: object, *, field_name: str = "path") -> str:
     return "/".join(encode_url_path_segment(segment, field_name=field_name) for segment in value_str.split("/"))
 
 
+def _strip_trailing_slashes_keeping_the_scheme(api_base: str) -> str:
+    stripped: Final = api_base.rstrip("/")
+    parts: Final = urlsplit(stripped)
+    if parts.scheme and not (parts.netloc or parts.path or parts.query or parts.fragment):
+        return api_base
+    if not parts.query or not parts.path.endswith("/"):
+        return stripped
+    url_before_query, _, query = stripped.partition("?")
+    return f"{url_before_query.rstrip('/')}?{query}"
+
+
+def join_api_base(api_base: str, route: str) -> str:
+    return f"{_strip_trailing_slashes_keeping_the_scheme(api_base)}/{route.lstrip('/')}"
+
+
+def ensure_api_route(api_base: str, route: str) -> str:
+    base: Final = _strip_trailing_slashes_keeping_the_scheme(api_base)
+    if urlsplit(base).path.endswith(f"/{route.lstrip('/')}"):
+        return base
+    return join_api_base(base, route)
+
+
 def _is_blocked_ip(addr: str) -> bool:
     """Return True for any IP not safe to reach from a user-supplied URL.
 

litellm/llms/aiml/image_generation/transformation.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Final
 import httpx
 from pydantic import ConfigDict, TypeAdapter
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.image_generation.transformation import (
     BaseImageGenerationConfig,
 )
@@ -121,7 +122,7 @@ class AimlImageGenerationConfig(BaseImageGenerationConfig):
         complete_url = complete_url.rstrip("/")
         # Strip /v1 suffix if present since IMAGE_GENERATION_ENDPOINT already includes v1
         complete_url = complete_url.removesuffix("/v1")
-        complete_url = f"{complete_url}/{self.IMAGE_GENERATION_ENDPOINT}"
+        complete_url = join_api_base(complete_url, self.IMAGE_GENERATION_ENDPOINT)
         return complete_url
 
     def validate_environment(

litellm/llms/aiohttp_openai/chat/transformation.py

@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Any, Final
 from aiohttp import ClientResponse
 from pydantic import ConfigDict, TypeAdapter
 
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.openai_like.chat.transformation import OpenAILikeChatConfig
 from litellm.types.llms.openai import AllMessageValues
 from litellm.types.utils import Choices, ModelResponse
@@ -44,12 +45,7 @@ class AiohttpOpenAIChatConfig(OpenAILikeChatConfig):
         Ensure - /v1/chat/completions is at the end of the url
 
         """
-        if api_base is None:
-            api_base = "https://api.openai.com"
-
-        if not api_base.endswith("/chat/completions"):
-            api_base += "/chat/completions"
-        return api_base
+        return ensure_api_route("https://api.openai.com" if api_base is None else api_base, "chat/completions")
 
     def validate_environment(
         self,

litellm/llms/anthropic/batches/transformation.py

@@ -7,7 +7,7 @@ import httpx
 from httpx import Headers, Response
 from typing_extensions import ReadOnly, TypedDict
 
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, ensure_api_route, join_api_base
 from litellm.llms.base_llm.batches.transformation import BaseBatchesConfig
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.types.llms.openai import AllMessageValues, CreateBatchRequest
@@ -106,10 +106,8 @@ class AnthropicBatchesConfig(BaseBatchesConfig):
         data: CreateBatchRequest,
     ) -> str:
         """Get the complete URL for batch creation request."""
-        api_base = api_base or self.anthropic_model_info.get_api_base(api_base)
-        if not api_base.endswith("/v1/messages/batches"):
-            api_base = f"{api_base.rstrip('/')}/v1/messages/batches"
-        return api_base
+        api_base = self.anthropic_model_info.resolve_anthropic_api_base(api_base)
+        return ensure_api_route(api_base, "v1/messages/batches")
 
     def transform_create_batch_request(
         self,
@@ -158,9 +156,9 @@ class AnthropicBatchesConfig(BaseBatchesConfig):
         Returns:
             Complete URL for Anthropic batch retrieval: {api_base}/v1/messages/batches/{batch_id}
         """
-        api_base = api_base or self.anthropic_model_info.get_api_base(api_base)
+        api_base = self.anthropic_model_info.resolve_anthropic_api_base(api_base)
         encoded_batch_id: Final = encode_url_path_segment(batch_id, field_name="batch_id")
-        return f"{api_base.rstrip('/')}/v1/messages/batches/{encoded_batch_id}"
+        return join_api_base(api_base, f"v1/messages/batches/{encoded_batch_id}")
 
     def transform_retrieve_batch_request(
         self,

litellm/llms/anthropic/chat/handler.py

@@ -856,11 +856,21 @@ class ModelResponseIterator:
                 if reasoning_content is None:
                     reasoning_content = ""
         elif "content" in content_block["delta"] and content_block["delta"].get("type") == "compaction_delta":
-            # Handle compaction delta
+            compaction_delta: Final = content_block["delta"]["content"]
             provider_specific_fields["compaction_delta"] = {
                 "type": "compaction_delta",
-                "content": content_block["delta"]["content"],
+                "content": compaction_delta,
             }
+            if self.compaction_blocks and isinstance(compaction_delta, str):
+                streamed_summary: Final = self.compaction_blocks[-1].get("content")
+                self.compaction_blocks = [
+                    *self.compaction_blocks[:-1],
+                    {
+                        **self.compaction_blocks[-1],
+                        "content": (streamed_summary if isinstance(streamed_summary, str) else "") + compaction_delta,
+                    },
+                ]
+                provider_specific_fields["compaction_blocks"] = self.compaction_blocks
 
         return (
             text,

litellm/llms/anthropic/common_utils.py

@@ -35,6 +35,7 @@ from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import
     parts_of,
 )
 from litellm.litellm_core_utils.reasoning_effort_utils import non_numeric_thinking_budget_error
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.anthropic.wif import (
     aget_anthropic_wif_token,
     anthropic_base_without_chat_suffix,
@@ -468,7 +469,7 @@ def _fetch_anthropic_models_page(
     # which a read-only one cannot support
     query: Final = f"?after_id={quote(after_id)}" if after_id else ""
     response: Final = litellm.module_level_client.get(
-        url=f"{api_base}/v1/models{query}",
+        url=f"{join_api_base(api_base, 'v1/models')}{query}",
         headers=headers,
         follow_redirects=False,
     )
@@ -1406,7 +1407,7 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         return {**caller_headers, **anthropic_headers}
 
     @staticmethod
-    def get_api_base(api_base: str | None = None) -> str | None:
+    def resolve_anthropic_api_base(api_base: str | None = None) -> str:
         from litellm.secret_managers.main import get_secret_str
 
         return (
@@ -1416,6 +1417,10 @@ class AnthropicModelInfo(BaseLLMModelInfo):
             or "https://api.anthropic.com"
         )
 
+    @staticmethod
+    def get_api_base(api_base: str | None = None) -> str | None:
+        return AnthropicModelInfo.resolve_anthropic_api_base(api_base)
+
     @staticmethod
     def get_api_key(api_key: str | None = None) -> str | None:
         """An empty or whitespace-only key counts as unset: it can never authenticate anything, and
@@ -1533,14 +1538,14 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         api_base: str | None,
         litellm_params: Mapping[str, object] | None,
     ) -> list[str]:  # mutable-ok: matches get_models' list[str] contract shared by every provider override
-        resolved_api_base: Final = AnthropicModelInfo.get_api_base(api_base)
+        resolved_api_base: Final = AnthropicModelInfo.resolve_anthropic_api_base(api_base)
         auth_header: Final = AnthropicModelInfo.get_auth_header(
             api_key,
             resolved_api_base,
             litellm_params=litellm_params,
             allow_workload_identity=config_allows_workload_identity(self),
         )
-        if resolved_api_base is None or auth_header is None:
+        if auth_header is None:
             raise ValueError(
                 "ANTHROPIC_API_BASE/ANTHROPIC_BASE_URL or ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN (or workload "
                 "identity federation via ANTHROPIC_FEDERATION_RULE_ID/ANTHROPIC_ORGANIZATION_ID/"

litellm/llms/anthropic/count_tokens/transformation.py

@@ -25,6 +25,7 @@ from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import
     anthropic_system_blocks,
     split_leading_system_run,
 )
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.anthropic.common_utils import merge_anthropic_beta_headers
 from litellm.llms.anthropic.wif import resolve_anthropic_base
 from litellm.types.llms.openai import AllMessageValues, ChatCompletionImageObject, ValidUserMessageContentTypes
@@ -317,7 +318,7 @@ class AnthropicCountTokensConfig:
         Returns:
             The endpoint URL for the CountTokens API
         """
-        return resolve_anthropic_base(api_base) + "/v1/messages/count_tokens"
+        return join_api_base(resolve_anthropic_base(api_base), "v1/messages/count_tokens")
 
     def transform_request_to_count_tokens(
         self,

litellm/llms/anthropic/files/handler.py

@@ -10,7 +10,7 @@ import litellm
 from litellm._logging import verbose_logger
 from litellm._uuid import uuid
 from litellm.litellm_core_utils.litellm_logging import Logging
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
 from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
 from litellm.types.llms.openai import (
     FileContentRequest,
@@ -74,7 +74,7 @@ class AnthropicFilesHandler:
             batch_id = file_id
 
         # Get Anthropic API credentials
-        api_base = self.anthropic_model_info.get_api_base(api_base)
+        api_base = self.anthropic_model_info.resolve_anthropic_api_base(api_base)
         auth_header: Final = await self.anthropic_model_info.aget_auth_header(
             api_key, api_base, litellm_params=litellm_params, allow_workload_identity=True
         )
@@ -84,7 +84,7 @@ class AnthropicFilesHandler:
 
         # Construct the Anthropic batch results URL
         encoded_batch_id: Final = encode_url_path_segment(batch_id, field_name="batch_id")
-        results_url: Final = f"{api_base.rstrip('/')}/v1/messages/batches/{encoded_batch_id}/results"
+        results_url: Final = join_api_base(api_base, f"v1/messages/batches/{encoded_batch_id}/results")
 
         # Prepare headers
         headers: Final = {

litellm/llms/anthropic/files/transformation.py

@@ -22,7 +22,7 @@ from openai.types.file_deleted import FileDeleted
 from pydantic import ConfigDict, TypeAdapter
 
 from litellm.litellm_core_utils.prompt_templates.common_utils import extract_file_data
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.files.transformation import (
     BaseFilesConfig,
@@ -80,7 +80,7 @@ class AnthropicFilesConfig(BaseFilesConfig):
         stream: bool | None = None,
     ) -> str:
         api_base = AnthropicModelInfo.get_api_base(api_base) or ANTHROPIC_FILES_API_BASE
-        return f"{api_base.rstrip('/')}/v1/files"
+        return join_api_base(api_base, "v1/files")
 
     def get_error_class(
         self,
@@ -226,7 +226,7 @@ class AnthropicFilesConfig(BaseFilesConfig):
     ) -> tuple[str, dict]:
         api_base: Final = AnthropicModelInfo.get_api_base(litellm_params.get("api_base")) or ANTHROPIC_FILES_API_BASE
         encoded_file_id: Final = encode_url_path_segment(file_id, field_name="file_id")
-        return f"{api_base.rstrip('/')}/v1/files/{encoded_file_id}", {}
+        return join_api_base(api_base, f"v1/files/{encoded_file_id}"), {}
 
     def transform_retrieve_file_response(
         self,
@@ -245,7 +245,7 @@ class AnthropicFilesConfig(BaseFilesConfig):
     ) -> tuple[str, dict]:
         api_base: Final = AnthropicModelInfo.get_api_base(litellm_params.get("api_base")) or ANTHROPIC_FILES_API_BASE
         encoded_file_id: Final = encode_url_path_segment(file_id, field_name="file_id")
-        return f"{api_base.rstrip('/')}/v1/files/{encoded_file_id}", {}
+        return join_api_base(api_base, f"v1/files/{encoded_file_id}"), {}
 
     def transform_delete_file_response(
         self,
@@ -264,7 +264,7 @@ class AnthropicFilesConfig(BaseFilesConfig):
         litellm_params: dict,
     ) -> tuple[str, dict]:
         api_base: Final = AnthropicModelInfo.get_api_base(litellm_params.get("api_base")) or ANTHROPIC_FILES_API_BASE
-        url: Final = f"{api_base.rstrip('/')}/v1/files"
+        url: Final = join_api_base(api_base, "v1/files")
         params: Final[dict[str, str]] = {}
         if purpose:
             params["purpose"] = purpose
@@ -299,8 +299,8 @@ class AnthropicFilesConfig(BaseFilesConfig):
         api_base: Final = AnthropicModelInfo.get_api_base(litellm_params.get("api_base")) or ANTHROPIC_FILES_API_BASE
         encoded_file_id: Final = encode_url_path_segment(file_id, field_name="file_id")
         if file_id.startswith(ANTHROPIC_MESSAGE_BATCH_ID_PREFIX):
-            return f"{api_base.rstrip('/')}/v1/messages/batches/{encoded_file_id}/results", {}
-        return f"{api_base.rstrip('/')}/v1/files/{encoded_file_id}/content", {}
+            return join_api_base(api_base, f"v1/messages/batches/{encoded_file_id}/results"), {}
+        return join_api_base(api_base, f"v1/files/{encoded_file_id}/content"), {}
 
     def transform_file_content_response(
         self,

litellm/llms/anthropic/pass_through/adapters/streaming_iterator.py

@@ -16,6 +16,7 @@ from typing import (
     Protocol,
     cast,
     get_args,
+    runtime_checkable,
 )
 
 from pydantic import TypeAdapter
@@ -65,6 +66,14 @@ class _ChunkStream(Protocol):
     def __aiter__(self) -> "AsyncIterator[ModelResponseStream]": ...
 
 
+@runtime_checkable
+class _FailureLoggingWaiter(Protocol):
+    @property
+    def has_dispatched_failure_logging(self) -> bool: ...
+
+    async def wait_for_failure_logging(self, timeout: float | None) -> None: ...
+
+
 def _optional_attr(obj: object, name: str) -> object:
     return getattr(obj, name, None)
 
@@ -189,6 +198,14 @@ class _CombinedChunkSplitter:
         self._held_calls: Mapping[int, tuple[ModelResponseStream, _ToolCallPart]] = MappingProxyType({})
         self._live_call_index: int | None = None
 
+    @property
+    def has_dispatched_failure_logging(self) -> bool:
+        return isinstance(self._stream, _FailureLoggingWaiter) and self._stream.has_dispatched_failure_logging is True
+
+    async def wait_for_failure_logging(self, timeout: float | None) -> None:
+        if isinstance(self._stream, _FailureLoggingWaiter):
+            await self._stream.wait_for_failure_logging(timeout=timeout)
+
     @property
     def chunks(self) -> "list[ModelResponseStream] | None":
         return cast(  # cast-ok: chunks is a list of ModelResponseStream on the inner stream
@@ -522,7 +539,9 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper):
         # Wrap the upstream stream so chunks that carry both content and a
         # finish_reason (fake-streamed providers) are split into two — see
         # _CombinedChunkSplitter.
-        super().__init__(_CombinedChunkSplitter(completion_stream))
+        combined_chunk_splitter: Final = _CombinedChunkSplitter(completion_stream)
+        super().__init__(combined_chunk_splitter)
+        self._combined_chunk_splitter: Final = combined_chunk_splitter
         self.model = model
         self._message_id: str = f"msg_{uuid.uuid4()}"
         if litellm_logging_obj is not None:
@@ -1244,7 +1263,10 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper):
                 if provider_error is e:
                     raise
                 raise provider_error from e
-            if logging_obj is not None:
+            stream_has_dispatched_failure_logging: Final = self._combined_chunk_splitter.has_dispatched_failure_logging
+            if stream_has_dispatched_failure_logging:
+                await self._combined_chunk_splitter.wait_for_failure_logging(timeout=None)
+            elif logging_obj is not None:
                 try:
                     await logging_obj.dispatch_failure_handlers(
                         exception=provider_error,

litellm/llms/anthropic/pass_through/messages/transformation.py

@@ -9,6 +9,7 @@ from litellm.anthropic_beta_headers_manager import get_unsupported_headers, is_b
 from litellm.exceptions import AuthenticationError
 from litellm.litellm_core_utils.core_helpers import drops_unsupported_params
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.anthropic.pass_through.convertible_blocks import drop_non_string_tool_result_texts
 from litellm.llms.anthropic.pass_through.safeguards import proxy_serves_safeguards
 from litellm.llms.base_llm.anthropic_messages.transformation import (
@@ -287,10 +288,7 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig):
         litellm_params: dict,
         stream: bool | None = None,
     ) -> str:
-        api_base = AnthropicModelInfo.get_api_base(api_base) or "https://api.anthropic.com"
-        if not api_base.endswith("/v1/messages"):
-            api_base = f"{api_base}/v1/messages"
-        return api_base
+        return ensure_api_route(AnthropicModelInfo.get_api_base(api_base) or "https://api.anthropic.com", "v1/messages")
 
     def validate_anthropic_messages_environment(
         self,

litellm/llms/anthropic/skills/transformation.py

@@ -9,7 +9,7 @@ import httpx
 from pydantic import TypeAdapter
 
 from litellm._logging import verbose_logger
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
 from litellm.llms.base_llm.skills.transformation import (
     BaseSkillsAPIConfig,
     LiteLLMLoggingObj,
@@ -75,13 +75,11 @@ class AnthropicSkillsConfig(BaseSkillsAPIConfig):
         """Get complete URL for Anthropic Skills API"""
         from litellm.llms.anthropic.common_utils import AnthropicModelInfo
 
-        if api_base is None:
-            api_base = AnthropicModelInfo.get_api_base()
-
+        resolved_api_base: Final = AnthropicModelInfo.get_api_base(api_base) or "https://api.anthropic.com"
         if skill_id:
             encoded_skill_id: Final = encode_url_path_segment(skill_id, field_name="skill_id")
-            return f"{api_base}/v1/skills/{encoded_skill_id}"
-        return f"{api_base}/v1/{endpoint}"
+            return join_api_base(resolved_api_base, f"v1/skills/{encoded_skill_id}")
+        return join_api_base(resolved_api_base, f"v1/{endpoint}")
 
     def transform_create_skill_request(
         self,

litellm/llms/anthropic/wif.py

@@ -15,6 +15,7 @@ from typing_extensions import assert_never
 
 import litellm
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.auth.client_credentials import keycloak_assertion_source
 from litellm.llms.base_llm.auth.identity_source import (
     AnthropicIdentitySourceKind,
@@ -324,7 +325,7 @@ def anthropic_internal_issuer_jwks(credential_values: Mapping[str, object]) -> A
 
 def build_anthropic_wif_spec(params: AnthropicWifParams, api_base: str) -> TokenExchangeSpec:
     return TokenExchangeSpec(
-        token_url=api_base.rstrip("/") + ANTHROPIC_TOKEN_EXCHANGE_PATH,
+        token_url=join_api_base(api_base, ANTHROPIC_TOKEN_EXCHANGE_PATH),
         assertion_ref=params.assertion_ref,
         assertion_field="assertion",
         static_body=MappingProxyType(

litellm/llms/apiserpent/search/transformation.py

@@ -14,6 +14,7 @@ from urllib.parse import urlencode
 import httpx
 
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.apiserpent.search.defaults import (
     DEEP_SEARCH_PATH,
     NUM_MAX,
@@ -77,13 +78,11 @@ class APISerpentSearchConfig(BaseSearchConfig):
         Build the search URL. APISerpent uses GET, so the transformed request is
         serialized into the query string. The endpoint path (quick vs deep) is
         always applied; an ``api_base`` / ``APISERPENT_API_BASE`` override only
-        changes the host. The ``endswith`` guard keeps this idempotent, since the
+        changes the host. ``ensure_api_route`` keeps this idempotent, since the
         handler re-invokes this method with the already-resolved URL as api_base.
         """
-        base = (api_base or get_secret_str("APISERPENT_API_BASE") or APISERPENT_BASE).rstrip("/")
         path: Final = DEEP_SEARCH_PATH if self._is_deep_search(optional_params) else QUICK_SEARCH_PATH
-        if not base.endswith(path):
-            base = f"{base}{path}"
+        base: Final = ensure_api_route(api_base or get_secret_str("APISERPENT_API_BASE") or APISERPENT_BASE, path)
 
         if data and isinstance(data, dict) and APISERPENT_PARAMS_KEY in data:
             query_string: Final = urlencode(data[APISERPENT_PARAMS_KEY], doseq=True)

litellm/llms/azure/audio_transcription/transformation.py

@@ -13,6 +13,7 @@ import httpx
 from pydantic import ConfigDict, TypeAdapter
 
 from litellm.litellm_core_utils.audio_utils.utils import process_audio_file
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.audio_transcription.transformation import (
     AudioTranscriptionRequestData,
     BaseAudioTranscriptionConfig,
@@ -110,7 +111,7 @@ class AzureSpeechAudioTranscriptionConfig(BaseAudioTranscriptionConfig):
             "language": optional_params.get("language", self.DEFAULT_LANGUAGE),
             "format": self._get_azure_response_format(optional_params.get("response_format")),
         }
-        return f"{base_url}{self.STT_ENDPOINT_PATH}?{urlencode(query_params)}"
+        return f"{join_api_base(base_url, self.STT_ENDPOINT_PATH)}?{urlencode(query_params)}"
 
     def transform_audio_transcription_request(
         self,
@@ -153,7 +154,6 @@ class AzureSpeechAudioTranscriptionConfig(BaseAudioTranscriptionConfig):
         )
 
     def _resolve_stt_base_url(self, api_base: str) -> str:
-        api_base = api_base.rstrip("/")
         parsed_url: Final = urlparse(api_base)
         hostname: Final = parsed_url.hostname or ""
 

litellm/llms/azure/common_utils.py

@@ -18,6 +18,7 @@ import litellm
 from litellm._logging import verbose_logger
 from litellm.caching.caching import DualCache
 from litellm.constants import DEFAULT_MAX_RETRIES
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.custom_httpx.http_handler import HTTPHandler
 from litellm.llms.openai.common_utils import BaseOpenAILLM, OpenAIAsyncHTTPClient, OpenAIHTTPClient
@@ -616,7 +617,7 @@ class BaseAzureLLM(BaseOpenAILLM):
 
             v1_params: Final[_AzureV1ClientParams] = {
                 "api_key": v1_api_key,
-                "base_url": f"{api_base}/openai/v1/",
+                "base_url": f"{ensure_api_route(api_base or '', 'openai/v1')}/",
             }
             if "timeout" in azure_client_params:
                 v1_params["timeout"] = azure_client_params["timeout"]

litellm/llms/azure/realtime/handler.py

@@ -10,6 +10,7 @@ from typing import Final, Protocol, cast
 
 from litellm._logging import verbose_proxy_logger
 from litellm.constants import REALTIME_WEBSOCKET_MAX_MESSAGE_SIZE_BYTES
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.types.realtime import RealtimeQueryParams
 
 from ....litellm_core_utils.litellm_logging import Logging as LiteLLMLogging
@@ -136,7 +137,8 @@ class AzureOpenAIRealtime(AzureChatCompletion):
             query_parts.append(urlencode({"intent": intent}))
 
         qs: Final = "&".join(query_parts)
-        return f"{api_base}{path}?{qs}" if qs else f"{api_base}{path}"
+        endpoint_url: Final = join_api_base(api_base, path)
+        return f"{endpoint_url}?{qs}" if qs else endpoint_url
 
     def construct_url(
         self,

litellm/llms/azure/realtime/http_transformation.py

@@ -3,6 +3,7 @@
 from typing import Final
 
 import litellm
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.realtime.http_transformation import BaseRealtimeHTTPConfig
 from litellm.secret_managers.main import get_secret_str
 
@@ -39,9 +40,9 @@ class AzureRealtimeHTTPConfig(BaseRealtimeHTTPConfig):
         return _azure_realtime_v1_url(self.get_api_base(api_base), "calls")
 
     def get_transcription_session_url(self, api_base: str | None, model: str, api_version: str | None = None) -> str:
-        base: Final = self.get_api_base(api_base).rstrip("/")
+        base: Final = self.get_api_base(api_base)
         version: Final = api_version or get_secret_str("AZURE_API_VERSION") or "2024-12-17"
-        return f"{base}/openai/realtime/transcription_sessions?api-version={version}"
+        return f"{join_api_base(base, 'openai/realtime/transcription_sessions')}?api-version={version}"
 
     def get_realtime_calls_headers(self, ephemeral_key: str) -> dict[str, str]:
         return {

litellm/llms/azure/search/transformation.py

@@ -35,6 +35,7 @@ from typing import TYPE_CHECKING, Final, Literal
 import httpx
 from pydantic import ConfigDict, ValidationError
 
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.azure.common_utils import cached_azure_ad_token_refresh_provider
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.search.transformation import (
@@ -340,10 +341,7 @@ class BingGroundingSearchConfig(BaseSearchConfig):
                 f"{PROJECT_ENDPOINT_ENV} is not set. Set it to your Microsoft Foundry project "
                 f"endpoint, e.g. https://<account>.services.ai.azure.com/api/projects/<project>."
             )
-        trimmed: Final = resolved_base.rstrip("/")
-        if trimmed.endswith(_RESPONSES_PATH):
-            return trimmed
-        return f"{trimmed}{_RESPONSES_PATH}"
+        return ensure_api_route(resolved_base, _RESPONSES_PATH)
 
     def transform_search_request(
         self,

litellm/llms/azure/text_to_speech/transformation.py

@@ -11,6 +11,7 @@ from urllib.parse import urlparse
 import httpx
 
 import litellm
+from litellm.litellm_core_utils.url_utils import ensure_api_route, join_api_base
 from litellm.llms.base_llm.text_to_speech.transformation import (
     BaseTextToSpeechConfig,
     TextToSpeechRequestData,
@@ -329,8 +330,6 @@ class AzureAVATextToSpeechConfig(BaseTextToSpeechConfig):
                 f"https://{{region}}.{self.TTS_SPEECH_DOMAIN}"
             )
 
-        # Remove trailing slash and parse URL
-        api_base = api_base.rstrip("/")
         parsed_url: Final = urlparse(api_base)
         hostname: Final = parsed_url.hostname or ""
 
@@ -339,14 +338,10 @@ class AzureAVATextToSpeechConfig(BaseTextToSpeechConfig):
             region: Final = self._extract_region_from_hostname(hostname=hostname, domain=self.COGNITIVE_SERVICES_DOMAIN)
             return self._build_tts_url(region=region)
 
-        # Check if it's already a TTS endpoint
         if self._is_tts_endpoint(hostname=hostname):
-            if not api_base.endswith(self.TTS_ENDPOINT_PATH):
-                return f"{api_base}{self.TTS_ENDPOINT_PATH}"
-            return api_base
+            return ensure_api_route(api_base, self.TTS_ENDPOINT_PATH)
 
-        # Assume it's a custom endpoint, append the path
-        return f"{api_base}{self.TTS_ENDPOINT_PATH}"
+        return join_api_base(api_base, self.TTS_ENDPOINT_PATH)
 
     def _is_cognitive_services_endpoint(self, hostname: str) -> bool:
         """Check if hostname is a Cognitive Services endpoint"""

litellm/llms/azure_ai/agents/handler.py

@@ -30,7 +30,7 @@ from typing_extensions import ReadOnly
 
 from litellm._logging import verbose_logger
 from litellm.litellm_core_utils.hidden_params import set_hidden_param
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
 from litellm.llms.azure_ai.agents.transformation import (
     AzureAIAgentsConfig,
     AzureAIAgentsError,
@@ -130,28 +130,29 @@ class AzureAIAgentsHandler:
     # See: https://learn.microsoft.com/en-us/azure/ai-foundry/agents/quickstart
     # -------------------------------------------------------------------------
     def _build_thread_url(self, api_base: str, api_version: str) -> str:
-        return f"{api_base}/threads?api-version={api_version}"
+        return f"{join_api_base(api_base, 'threads')}?api-version={api_version}"
 
     def _build_messages_url(self, api_base: str, thread_id: str, api_version: str) -> str:
         encoded_thread_id: Final = encode_url_path_segment(thread_id, field_name="thread_id")
-        return f"{api_base}/threads/{encoded_thread_id}/messages?api-version={api_version}"
+        return f"{join_api_base(api_base, f'threads/{encoded_thread_id}/messages')}?api-version={api_version}"
 
     def _build_runs_url(self, api_base: str, thread_id: str, api_version: str) -> str:
         encoded_thread_id: Final = encode_url_path_segment(thread_id, field_name="thread_id")
-        return f"{api_base}/threads/{encoded_thread_id}/runs?api-version={api_version}"
+        return f"{join_api_base(api_base, f'threads/{encoded_thread_id}/runs')}?api-version={api_version}"
 
     def _build_run_status_url(self, api_base: str, thread_id: str, run_id: str, api_version: str) -> str:
         encoded_thread_id: Final = encode_url_path_segment(thread_id, field_name="thread_id")
         encoded_run_id: Final = encode_url_path_segment(run_id, field_name="run_id")
-        return f"{api_base}/threads/{encoded_thread_id}/runs/{encoded_run_id}?api-version={api_version}"
+        run_status_route: Final = f"threads/{encoded_thread_id}/runs/{encoded_run_id}"
+        return f"{join_api_base(api_base, run_status_route)}?api-version={api_version}"
 
     def _build_list_messages_url(self, api_base: str, thread_id: str, api_version: str) -> str:
         encoded_thread_id: Final = encode_url_path_segment(thread_id, field_name="thread_id")
-        return f"{api_base}/threads/{encoded_thread_id}/messages?api-version={api_version}"
+        return f"{join_api_base(api_base, f'threads/{encoded_thread_id}/messages')}?api-version={api_version}"
 
     def _build_create_thread_and_run_url(self, api_base: str, api_version: str) -> str:
         """URL for the create-thread-and-run endpoint (supports streaming)."""
-        return f"{api_base}/threads/runs?api-version={api_version}"
+        return f"{join_api_base(api_base, 'threads/runs')}?api-version={api_version}"
 
     # -------------------------------------------------------------------------
     # Response Helpers
@@ -281,8 +282,6 @@ class AzureAIAgentsHandler:
         api_version: Final = optional_params.get("api_version", self.config.DEFAULT_API_VERSION)
         agent_id: Final = self.config.get_agent_id(model, optional_params)
         thread_id: Final = optional_params.get("thread_id")
-        api_base = api_base.rstrip("/")
-
         verbose_logger.debug("Azure AI Agents completion - api_base: %s, agent_id: %s", api_base, agent_id)
 
         return headers, api_version, agent_id, thread_id, api_base

litellm/llms/azure_ai/anthropic/count_tokens/transformation.py

@@ -5,8 +5,10 @@ Extends the base Anthropic CountTokens transformation with Azure authentication.
 """
 
 from typing import Final
+from urllib.parse import urlsplit
 
 from litellm.constants import ANTHROPIC_TOKEN_COUNTING_BETA_VERSION
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.anthropic.count_tokens.transformation import (
     AnthropicCountTokensConfig,
 )
@@ -76,14 +78,8 @@ class AzureAIAnthropicCountTokensConfig(AnthropicCountTokensConfig):
         Returns:
             The endpoint URL for the CountTokens API
         """
-        # Azure AI Anthropic endpoint format:
-        # https://<resource>.services.ai.azure.com/anthropic/v1/messages/count_tokens
-        api_base = api_base.rstrip("/")
-
-        # Ensure the URL has /anthropic path
-        if not api_base.endswith("/anthropic"):
-            if "/anthropic" not in api_base:
-                api_base = f"{api_base}/anthropic"
-
-        # Add the count_tokens path
-        return f"{api_base}/v1/messages/count_tokens"
+        base: Final = api_base.rstrip("/")
+        if base.endswith("/v1/messages"):
+            return join_api_base(base, "count_tokens")
+        anthropic_base: Final = base if "/anthropic" in urlsplit(base).path else join_api_base(base, "anthropic")
+        return join_api_base(anthropic_base, "v1/messages/count_tokens")

litellm/llms/azure_ai/anthropic/messages_transformation.py

@@ -9,6 +9,7 @@ from litellm.llms.anthropic.pass_through.messages.transformation import (
     AnthropicMessagesConfig,
 )
 from litellm.llms.azure.common_utils import BaseAzureLLM
+from litellm.llms.azure_ai.anthropic.transformation import azure_anthropic_messages_url
 from litellm.types.router import GenericLiteLLMParams
 
 
@@ -96,25 +97,7 @@ class AzureAnthropicMessagesConfig(AnthropicMessagesConfig):
                 "Expected format: https://<resource-name>.services.ai.azure.com/anthropic"
             )
 
-        # Ensure the URL ends with /v1/messages
-        api_base = api_base.rstrip("/")
-        if api_base.endswith("/v1/messages") or api_base.endswith("/anthropic/v1/messages"):
-            # Already correct
-            pass
-        else:
-            # Check if /anthropic is already in the path
-            if "/anthropic" in api_base:
-                # /anthropic exists, ensure we end with /anthropic/v1/messages
-                # Extract the base URL up to and including /anthropic
-                parts: Final = api_base.split("/anthropic", 1)
-                api_base = parts[0] + "/anthropic"
-            else:
-                # /anthropic not in path, add it
-                api_base = api_base + "/anthropic"
-            # Add /v1/messages
-            api_base = api_base + "/v1/messages"
-
-        return api_base
+        return azure_anthropic_messages_url(api_base)
 
     def _remove_scope_from_cache_control(self, anthropic_messages_request: dict) -> None:
         """

litellm/llms/azure_ai/anthropic/transformation.py

@@ -4,12 +4,23 @@ Azure Anthropic transformation config - extends AnthropicConfig with Azure authe
 
 from typing import Final
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.anthropic.chat.transformation import AnthropicConfig
 from litellm.llms.azure.common_utils import BaseAzureLLM
 from litellm.types.llms.openai import AllMessageValues
 from litellm.types.router import GenericLiteLLMParams
 
 
+def azure_anthropic_messages_url(api_base: str) -> str:
+    base: Final = api_base.rstrip("/")
+    if base.endswith("/v1/messages"):
+        return base
+    path_start: Final = base.find("/", base.find("://") + len("://")) if "://" in base else 0
+    anthropic_start: Final = base.find("/anthropic", path_start) if path_start >= 0 else -1
+    anthropic_root: Final = base[:anthropic_start] if anthropic_start >= 0 else base
+    return join_api_base(anthropic_root, "anthropic/v1/messages")
+
+
 def _promote_extra_body_to_optional_params(optional_params: dict) -> None:
     """Promote anthropic-native passthrough keys out of ``extra_body``.
 

litellm/llms/azure_ai/embed/handler.py

@@ -5,6 +5,7 @@ from urllib.parse import urlsplit, urlunsplit
 from openai import OpenAI
 
 import litellm
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.azure_ai.common_utils import is_foundry_model_inference_base
 from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
@@ -74,13 +75,18 @@ class AzureAIEmbedding(OpenAIChatCompletion):
         api_base: str | None,
         client: HTTPHandler | AsyncHTTPHandler | None = None,
     ) -> EmbeddingResponse:
+        if api_base is None:
+            raise ValueError(
+                "api_base is None. Please set AZURE_AI_API_BASE or dynamically via `api_base` param, "
+                "to make the request."
+            )
         if client is None or not isinstance(client, AsyncHTTPHandler):
             client = get_async_httpx_client(
                 llm_provider=litellm.LlmProviders.AZURE_AI,
                 params={"timeout": timeout},
             )
 
-        url: Final = f"{api_base}/images/embeddings"
+        url: Final = join_api_base(api_base, "images/embeddings")
 
         response: Final = await client.post(
             url=url,
@@ -123,7 +129,7 @@ class AzureAIEmbedding(OpenAIChatCompletion):
         if client is None or not isinstance(client, HTTPHandler):
             client = HTTPHandler(timeout=timeout, concurrent_limit=1)
 
-        url: Final = f"{api_base}/images/embeddings"
+        url: Final = join_api_base(api_base, "images/embeddings")
 
         response: Final = client.post(
             url=url,

litellm/llms/azure_ai/image_generation/flux_transformation.py

@@ -3,6 +3,7 @@ from types import MappingProxyType
 from typing import Final
 
 from litellm.exceptions import BadRequestError, UnsupportedParamsError
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.openai.image_generation import GPTImageGenerationConfig
 from litellm.types.llms.openai import OpenAIImageGenerationOptionalParams
 
@@ -52,7 +53,8 @@ class AzureFoundryFluxImageGenerationConfig(GPTImageGenerationConfig):
             return f"{api_base}?api-version={api_version}"
 
         provider_model_path: Final = AzureFoundryFluxImageGenerationConfig.get_flux2_provider_model_path(model)
-        return f"{api_base}/providers/blackforestlabs/v1/{provider_model_path}?api-version={api_version}"
+        flux_route: Final = f"providers/blackforestlabs/v1/{provider_model_path}"
+        return f"{join_api_base(api_base, flux_route)}?api-version={api_version}"
 
     @staticmethod
     def is_flux2_model(model: str) -> bool:

litellm/llms/azure_ai/image_generation/mai_transformation.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, Final
 import httpx
 
 from litellm.exceptions import UnsupportedParamsError
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.image_generation.transformation import (
     BaseImageGenerationConfig,
 )
@@ -41,9 +42,9 @@ class AzureFoundryMAIImageGenerationConfig(BaseImageGenerationConfig):
 
         if "/mai/" in path:
             prefix, _, _ = path.partition("/images/")
-            path = f"{prefix}/images/generations"
+            path = join_api_base(prefix, "images/generations")
         else:
-            path = f"{path}/mai/v1/images/generations"
+            path = join_api_base(path, "mai/v1/images/generations")
 
         if separator:
             return f"{path}?{query}"
@@ -63,9 +64,9 @@ class AzureFoundryMAIImageGenerationConfig(BaseImageGenerationConfig):
 
         if "/mai/" in path:
             prefix, _, _ = path.partition("/images/")
-            path = f"{prefix}/images/edits"
+            path = join_api_base(prefix, "images/edits")
         else:
-            path = f"{path}/mai/v1/images/edits"
+            path = join_api_base(path, "mai/v1/images/edits")
 
         if separator:
             return f"{path}?{query}"

litellm/llms/azure_ai/vector_stores/transformation.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Final
 
 import httpx
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.azure.common_utils import BaseAzureLLM
 from litellm.llms.base_llm.vector_store.transformation import (
     BaseQueryEmbeddingVectorStoreConfig,
@@ -172,7 +173,8 @@ class AzureAIVectorStoreConfig(BaseQueryEmbeddingVectorStoreConfig, BaseAzureLLM
         litellm_logging_obj.model_call_details["input"] = query_text
         litellm_logging_obj.model_call_details["embedding_model"] = litellm_params.get("litellm_embedding_model")
         litellm_logging_obj.model_call_details["top_k"] = top_k
-        return f"{api_base}/indexes/{vector_store_id}/docs/search?api-version=2024-07-01", {
+        search_route: Final = f"indexes/{vector_store_id}/docs/search"
+        return f"{join_api_base(api_base, search_route)}?api-version=2024-07-01", {
             "search": "*",
             "vectorQueries": [{"vector": query_vector, "fields": vector_field, "kind": "vector", "k": top_k}],
             "select": "id,content",

litellm/llms/base_llm/decisions/transformation.py

@@ -12,6 +12,7 @@ from pydantic_core import ErrorDetails
 from typing_extensions import assert_never
 
 import litellm
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.decisions import (
@@ -582,7 +583,7 @@ class BaseDecisionsConfig(ABC):
         )
 
     def get_complete_url(self, api_base: str, model: str) -> str:
-        return f"{api_base.rstrip('/').removesuffix('/v1')}{self.path}"
+        return join_api_base(api_base.rstrip("/").removesuffix("/v1"), self.path)
 
     def signs_with_aws(self, api_base: str) -> bool:
         return False

litellm/llms/base_llm/evals/transformation.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 import httpx
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.types.llms.openai_evals import (
     CancelEvalResponse,
@@ -79,7 +80,7 @@ class BaseEvalsAPIConfig(ABC):
         """
         if api_base is None:
             raise ValueError("api_base is required")
-        return f"{api_base}/v1/{endpoint}"
+        return join_api_base(api_base, f"v1/{endpoint}")
 
     @abstractmethod
     def transform_create_eval_request(

litellm/llms/base_llm/ocr/transformation.py

@@ -4,7 +4,7 @@ Base OCR types shared by the Rust OCR route and Python consumers.
 
 import builtins
 from collections.abc import Mapping
-from typing import Any, Final, Literal
+from typing import Final, Literal
 
 from pydantic import PrivateAttr
 
@@ -45,7 +45,7 @@ class OCRPageImage(LiteLLMPydanticObjectBase):
     """Image extracted from OCR page."""
 
     image_base64: str | None = None
-    bbox: dict[str, Any] | None = None
+    bbox: dict[str, builtins.object] | None = None
 
     model_config = {"extra": "allow"}
 
@@ -80,7 +80,7 @@ class OCRResponse(LiteLLMPydanticObjectBase):
 
     pages: list[OCRPage]
     model: str
-    document_annotation: Any | None = None
+    document_annotation: builtins.object | None = None
     usage_info: OCRUsageInfo | None = None
     content: str | None = None
     tables: list[dict[str, builtins.object]] | None = None

litellm/llms/base_llm/realtime/http_transformation.py

@@ -7,10 +7,11 @@ These are HTTP (not WebSocket) endpoints used by the WebRTC flow:
 """
 
 from abc import ABC, abstractmethod
-from typing import Final
 
 import httpx
 
+from litellm.litellm_core_utils.url_utils import join_api_base
+
 
 class BaseRealtimeHTTPConfig(ABC):
     """
@@ -61,7 +62,7 @@ class BaseRealtimeHTTPConfig(ABC):
         """Return the full URL for POST /realtime/transcription_sessions."""
         base = (api_base or "").rstrip("/")
         base = base.removesuffix("/v1")
-        return f"{base}/v1/realtime/transcription_sessions"
+        return join_api_base(base, "v1/realtime/transcription_sessions")
 
     @abstractmethod
     def validate_environment(
@@ -83,8 +84,7 @@ class BaseRealtimeHTTPConfig(ABC):
 
     def get_realtime_calls_url(self, api_base: str | None, model: str, api_version: str | None = None) -> str:
         """Return the full URL for POST /realtime/calls (SDP exchange)."""
-        base: Final = (api_base or "").rstrip("/")
-        return f"{base}/v1/realtime/calls"
+        return join_api_base(api_base or "", "v1/realtime/calls")
 
     def get_realtime_calls_headers(self, ephemeral_key: str) -> dict:
         """

litellm/llms/base_llm/sandbox/transformation.py

@@ -7,7 +7,7 @@ run code -> delete container; `code_interpreter_tool` combines all three.
 """
 
 import builtins
-from typing import Any, Final
+from typing import Final
 
 import httpx
 from pydantic import Field, PrivateAttr
@@ -42,8 +42,8 @@ class CodeExecutionResult(LiteLLMPydanticObjectBase):
 
     stdout: str = ""
     stderr: str = ""
-    results: list[dict[str, Any]] = Field(default_factory=list)
-    error: dict[str, Any] | None = None
+    results: list[dict[str, object]] = Field(default_factory=list)
+    error: dict[str, object] | None = None
     execution_count: int | None = None
     object: str = "code_execution"
 

litellm/llms/base_llm/skills/transformation.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 import httpx
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.types.llms.anthropic_skills import (
     CreateSkillRequest,
@@ -71,7 +72,7 @@ class BaseSkillsAPIConfig(ABC):
         """
         if api_base is None:
             raise ValueError("api_base is required")
-        return f"{api_base}/v1/{endpoint}"
+        return join_api_base(api_base, f"v1/{endpoint}")
 
     @abstractmethod
     def transform_create_skill_request(

litellm/llms/bedrock/chat/agentcore/transformation.py

@@ -18,6 +18,7 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import (
     convert_content_list_to_str,
 )
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.a2a.common_utils import extract_text_from_a2a_response
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
@@ -98,14 +99,14 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
         # Build the base endpoint URL for AgentCore
         # Note: We don't use get_runtime_endpoint as AgentCore has its own endpoint structure
         if aws_bedrock_runtime_endpoint:
-            base_url = aws_bedrock_runtime_endpoint
+            base_url = f"{aws_bedrock_runtime_endpoint}"
         else:
             base_url = f"https://bedrock-agentcore.{region}.{get_aws_dns_suffix(region)}"
 
         # Based on boto3 client.invoke_agent_runtime, the path is:
         # /runtimes/{URL-ENCODED-ARN}/invocations?qualifier=<value>
         encoded_arn: Final = quote(agent_runtime_arn, safe="")
-        endpoint_url = f"{base_url}/runtimes/{encoded_arn}/invocations"
+        endpoint_url = join_api_base(base_url, f"runtimes/{encoded_arn}/invocations")
 
         # Add qualifier as query parameter if provided
         if "qualifier" in optional_params:

litellm/llms/bedrock/chat/chat_completions/transformation.py

@@ -33,6 +33,7 @@ from litellm.litellm_core_utils.prompt_templates.image_handling import (
     inline_remote_image_urls,
     inline_remote_media,
 )
+from litellm.litellm_core_utils.url_utils import ensure_api_route, join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM, bedrock_bearer_token
 from litellm.llms.bedrock.common_utils import (
@@ -371,12 +372,9 @@ class AmazonBedrockRuntimeChatCompletionsConfig(OpenAILikeChatConfig):
             ),
             aws_region_name=aws_region_name,
         )
-        base: Final = proxy_endpoint_url.rstrip("/")
-        if base.endswith("/openai/v1/chat/completions"):
-            return base
-        if base.endswith("/openai/v1"):
-            return f"{base}/chat/completions"
-        return f"{base}/openai/v1/chat/completions"
+        if proxy_endpoint_url.rstrip("/").endswith("/openai/v1"):
+            return join_api_base(proxy_endpoint_url, "chat/completions")
+        return ensure_api_route(proxy_endpoint_url, "openai/v1/chat/completions")
 
     def _params_with_region_from_path(
         self, optional_params: dict, model: str | None

litellm/llms/bedrock/chat/converse_handler.py

@@ -10,6 +10,7 @@ from litellm.anthropic_beta_headers_manager import (
 )
 from litellm.litellm_core_utils.get_litellm_params import stored_control_options
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObject
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm import base_model_iterator
 from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
@@ -363,11 +364,11 @@ class BedrockConverseLLM(BaseAWSLLM):
             aws_region_name=aws_region_name,
         )
         if (stream is not None and stream is True) and not fake_stream:
-            endpoint_url = f"{endpoint_url}/model/{modelId}/converse-stream"
-            proxy_endpoint_url = f"{proxy_endpoint_url}/model/{modelId}/converse-stream"
+            endpoint_url = join_api_base(endpoint_url, f"model/{modelId}/converse-stream")
+            proxy_endpoint_url = join_api_base(proxy_endpoint_url, f"model/{modelId}/converse-stream")
         else:
-            endpoint_url = f"{endpoint_url}/model/{modelId}/converse"
-            proxy_endpoint_url = f"{proxy_endpoint_url}/model/{modelId}/converse"
+            endpoint_url = join_api_base(endpoint_url, f"model/{modelId}/converse")
+            proxy_endpoint_url = join_api_base(proxy_endpoint_url, f"model/{modelId}/converse")
 
         ## COMPLETION CALL
         headers = {"Content-Type": "application/json"}

litellm/llms/bedrock/chat/invoke_agent/transformation.py

@@ -15,7 +15,7 @@ from litellm._uuid import uuid
 from litellm.litellm_core_utils.prompt_templates.common_utils import (
     convert_content_list_to_str,
 )
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import BedrockError
@@ -101,9 +101,10 @@ class AmazonInvokeAgentConfig(BaseConfig, BaseAWSLLM):
         encoded_agent_alias_id: Final = encode_url_path_segment(agent_alias_id, field_name="agent_alias_id")
         encoded_session_id: Final = encode_url_path_segment(session_id, field_name="session_id")
 
-        endpoint_url = f"{endpoint_url}/agents/{encoded_agent_id}/agentAliases/{encoded_agent_alias_id}/sessions/{encoded_session_id}/text"
-
-        return endpoint_url
+        return join_api_base(
+            endpoint_url,
+            f"agents/{encoded_agent_id}/agentAliases/{encoded_agent_alias_id}/sessions/{encoded_session_id}/text",
+        )
 
     def sign_request(
         self,

litellm/llms/bedrock/chat/invoke_transformations/amazon_openai_transformation.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Any, Final
 
 import httpx
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import BedrockError
 from litellm.llms.bedrock.request_metadata import (
@@ -97,13 +98,8 @@ class AmazonBedrockOpenAIConfig(OpenAIGPTConfig, BaseAWSLLM):
         # Encode model ID for ARNs (e.g., :imported-model/ -> :imported-model%2F)
         model_id = CommonUtils.encode_bedrock_runtime_modelid_arn(model_id)
 
-        # Build the invoke URL
-        if stream:
-            endpoint_url = f"{endpoint_url}/model/{model_id}/invoke-with-response-stream"
-        else:
-            endpoint_url = f"{endpoint_url}/model/{model_id}/invoke"
-
-        return endpoint_url
+        invoke_route: Final = "invoke-with-response-stream" if stream else "invoke"
+        return join_api_base(endpoint_url, f"model/{model_id}/{invoke_route}")
 
     def sign_request(
         self,

litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py

@@ -18,6 +18,7 @@ from litellm.litellm_core_utils.prompt_templates.factory import (
     prompt_factory,
     render_custom_prompt_template,
 )
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
 from litellm.llms.bedrock.chat.invoke_handler import make_call, make_sync_call
 from litellm.llms.bedrock.common_utils import BedrockError
@@ -136,20 +137,13 @@ class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
         aws_bedrock_runtime_endpoint: Final = optional_params.get(
             "aws_bedrock_runtime_endpoint", None
         )  # https://bedrock-runtime.{region_name}.amazonaws.com
-        endpoint_url, proxy_endpoint_url = self.get_runtime_endpoint(
+        endpoint_url, _ = self.get_runtime_endpoint(
             api_base=api_base,
             aws_bedrock_runtime_endpoint=aws_bedrock_runtime_endpoint,
             aws_region_name=self._get_aws_region_name(optional_params=optional_params, model=model),
         )
-
-        if (stream is not None and stream is True) and provider != "ai21":
-            endpoint_url = f"{endpoint_url}/model/{modelId}/invoke-with-response-stream"
-            proxy_endpoint_url = f"{proxy_endpoint_url}/model/{modelId}/invoke-with-response-stream"
-        else:
-            endpoint_url = f"{endpoint_url}/model/{modelId}/invoke"
-            proxy_endpoint_url = f"{proxy_endpoint_url}/model/{modelId}/invoke"
-
-        return endpoint_url
+        invoke_route: Final = "invoke-with-response-stream" if stream is True and provider != "ai21" else "invoke"
+        return join_api_base(endpoint_url, f"model/{modelId}/{invoke_route}")
 
     def sign_request(
         self,

litellm/llms/bedrock/claude_platform/common_utils.py

@@ -5,6 +5,7 @@ import httpx
 
 import litellm
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import BedrockError
 from litellm.secret_managers.main import get_secret_str
@@ -140,9 +141,7 @@ class BedrockClaudePlatformMixin(BaseAWSLLM):
         if api_base is None:
             aws_region_name: Final = self._get_required_aws_region_name(optional_params)
             api_base = f"https://{CLAUDE_PLATFORM_SERVICE_NAME}.{aws_region_name}.api.aws"
-        if not api_base.endswith("/v1/messages"):
-            api_base = f"{api_base.rstrip('/')}/v1/messages"
-        return api_base
+        return ensure_api_route(api_base, "v1/messages")
 
     def sign_request(
         self,

litellm/llms/bedrock/common_utils.py

@@ -31,6 +31,7 @@ from litellm import verbose_logger
 from litellm.litellm_core_utils.aws_partition import get_aws_dns_suffix
 from litellm.litellm_core_utils.optional_imports import ensure_optional_import
 from litellm.litellm_core_utils.prompt_templates.common_utils import schema_property_count
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.base_llm.anthropic_messages.transformation import (
     BaseAnthropicMessagesConfig,
 )
@@ -1305,10 +1306,7 @@ def build_mantle_messages_url(
     """
     override: Final = api_base or aws_bedrock_runtime_endpoint or _mantle_api_base_from_env()
     if override:
-        base: Final = override.rstrip("/")
-        if base.endswith(MANTLE_MESSAGES_PATH):
-            return base
-        return f"{base}{MANTLE_MESSAGES_PATH}"
+        return ensure_api_route(override, MANTLE_MESSAGES_PATH)
     return f"https://bedrock-mantle.{region}.api.aws{MANTLE_MESSAGES_PATH}"
 
 

litellm/llms/bedrock/count_tokens/mantle_handler.py

@@ -7,6 +7,7 @@ from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 import litellm
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.anthropic.count_tokens.transformation import COUNT_TOKEN_OPTION_NAMES, AnthropicCountTokensConfig
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM, run_aws_signing
 from litellm.llms.bedrock.common_utils import BedrockError, build_mantle_messages_url
@@ -43,7 +44,7 @@ class BedrockMantleCountTokensHandler(BaseAWSLLM):
         messages_url: Final = build_mantle_messages_url(
             api_base=None, aws_bedrock_runtime_endpoint=None, region=aws_region_name
         )
-        return f"{messages_url}{MANTLE_COUNT_TOKENS_SUFFIX}"
+        return join_api_base(messages_url, MANTLE_COUNT_TOKENS_SUFFIX)
 
     async def handle_count_tokens_request(
         self,

litellm/llms/bedrock/count_tokens/transformation.py

@@ -11,6 +11,7 @@ from typing import Final, Literal
 
 from pydantic import JsonValue
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import get_bedrock_base_model
 
@@ -236,9 +237,7 @@ class BedrockCountTokensConfig(BaseAWSLLM):
             aws_bedrock_runtime_endpoint=aws_bedrock_runtime_endpoint,
             aws_region_name=aws_region_name,
         )
-        endpoint: Final = f"{base_url}/model/{encoded_model_id}/count-tokens"
-
-        return endpoint
+        return join_api_base(base_url, f"model/{encoded_model_id}/count-tokens")
 
     def transform_bedrock_response_to_anthropic(
         self, bedrock_response: Mapping[str, JsonValue]

litellm/llms/bedrock/embed/embedding.py

@@ -12,6 +12,7 @@ import httpx
 
 import litellm
 from litellm.constants import BEDROCK_EMBEDDING_PROVIDERS_LITERAL
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.cohere.embed.handler import embedding as cohere_embedding
 from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
@@ -512,9 +513,9 @@ class BedrockEmbedding(BaseAWSLLM):
             aws_region_name=aws_region_name,
         )
         if has_async_invoke:
-            endpoint_url = f"{endpoint_url}/async-invoke"
+            endpoint_url = join_api_base(endpoint_url, "async-invoke")
         else:
-            endpoint_url = f"{endpoint_url}/model/{modelId}/invoke"
+            endpoint_url = join_api_base(endpoint_url, f"model/{modelId}/invoke")
 
         if batch_data is not None:
             if aembedding:
@@ -611,7 +612,7 @@ class BedrockEmbedding(BaseAWSLLM):
 
         # Encode the ARN for use in URL path
         encoded_arn: Final = quote(invocation_arn, safe="")
-        status_url: Final = f"{endpoint_url.rstrip('/')}/async-invoke/{encoded_arn}"
+        status_url: Final = join_api_base(endpoint_url, f"async-invoke/{encoded_arn}")
 
         # Prepare headers for GET request
         headers: Final = {"Content-Type": "application/json"}

litellm/llms/bedrock/image_edit/handler.py

@@ -14,6 +14,7 @@ import httpx
 import litellm
 from litellm._logging import verbose_logger
 from litellm.litellm_core_utils.litellm_logging import Logging as LitellmLogging
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.bedrock.image_edit.amazon_nova_canvas_image_edit_transformation import (
     BedrockAmazonNovaCanvasImageEditConfig,
 )
@@ -226,7 +227,7 @@ class BedrockImageEdit(BaseAWSLLM):
             aws_bedrock_runtime_endpoint=boto3_credentials_info.aws_bedrock_runtime_endpoint,
             aws_region_name=boto3_credentials_info.aws_region_name,
         )
-        proxy_endpoint_url = f"{proxy_endpoint_url}/model/{modelId}/invoke"
+        proxy_endpoint_url = join_api_base(proxy_endpoint_url, f"model/{modelId}/invoke")
         data: Final = self._get_request_body(
             model=model,
             image=image,

litellm/llms/bedrock/image_generation/image_handler.py

@@ -8,6 +8,7 @@ import httpx
 import litellm
 from litellm._logging import verbose_logger
 from litellm.litellm_core_utils.litellm_logging import Logging as LitellmLogging
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.bedrock.image_generation.amazon_nova_canvas_transformation import (
     AmazonNovaCanvasConfig,
 )
@@ -248,7 +249,7 @@ class BedrockImageGeneration(BaseAWSLLM):
             aws_bedrock_runtime_endpoint=boto3_credentials_info.aws_bedrock_runtime_endpoint,
             aws_region_name=boto3_credentials_info.aws_region_name,
         )
-        proxy_endpoint_url = f"{proxy_endpoint_url}/model/{modelId}/invoke"
+        proxy_endpoint_url = join_api_base(proxy_endpoint_url, f"model/{modelId}/invoke")
         data: Final = self._get_request_body(
             model=model,
             prompt=prompt,

litellm/llms/bedrock/rerank/handler.py

@@ -6,6 +6,7 @@ from pydantic import ConfigDict, TypeAdapter
 
 import litellm
 from litellm.litellm_core_utils.litellm_logging import Logging as LitellmLogging
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
     HTTPHandler,
@@ -160,7 +161,7 @@ class BedrockRerankHandler(BaseAWSLLM):
             aws_region_name=boto3_credentials_info.aws_region_name,
         )
         proxy_endpoint_url = proxy_endpoint_url.replace("bedrock-runtime", "bedrock-agent-runtime")
-        proxy_endpoint_url = f"{proxy_endpoint_url}/rerank"
+        proxy_endpoint_url = join_api_base(proxy_endpoint_url, "rerank")
 
         body: Final = json.dumps(data).encode("utf-8")
         headers = {"Content-Type": "application/json"}

litellm/llms/bedrock/responses/transformation.py

@@ -46,6 +46,7 @@ from litellm.litellm_core_utils.prompt_templates.image_handling import (
     async_convert_url_to_base64,
     convert_url_to_base64,
 )
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.responses.codex_compat import drop_unsupported_tools, normalize_codex_input_items
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
@@ -223,9 +224,10 @@ class BedrockOpenAIResponsesConfig(BaseAWSLLM, OpenAIResponsesAPIConfig):
         litellm_params: dict,  # mutable-ok: signature fixed by the BaseResponsesAPIConfig override contract
     ) -> str:
         region: Final = self._get_aws_region_name(optional_params=litellm_params, model=None)
+        configured_endpoint: Final = litellm_params.get("aws_bedrock_runtime_endpoint")
         override: Final = (
             api_base
-            or litellm_params.get("aws_bedrock_runtime_endpoint")
+            or (f"{configured_endpoint}" if configured_endpoint else None)
             or get_secret_str("AWS_BEDROCK_RUNTIME_ENDPOINT")
         )
         # Partition-aware: bedrock-runtime is amazonaws.com.cn in China, and other
@@ -237,7 +239,7 @@ class BedrockOpenAIResponsesConfig(BaseAWSLLM, OpenAIResponsesAPIConfig):
             (host[: -len(suffix)] for suffix in BEDROCK_RUNTIME_OPENAI_BASE_SUFFIXES if host.endswith(suffix)),
             host,
         )
-        return f"{base}{BEDROCK_RUNTIME_OPENAI_RESPONSES_PATH}"
+        return join_api_base(base, BEDROCK_RUNTIME_OPENAI_RESPONSES_PATH)
 
     def supports_native_file_search(self) -> bool:
         return False

litellm/llms/bedrock/vector_stores/transformation.py

@@ -6,7 +6,7 @@ from urllib.parse import urlparse
 import httpx
 
 from litellm._logging import verbose_logger
-from litellm.litellm_core_utils.url_utils import encode_url_path_segment
+from litellm.litellm_core_utils.url_utils import encode_url_path_segment, join_api_base
 from litellm.llms.base_llm.vector_store.transformation import BaseVectorStoreConfig
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import BedrockError
@@ -196,7 +196,7 @@ class BedrockVectorStoreConfig(BaseVectorStoreConfig, BaseAWSLLM):
             aws_region_name=self.get_aws_region_name_for_non_llm_api_calls(aws_region_name=aws_region_name),
             endpoint_type="agent",
         )
-        return f"{endpoint_url}/knowledgebases"
+        return join_api_base(endpoint_url, "knowledgebases")
 
     def transform_search_vector_store_request(
         self,
@@ -212,7 +212,7 @@ class BedrockVectorStoreConfig(BaseVectorStoreConfig, BaseAWSLLM):
             query = " ".join(query)
 
         encoded_vector_store_id: Final = encode_url_path_segment(vector_store_id, field_name="vector_store_id")
-        url: Final = f"{api_base}/{encoded_vector_store_id}/retrieve"
+        url: Final = join_api_base(api_base, f"{encoded_vector_store_id}/retrieve")
 
         request_body: Final[dict[str, object]] = {
             "retrievalQuery": BedrockKBRetrievalQuery(text=query),

litellm/llms/bedrock_mantle/messages/transformation.py

@@ -2,6 +2,7 @@ from collections.abc import Mapping
 from types import MappingProxyType
 from typing import Final
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
 from litellm.llms.bedrock.common_utils import MANTLE_MESSAGES_PATH
 from litellm.llms.bedrock.messages.mantle_transformation import AmazonMantleMessagesConfig
@@ -33,7 +34,7 @@ def build_mantle_native_messages_url(api_base: str | None, litellm_params: Mappi
         configured,
     )
     host: Final = f"https://bedrock-mantle.{region}.api.aws" if MANTLE_HOST_RE.match(stripped) else stripped
-    return f"{host}{MANTLE_MESSAGES_PATH}"
+    return join_api_base(host, MANTLE_MESSAGES_PATH)
 
 
 class BedrockMantleAnthropicMessagesConfig(BedrockMantleAuthMixin, AmazonMantleMessagesConfig):

litellm/llms/bedrock_mantle/responses/transformation.py

@@ -22,6 +22,7 @@ import httpx
 
 import litellm
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.responses.codex_compat import drop_unsupported_tools, normalize_codex_input_items
 from litellm.llms.base_llm.responses.transformation import ReasoningSummaryLevel
@@ -100,7 +101,7 @@ class BedrockMantleResponsesAPIConfig(BedrockMantleAuthMixin, OpenAIResponsesAPI
         if MANTLE_HOST_RE.match(base):
             base = f"https://bedrock-mantle.{region}.api.aws"
         path: Final = "/openai/v1/responses" if self.use_openai_path else "/v1/responses"
-        return f"{base}{path}"
+        return join_api_base(base, path)
 
     def validate_environment(self, headers: dict, model: str, litellm_params: GenericLiteLLMParams | None) -> dict:
         litellm_params = litellm_params or GenericLiteLLMParams()

litellm/llms/black_forest_labs/image_edit/transformation.py

@@ -19,7 +19,7 @@ from typing_extensions import NotRequired, ReadOnly, TypedDict
 
 import litellm
 from litellm.constants import DEFAULT_MAX_RECURSE_DEPTH
-from litellm.litellm_core_utils.url_utils import async_safe_get, safe_get
+from litellm.litellm_core_utils.url_utils import async_safe_get, join_api_base, safe_get
 from litellm.llms.base_llm.image_edit.transformation import BaseImageEditConfig
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.images.main import ImageEditOptionalRequestParams
@@ -189,11 +189,10 @@ class BlackForestLabsImageEditConfig(BaseImageEditConfig):
         """
         Get the complete URL for the Black Forest Labs API request.
         """
-        base_url: str = api_base or get_secret_str("BFL_API_BASE") or DEFAULT_API_BASE
-        base_url = base_url.rstrip("/")
+        base_url: Final = api_base or get_secret_str("BFL_API_BASE") or DEFAULT_API_BASE
 
         endpoint: Final = self._get_model_endpoint(model)
-        return f"{base_url}{endpoint}"
+        return join_api_base(base_url, endpoint)
 
     def _read_image_bytes(
         self,

litellm/llms/black_forest_labs/image_generation/transformation.py

@@ -14,6 +14,7 @@ from typing import TYPE_CHECKING, Any, Final
 import httpx
 from pydantic import ConfigDict, TypeAdapter
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.image_generation.transformation import (
     BaseImageGenerationConfig,
 )
@@ -202,11 +203,10 @@ class BlackForestLabsImageGenerationConfig(BaseImageGenerationConfig):
         """
         Get the complete URL for the Black Forest Labs API request.
         """
-        base_url: str = api_base or get_secret_str("BFL_API_BASE") or DEFAULT_API_BASE
-        base_url = base_url.rstrip("/")
+        base_url: Final = api_base or get_secret_str("BFL_API_BASE") or DEFAULT_API_BASE
 
         endpoint: Final = self._get_model_endpoint(model)
-        return f"{base_url}{endpoint}"
+        return join_api_base(base_url, endpoint)
 
     def transform_image_generation_request(
         self,

litellm/llms/chatgpt/responses/transformation.py

@@ -9,6 +9,7 @@ from litellm.litellm_core_utils.hidden_params import HIDDEN_PARAMS_ATTR, set_hid
 from litellm.litellm_core_utils.llm_response_utils.convert_dict_to_response import (
     safe_convert_created_field,
 )
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.openai.common_utils import OpenAIError
 from litellm.llms.openai.responses.transformation import OpenAIResponsesAPIConfig
 from litellm.responses.sse_output_recovery import (
@@ -253,8 +254,7 @@ class ChatGPTResponsesAPIConfig(OpenAIResponsesAPIConfig):
         litellm_params: dict,
     ) -> str:
         api_base = api_base or self.authenticator.get_api_base() or CHATGPT_API_BASE
-        api_base = api_base.rstrip("/")
-        return f"{api_base}/responses"
+        return join_api_base(api_base, "responses")
 
     def supports_native_websocket(self) -> bool:
         """ChatGPT does not support native WebSocket for Responses API"""

litellm/llms/cloudflare/chat/transformation.py

@@ -3,6 +3,7 @@ from typing import Final
 import httpx
 
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig
 from litellm.secret_managers.main import (
@@ -59,7 +60,7 @@ class CloudflareChatConfig(OpenAIGPTConfig):
             verbose_logger.warning(
                 "Cloudflare api_base ending in '/ai/run' is the legacy Workers AI path and no longer serves OpenAI-compatible requests; rewriting to the '/ai/v1' endpoint"
             )
-            return f"{trimmed[: -len('/ai/run')]}/ai/v1"
+            return join_api_base(trimmed[: -len("/ai/run")], "ai/v1")
         return api_base
 
     def validate_environment(

litellm/llms/cloudflare/common_utils.py

@@ -3,6 +3,7 @@ from typing import Final
 
 from pydantic import TypeAdapter, ValidationError
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.secret_managers.main import (
     get_secret_str,
     normalize_nonempty_secret_str,
@@ -34,10 +35,10 @@ def workers_ai_request_model(model: str) -> str:
 def workers_ai_run_url(api_base: str, model: str) -> str:
     normalized_api_base: Final = api_base.rstrip("/")
     if normalized_api_base.endswith("/ai/v1"):
-        return f"{normalized_api_base.removesuffix('/ai/v1')}/ai/run/{model}"
+        return join_api_base(normalized_api_base.removesuffix("/ai/v1"), f"ai/run/{model}")
     if normalized_api_base.endswith("/ai/run"):
         return f"{normalized_api_base}/{model}"
-    return f"{normalized_api_base}/ai/run/{model}"
+    return join_api_base(normalized_api_base, f"ai/run/{model}")
 
 
 def unwrap_workers_ai_result(payload: object) -> object:

litellm/llms/cohere/rerank/transformation.py

@@ -6,6 +6,7 @@ from pydantic import ConfigDict, TypeAdapter
 
 import litellm
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.rerank.transformation import BaseRerankConfig
 from litellm.secret_managers.main import get_secret_str
@@ -31,11 +32,7 @@ class CohereRerankConfig(BaseRerankConfig):
         optional_params: dict | None = None,
     ) -> str:
         if api_base:
-            # Remove trailing slashes and ensure clean base URL
-            api_base = api_base.rstrip("/")
-            if not api_base.endswith("/v1/rerank"):
-                api_base = f"{api_base}/v1/rerank"
-            return api_base
+            return ensure_api_route(api_base, "v1/rerank")
         return "https://api.cohere.ai/v1/rerank"
 
     def get_supported_cohere_rerank_params(self, model: str) -> list:

litellm/llms/cohere/rerank_v2/transformation.py

@@ -1,5 +1,6 @@
 from typing import Any, Final
 
+from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.cohere.rerank.transformation import CohereRerankConfig
 from litellm.types.rerank import OptionalRerankParams, RerankRequest
 
@@ -19,11 +20,7 @@ class CohereRerankV2Config(CohereRerankConfig):
         optional_params: dict | None = None,
     ) -> str:
         if api_base:
-            # Remove trailing slashes and ensure clean base URL
-            api_base = api_base.rstrip("/")
-            if not api_base.endswith("/v2/rerank"):
-                api_base = f"{api_base}/v2/rerank"
-            return api_base
+            return ensure_api_route(api_base, "v2/rerank")
         return "https://api.cohere.ai/v2/rerank"
 
     def get_supported_cohere_rerank_params(self, model: str) -> list:

litellm/llms/cometapi/chat/transformation.py

@@ -10,6 +10,7 @@ from typing import Any, Final
 
 import httpx
 
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.types.llms.openai import AllMessageValues, ChatCompletionToolParam
@@ -112,16 +113,14 @@ class CometAPIConfig(OpenAIGPTConfig):
 
         # Ensure we include /v1 prefix when missing
         if api_base.endswith("/v1"):
-            return f"{api_base}/{endpoint}"
-        if api_base.endswith("/v1/"):
-            return f"{api_base}{endpoint}"
+            return join_api_base(api_base, endpoint)
         # If user provided https://api.cometapi.com, add /v1
         if api_base == "https://api.cometapi.com":
-            return f"{api_base}/v1/{endpoint}"
+            return join_api_base(api_base, f"v1/{endpoint}")
         # Generic fallback: if '/v1' not in path, add it
         if "/v1" not in api_base.split("//", 1)[-1]:
-            return f"{api_base}/v1/{endpoint}"
-        return f"{api_base}/{endpoint}"
+            return join_api_base(api_base, f"v1/{endpoint}")
+        return join_api_base(api_base, endpoint)
 
     def get_error_class(self, error_message: str, status_code: int, headers: dict | httpx.Headers) -> BaseLLMException:
         """

litellm/llms/cometapi/embed/transformation.py

@@ -9,6 +9,7 @@ import httpx
 from pydantic import ConfigDict, TypeAdapter
 
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.embedding.transformation import BaseEmbeddingConfig
 from litellm.secret_managers.main import get_secret_str
@@ -44,9 +45,7 @@ class CometAPIEmbeddingConfig(BaseEmbeddingConfig):
         """
         Get the complete URL for the CometAPI embedding endpoint.
         """
-        api_base = "https://api.cometapi.com/v1" if api_base is None else api_base.rstrip("/")
-        complete_url: Final = f"{api_base}/embeddings"
-        return complete_url
+        return join_api_base("https://api.cometapi.com/v1" if api_base is None else api_base, "embeddings")
 
     def validate_environment(
         self,