diff --git a/litellm-rust/crates/llms-types/src/providers/anthropic/beta.rs b/litellm-rust/crates/llms-types/src/providers/anthropic/beta.rs
index 80095cac36c..01ed023999d 100644
--- a/litellm-rust/crates/llms-types/src/providers/anthropic/beta.rs
+++ b/litellm-rust/crates/llms-types/src/providers/anthropic/beta.rs
@@ -199,7 +199,7 @@ impl AnthropicBeta {
                 &[BetaProvider::BedrockConverse, BetaProvider::Databricks]
             }
             Self::ContextManagement20250627 => &[BetaProvider::BedrockConverse],
-            Self::AdvisorTool20260301 | Self::Compact20260904 => &[
+            Self::AdvisorTool20260301 => &[
                 BetaProvider::AzureAi,
                 BetaProvider::BedrockConverse,
                 BetaProvider::Bedrock,
@@ -207,6 +207,12 @@ impl AnthropicBeta {
                 BetaProvider::VertexAi,
                 BetaProvider::Databricks,
             ],
+            Self::Compact20260904 => &[
+                BetaProvider::BedrockConverse,
+                BetaProvider::Bedrock,
+                BetaProvider::BedrockMantle,
+                BetaProvider::Databricks,
+            ],
             Self::Bash20241022
             | Self::Bash20250124
             | Self::McpServers20251204
@@ -256,14 +262,18 @@ impl AnthropicBeta {
             Self::InterleavedThinking20250514 | Self::WebSearch20250305 => {
                 &[BetaProvider::BedrockConverse, BetaProvider::Bedrock]
             }
-            Self::MidConversationOutputConfig20260701
-            | Self::MidConversationToolChanges20260701 => &[
+            Self::MidConversationOutputConfig20260701 => &[
                 BetaProvider::AzureAi,
                 BetaProvider::BedrockConverse,
                 BetaProvider::BedrockMantle,
                 BetaProvider::VertexAi,
                 BetaProvider::Databricks,
             ],
+            Self::MidConversationToolChanges20260701 => &[
+                BetaProvider::BedrockConverse,
+                BetaProvider::BedrockMantle,
+                BetaProvider::Databricks,
+            ],
             Self::Output128k20250219 | Self::TokenEfficientTools20250219 => &[
                 BetaProvider::AzureAi,
                 BetaProvider::BedrockConverse,
@@ -483,7 +493,7 @@ mod tests {
         let config = beta_headers_config();
         let config_columns: Vec<String> = config
             .keys()
-            .filter(|column| column.as_str() != "description")
+            .filter(|column| column.as_str() != "description" && !column.ends_with("_header_only"))
             .cloned()
             .collect();
         let beta_provider_columns: Vec<String> = BetaProvider::VARIANTS
@@ -502,12 +512,16 @@ mod tests {
         let config = beta_headers_config();
         for provider in BetaProvider::VARIANTS {
             for beta in &AnthropicBeta::KNOWN {
-                let expected = config
-                    .get(provider.as_ref())
-                    .and_then(serde_json::Value::as_object)
-                    .and_then(|column| column.get(beta.as_str()))
-                    .and_then(serde_json::Value::as_str)
-                    .map(str::to_string);
+                let cell = |column: &str| {
+                    config
+                        .get(column)
+                        .and_then(serde_json::Value::as_object)
+                        .and_then(|values| values.get(beta.as_str()))
+                        .and_then(serde_json::Value::as_str)
+                        .map(str::to_string)
+                };
+                let expected =
+                    cell(&format!("{provider}_header_only")).or_else(|| cell(provider.as_ref()));
                 let actual = beta.on(*provider).map(|name| name.to_string());
                 assert_eq!(actual, expected, "provider {provider}, beta {beta}");
                 if matches!(beta, AnthropicBeta::AdvancedToolUse20251120)
diff --git a/litellm-rust/crates/llms/src/anthropic/messages/transformation.rs b/litellm-rust/crates/llms/src/anthropic/messages/transformation.rs
index 6657cbf262f..fb6d7259bf9 100644
--- a/litellm-rust/crates/llms/src/anthropic/messages/transformation.rs
+++ b/litellm-rust/crates/llms/src/anthropic/messages/transformation.rs
@@ -1,7 +1,8 @@
 use litellm_auth::CredentialPlacement;
 use litellm_llms_types::{
     formats::messages::{
-        ContextEdit, ContextManagement, Message, MessagesOptionalParams, MessagesRequest, Speed,
+        ContentBlock, ContentBlockType, ContextEdit, ContextManagement, Message,
+        MessagesOptionalParams, MessagesRequest, Speed, ThinkingConfig, ThinkingDisplay,
     },
     providers::anthropic::{AnthropicBeta, BetaProvider, BetaSet, DEFAULT_HEADERS},
     recognized::Recognized,
@@ -203,6 +204,10 @@ fn feature_betas(request: &MessagesRequest) -> BetaSet {
             .then_some(AnthropicBeta::FastMode20260201),
         messages_carry_output_config(&request.messages)
             .then_some(AnthropicBeta::PerTurnControl20260701),
+        uses_thinking_display_updates(params)
+            .then_some(AnthropicBeta::ThinkingDisplayUpdates20260818),
+        messages_carry_tool_changes(&request.messages)
+            .then_some(AnthropicBeta::MidConversationToolChanges20260701),
         has_advisor_tool(tools).then_some(AnthropicBeta::AdvisorTool20260301),
         is_tool_search_used(tools).then_some(AnthropicBeta::AdvancedToolUse20251120),
     ]
@@ -253,6 +258,36 @@ fn messages_carry_output_config(messages: &[Message]) -> bool {
         .any(|message| message.extra.contains_key("output_config"))
 }
 
+fn uses_thinking_display_updates(params: &MessagesOptionalParams) -> bool {
+    let display = match params.thinking.as_ref().and_then(Recognized::known) {
+        Some(ThinkingConfig::Enabled(thinking)) => thinking.display.as_ref(),
+        Some(ThinkingConfig::Adaptive(thinking)) => thinking.display.as_ref(),
+        _ => None,
+    };
+    display.and_then(Recognized::known) == Some(&ThinkingDisplay::Updates)
+}
+
+fn is_tool_reference_change(block: &ContentBlock) -> bool {
+    matches!(
+        &block.block_type,
+        Some(ContentBlockType::Other(block_type))
+            if block_type == "tool_addition" || block_type == "tool_removal"
+    ) && block
+        .extra
+        .get("tool")
+        .and_then(|tool| tool.get("type"))
+        .and_then(Value::as_str)
+        == Some("tool_reference")
+}
+
+fn messages_carry_tool_changes(messages: &[Message]) -> bool {
+    messages
+        .iter()
+        .filter(|message| message.role == "system")
+        .flat_map(Message::blocks)
+        .any(is_tool_reference_change)
+}
+
 fn unsupported_param(model: &str, param: &str, value: &str, hint: &str) -> Error {
     Error::InvalidRequest(crate::ErrorDetail::UnsupportedParameter {
         model: model.into(),
@@ -1071,6 +1106,41 @@ mod tests {
         json!({"safeguards": [{"type": "dangerous_tool_use", "classifier_context": {"v": 1, "permission_mode": "auto"}}]}),
         &[]
     )]
+    #[case::adaptive_display_updates(
+        json!({"thinking": {"type": "adaptive", "display": "updates"}}),
+        &["thinking-display-updates-2026-08-18"]
+    )]
+    #[case::enabled_display_updates(
+        json!({"thinking": {"type": "enabled", "budget_tokens": 2048, "display": "updates"}}),
+        &["thinking-display-updates-2026-08-18"]
+    )]
+    #[case::summarized_display(json!({"thinking": {"type": "adaptive", "display": "summarized"}}), &[])]
+    #[case::disabled_thinking(json!({"thinking": {"type": "disabled"}}), &[])]
+    #[case::system_tool_addition(
+        json!({"messages": [
+            {"role": "user", "content": "Use the ping tool"},
+            {"role": "system", "content": [{"type": "tool_addition", "tool": {"type": "tool_reference", "name": "ping"}}]},
+        ]}),
+        &["mid-conversation-tool-changes-2026-07-01"]
+    )]
+    #[case::system_tool_removal(
+        json!({"messages": [
+            {"role": "system", "content": [{"type": "tool_removal", "tool": {"type": "tool_reference", "name": "ping"}}]},
+        ]}),
+        &["mid-conversation-tool-changes-2026-07-01"]
+    )]
+    #[case::user_tool_addition(
+        json!({"messages": [
+            {"role": "user", "content": [{"type": "tool_addition", "tool": {"type": "tool_reference", "name": "ping"}}]},
+        ]}),
+        &[]
+    )]
+    #[case::tool_addition_without_a_tool_reference(
+        json!({"messages": [
+            {"role": "system", "content": [{"type": "tool_addition", "tool": {"type": "tool_definition"}}]},
+        ]}),
+        &[]
+    )]
     fn feature_betas_follow_the_request(#[case] fields: Value, #[case] expected: &[&str]) {
         assert_eq!(feature_betas(&request(fields)), betas(expected));
     }
@@ -1093,6 +1163,33 @@ mod tests {
         );
     }
 
+    #[rstest]
+    #[case::vertex_ai(
+        BetaProvider::VertexAi,
+        &["mid-conversation-tool-changes-2026-07-01", "thinking-display-updates-2026-08-18"]
+    )]
+    #[case::azure_ai(
+        BetaProvider::AzureAi,
+        &["mid-conversation-tool-changes-2026-07-01", "thinking-display-updates-2026-08-18"]
+    )]
+    #[case::bedrock_converse(BetaProvider::BedrockConverse, &["thinking-display-updates-2026-08-18"])]
+    #[case::databricks(BetaProvider::Databricks, &["thinking-display-updates-2026-08-18"])]
+    fn tool_change_and_display_betas_reach_the_providers_that_accept_them(
+        #[case] provider: BetaProvider,
+        #[case] expected: &[&str],
+    ) {
+        let fields = json!({
+            "thinking": {"type": "adaptive", "display": "updates"},
+            "messages": [
+                {"role": "system", "content": [{"type": "tool_addition", "tool": {"type": "tool_reference", "name": "ping"}}]},
+            ],
+        });
+        assert_eq!(
+            provider_feature_betas(&request(fields), provider),
+            betas(expected)
+        );
+    }
+
     #[rstest]
     fn hosts_without_a_beta_map_column_get_safeguards_without_a_derived_beta() {
         let client = headers(&[("anthropic-beta", "claude-code-20250219")]);
diff --git a/litellm-rust/crates/llms/src/azure_ai/messages/transformation.rs b/litellm-rust/crates/llms/src/azure_ai/messages/transformation.rs
index bf934fb4d4c..d578acea68c 100644
--- a/litellm-rust/crates/llms/src/azure_ai/messages/transformation.rs
+++ b/litellm-rust/crates/llms/src/azure_ai/messages/transformation.rs
@@ -545,6 +545,11 @@ mod tests {
         &[("anthropic-beta", "web-search-2025-03-05")],
         &[("x-api-key", "k"), ("anthropic-beta", "structured-outputs-2025-11-13,web-search-2025-03-05")]
     )]
+    #[case::compaction_needs_the_compact_2026_09_04_beta(
+        json!({"compaction": {"type": "summarize"}}),
+        &[],
+        &[("x-api-key", "k"), ("anthropic-beta", "compact-2026-09-04")]
+    )]
     #[case::no_feature_needs_a_beta(json!({}), &[], &[("x-api-key", "k")])]
     #[case::safeguards_need_the_dangerous_tool_use_beta(
         json!({"safeguards": [{"type": "dangerous_tool_use"}]}),
diff --git a/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs b/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs
index 46e5a68dcb8..e5e3a056fab 100644
--- a/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs
+++ b/litellm-rust/crates/llms/src/vertex_ai/messages/transformation.rs
@@ -798,6 +798,18 @@ mod tests {
         ]}}),
         &["compact-2026-01-12", "context-management-2025-06-27"]
     )]
+    #[case::compaction(json!({"compaction": {"type": "summarize"}}), &["compact-2026-09-04"])]
+    #[case::thinking_display_updates(
+        json!({"thinking": {"type": "adaptive", "display": "updates"}}),
+        &["thinking-display-updates-2026-08-18"]
+    )]
+    #[case::tool_addition(
+        json!({"messages": [
+            {"role": "user", "content": "Use the ping tool"},
+            {"role": "system", "content": [{"type": "tool_addition", "tool": {"type": "tool_reference", "name": "ping"}}]}
+        ]}),
+        &["mid-conversation-tool-changes-2026-07-01"]
+    )]
     #[case::advisor_tool_is_not_a_vertex_beta(
         json!({"tools": [{"type": "advisor_20260301", "name": "advisor"}]}),
         &[]
diff --git a/litellm/__init__.py b/litellm/__init__.py
index 5f14c605cd0..f64531f86fb 100644
--- a/litellm/__init__.py
+++ b/litellm/__init__.py
@@ -7,7 +7,6 @@ _apply_process_defaults()
 ### INIT VARIABLES #########################
 import threading
 import os
-import datetime
 
 from collections.abc import Mapping, Sequence
 from typing import (
@@ -550,6 +549,7 @@ _key_management_system: Optional["KeyManagementSystem"] = None
 output_parse_pii: bool = False
 #############################################
 from litellm.litellm_core_utils.get_model_cost_map import get_model_cost_map, mark_litellm_import_complete
+from litellm.litellm_core_utils.model_retirement import is_hidden_as_retired
 
 model_cost = get_model_cost_map(url=model_cost_map_url)
 cost_discount_config: Dict[str, float] = {}  # Provider-specific cost discounts {"vertex_ai": 0.05} = 5% discount
@@ -756,16 +756,6 @@ def is_openai_finetune_model(key: str) -> bool:
     return key.startswith("ft:") and not key.count(":") > 1
 
 
-def _is_past_deprecation_date(value: Mapping[str, object]) -> bool:
-    deprecation_date: Final = value.get("deprecation_date")
-    if not isinstance(deprecation_date, str):
-        return False
-    try:
-        return datetime.date.fromisoformat(deprecation_date) <= datetime.date.today()
-    except ValueError:
-        return False
-
-
 def _populate_provider_model_sets(model_cost_map: Mapping[str, Mapping[str, object]]) -> None:
     for key, value in tuple(model_cost_map.items()):
         if value.get("litellm_provider") == "openai" and not is_openai_finetune_model(key):
@@ -873,12 +863,12 @@ def _populate_provider_model_sets(model_cost_map: Mapping[str, Mapping[str, obje
             if "-to-" not in key and "fireworks-ai-default" not in key:
                 fireworks_ai_models.add(key)
         elif value.get("litellm_provider") == "together_ai":
-            if _is_past_deprecation_date(value):
+            if is_hidden_as_retired(value):
                 together_ai_models.discard(key)
             elif not key.startswith("together-ai-"):
                 together_ai_models.add(key)
         elif value.get("litellm_provider") == "baseten":
-            if _is_past_deprecation_date(value):
+            if is_hidden_as_retired(value):
                 baseten_models.discard(key)
             else:
                 baseten_models.add(key)
@@ -1051,7 +1041,10 @@ def _populate_provider_model_sets(model_cost_map: Mapping[str, Mapping[str, obje
         elif value.get("litellm_provider") == "coralbricks":
             coralbricks_models.add(key)
         elif value.get("litellm_provider") == "aiand":
-            aiand_models.add(key)
+            if is_hidden_as_retired(value):
+                aiand_models.discard(key)
+            else:
+                aiand_models.add(key)
         elif value.get("litellm_provider") == "reducto":
             reducto_models.add(key)
         elif value.get("litellm_provider") == "bedrock_mantle":
diff --git a/litellm/anthropic_beta_headers_config.json b/litellm/anthropic_beta_headers_config.json
index cee5ce15469..253074b0e1f 100644
--- a/litellm/anthropic_beta_headers_config.json
+++ b/litellm/anthropic_beta_headers_config.json
@@ -1,5 +1,5 @@
 {
-  "description": "Mapping of Anthropic beta headers for each provider. Keys are input header names, values are provider-specific header names (or null if unsupported). Only headers present in mapping keys with non-null values can be forwarded.",
+  "description": "Mapping of Anthropic beta headers for each provider. Keys are input header names, values are provider-specific header names (or null if unsupported). Only headers present in mapping keys with non-null values can be forwarded. A <provider>_header_only column lists betas that provider accepts only as the anthropic-beta HTTP header: they are forwarded there and dropped from the anthropic_beta body field. Proxies that predate these columns ignore them and read the provider column alone.",
   "anthropic": {
     "advisor-tool-2026-03-01": "advisor-tool-2026-03-01",
     "advanced-tool-use-2025-11-20": "advanced-tool-use-2025-11-20",
@@ -46,6 +46,7 @@
     "bash_20250124": null,
     "code-execution-2025-08-25": "code-execution-2025-08-25",
     "compact-2026-01-12": null,
+    "compact-2026-09-04": "compact-2026-09-04",
     "computer-use-2025-01-24": "computer-use-2025-01-24",
     "computer-use-2025-11-24": "computer-use-2025-11-24",
     "context-1m-2025-08-07": "context-1m-2025-08-07",
@@ -59,6 +60,7 @@
     "mcp-client-2025-11-20": "mcp-client-2025-11-20",
     "mcp-client-2025-04-04": "mcp-client-2025-04-04",
     "mcp-servers-2025-12-04": null,
+    "mid-conversation-tool-changes-2026-07-01": "mid-conversation-tool-changes-2026-07-01",
     "output-128k-2025-02-19": null,
     "structured-output-2024-03-01": null,
     "per-turn-control-2026-07-01": "per-turn-control-2026-07-01",
@@ -202,6 +204,7 @@
     "mcp-client-2025-11-20": null,
     "mcp-client-2025-04-04": null,
     "mcp-servers-2025-12-04": null,
+    "mid-conversation-tool-changes-2026-07-01": "mid-conversation-tool-changes-2026-07-01",
     "output-128k-2025-02-19": null,
     "structured-output-2024-03-01": null,
     "per-turn-control-2026-07-01": "per-turn-control-2026-07-01",
@@ -218,6 +221,10 @@
     "web-search-2025-03-05": "web-search-2025-03-05",
     "inline-tools-2026-09-15": "inline-tools-2026-09-15"
   },
+  "vertex_ai_header_only": {
+    "compact-2026-09-04": "compact-2026-09-04",
+    "inline-tools-2026-09-15": "inline-tools-2026-09-15"
+  },
   "databricks": {
     "advisor-tool-2026-03-01": null,
     "advanced-tool-use-2025-11-20": null,
diff --git a/litellm/anthropic_beta_headers_manager.py b/litellm/anthropic_beta_headers_manager.py
index 07730a0fbf8..be2ff07e088 100644
--- a/litellm/anthropic_beta_headers_manager.py
+++ b/litellm/anthropic_beta_headers_manager.py
@@ -30,7 +30,7 @@ from collections.abc import Mapping
 from concurrent.futures import ThreadPoolExecutor
 from functools import cache
 from importlib.resources import files
-from typing import Final, TypeAlias
+from typing import Final, Literal, TypeAlias
 
 import httpx
 from pydantic import TypeAdapter
@@ -47,6 +47,9 @@ BetaHeadersConfig: TypeAlias = Mapping[str, str | Mapping[str, str | None]]
 _BETA_HEADERS_CONFIG_ADAPTER: Final = TypeAdapter(BetaHeadersConfig)
 _DECODED_JSON: Final = TypeAdapter(object)
 
+BetaPlacement: TypeAlias = Literal["header", "body"]
+_HEADER_ONLY_COLUMN_SUFFIX: Final = "_header_only"
+
 
 class GetAnthropicBetaHeadersConfig:
     """
@@ -241,6 +244,31 @@ def get_provider_name(provider: str) -> str:
     return aliases.get(provider, provider)
 
 
+def _beta_column(name: str) -> Mapping[str, str | None]:
+    column: Final[Mapping[str, str | None]] = _load_beta_headers_config().get(name, {})
+    return column
+
+
+def _header_only_column(canonical_provider: str) -> Mapping[str, str | None]:
+    return _beta_column(f"{canonical_provider}{_HEADER_ONLY_COLUMN_SUFFIX}")
+
+
+def _provider_beta_mapping(provider: str, placement: BetaPlacement) -> Mapping[str, str | None]:
+    canonical_provider: Final = get_provider_name(provider)
+    column: Final = _beta_column(canonical_provider)
+    header_only: Final = _header_only_column(canonical_provider)
+    match placement:
+        case "header":
+            return {**column, **header_only}
+        case "body":
+            return {beta: name for beta, name in column.items() if beta not in header_only}
+
+
+def get_header_only_betas(provider: str) -> frozenset[str]:
+    header_only: Final = _header_only_column(get_provider_name(provider))
+    return frozenset(beta for beta, name in header_only.items() if name is not None)
+
+
 def has_beta_headers_config(provider: str) -> bool:
     config: Final = _bundled_beta_headers_config()
     aliases: Final = config.get("provider_aliases", {})
@@ -251,6 +279,7 @@ def has_beta_headers_config(provider: str) -> bool:
 def filter_and_transform_beta_headers(
     beta_headers: list[str],
     provider: str,
+    placement: BetaPlacement = "header",
 ) -> list[str]:
     """
     Filter and transform beta headers based on provider's mapping configuration.
@@ -263,6 +292,7 @@ def filter_and_transform_beta_headers(
     Args:
         beta_headers: List of Anthropic beta header values
         provider: Provider name (e.g., "anthropic", "bedrock", "vertex_ai")
+        placement: Whether the betas travel as the anthropic-beta header or the anthropic_beta body field
 
     Returns:
         List of filtered and transformed beta headers for the provider
@@ -270,11 +300,7 @@ def filter_and_transform_beta_headers(
     if not beta_headers:
         return []
 
-    config: Final = _load_beta_headers_config()
-    provider = get_provider_name(provider)
-
-    # Get the header mapping for this provider
-    provider_mapping: Final = config.get(provider, {})
+    provider_mapping: Final = _provider_beta_mapping(provider, placement)
 
     filtered_headers: Final[set[str]] = set()
 
@@ -426,6 +452,7 @@ def update_request_with_filtered_beta(
     filtered_body_betas: Final = filter_and_transform_beta_headers(
         beta_headers=existing_body_betas,
         provider=provider,
+        placement="body",
     )
 
     if filtered_body_betas:
diff --git a/litellm/integrations/prometheus.py b/litellm/integrations/prometheus.py
index e6318525b88..5c2f0f553a8 100644
--- a/litellm/integrations/prometheus.py
+++ b/litellm/integrations/prometheus.py
@@ -82,6 +82,7 @@ from litellm.types.proxy.carried_budget_state import (
     UserBudgetSnapshot,
 )
 from litellm.types.utils import (
+    CallTypes,
     StandardLoggingGuardrailInformation,
     StandardLoggingPayload,
     StandardLoggingZeroCostDiagnostic,
@@ -279,6 +280,11 @@ def _logged_fields(value: object) -> Mapping[str, object]:
         return _NO_LOGGED_FIELDS
 
 
+_GOOGLE_PASS_THROUGH_PROVIDERS: Final = frozenset(
+    (litellm.LlmProviders.GEMINI.value, litellm.LlmProviders.VERTEX_AI.value)
+)
+
+
 def _is_llm_provider(name: str) -> bool:
     routable: Final = (
         name in litellm.provider_list or JSONProviderRegistry.exists(name) or is_registered_custom_provider(name)
@@ -2942,6 +2948,22 @@ class PrometheusLogger(CustomLogger):
 
         return False
 
+    @staticmethod
+    def _google_pass_through_provider(request_data: Mapping[str, object]) -> str | None:
+        declared_provider: Final = request_data.get("custom_llm_provider")
+        if request_data.get("call_type") != CallTypes.pass_through.value or not isinstance(declared_provider, str):
+            return None
+        return declared_provider if declared_provider in _GOOGLE_PASS_THROUGH_PROVIDERS else None
+
+    @staticmethod
+    def _failed_request_requested_model(request_data: Mapping[str, object]) -> object:
+        requested_model: Final = request_data.get("model", "")
+        if PrometheusLogger._google_pass_through_provider(request_data) is None:
+            return requested_model
+        request_metadata: Final = _logged_fields(_logged_fields(request_data.get("litellm_params")).get("metadata"))
+        model_group: Final = request_metadata.get("model_group")
+        return model_group if isinstance(model_group, str) and model_group else requested_model
+
     @staticmethod
     def _extract_api_provider_from_request_data(request_data: dict) -> str | None:
         """
@@ -2950,22 +2972,27 @@ class PrometheusLogger(CustomLogger):
         A request can fail before a deployment is resolved, so the provider is
         not always known. Prefer the resolved ``custom_llm_provider`` on
         ``litellm_params``, then any provider recovered onto a partial
-        ``standard_logging_object`` (e.g. a stream that broke mid-flight), and
-        finally infer it from the requested model name (e.g. ``gpt-4o-mini`` ->
-        ``openai``) since the proxy's failure ``request_data`` usually carries
-        only the client-supplied model. Return ``None`` when it cannot be
-        determined so the label emits empty rather than a guess.
+        ``standard_logging_object`` (e.g. a stream that broke mid-flight). On a
+        Gemini or Vertex pass-through failure only, next take the provider the
+        failure payload names (``gemini`` or ``vertex_ai``), so every other
+        pass-through route keeps its earlier label. Finally infer it from the
+        requested model name (e.g. ``gpt-4o-mini`` -> ``openai``) since the
+        proxy's failure ``request_data`` usually carries only the client-supplied
+        model. Return ``None`` when it cannot be determined so the label emits
+        empty rather than a guess.
         """
         litellm_params: Final = request_data.get("litellm_params") or {}
-        provider = litellm_params.get("custom_llm_provider")
-        if provider:
-            return provider
         standard_logging_object: Final = request_data.get("standard_logging_object") or {}
-        provider = standard_logging_object.get("custom_llm_provider")
-        if provider:
-            return provider
+        resolved_provider: Final = litellm_params.get("custom_llm_provider") or standard_logging_object.get(
+            "custom_llm_provider"
+        )
+        if resolved_provider:
+            return resolved_provider
+        google_provider: Final = PrometheusLogger._google_pass_through_provider(request_data)
+        if google_provider is not None:
+            return google_provider
         model: Final = litellm_params.get("model") or request_data.get("model")
-        if not model:
+        if not isinstance(model, str) or not model:
             return None
         try:
             return litellm.get_llm_provider(model=model)[1] or None
@@ -3052,7 +3079,7 @@ class PrometheusLogger(CustomLogger):
                 team_alias=user_api_key_dict.team_alias,
                 org_id=user_api_key_dict.org_id,
                 org_alias=user_api_key_dict.organization_alias,
-                requested_model=_bounded_requested_model_label(request_data.get("model", "")),
+                requested_model=_bounded_requested_model_label(self._failed_request_requested_model(request_data)),
                 status_code=str(status_code),
                 exception_status=str(status_code),
                 exception_class=self._get_exception_class_name(original_exception),
diff --git a/litellm/litellm_core_utils/core_helpers.py b/litellm/litellm_core_utils/core_helpers.py
index 28f45d2bb2c..20e10f63f83 100644
--- a/litellm/litellm_core_utils/core_helpers.py
+++ b/litellm/litellm_core_utils/core_helpers.py
@@ -9,12 +9,13 @@ from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, Final, Literal, Protocol, TypeVar, cast, runtime_checkable
 
 import httpx
-from pydantic import TypeAdapter, ValidationError
+from pydantic import BaseModel, TypeAdapter, ValidationError
 from typing_extensions import TypeIs  # noqa: TID251  # narrows a duck-typed value to the Protocol its caller reads
 
 import litellm
 from litellm._logging import verbose_logger
 from litellm.constants import KUBERNETES_POD_ROUTING_KEY
+from litellm.litellm_core_utils.hidden_params import set_extra_attribute
 from litellm.litellm_core_utils.llm_response_utils.get_headers import get_provider_request_id
 from litellm.types.llms.openai import AllMessageValues, OpenAIChatCompletionFinishReason
 
@@ -710,9 +711,9 @@ def preserve_upstream_non_openai_attributes(
     _assign_attributes(model_response, original_chunk.model_dump(include=frozenset(candidate_keys)).items())
 
 
-def _assign_attributes(target: object, values: Iterable[tuple[str, object]]) -> None:
+def _assign_attributes(target: BaseModel, values: Iterable[tuple[str, object]]) -> None:
     for key, value in values:
-        setattr(target, key, value)
+        set_extra_attribute(target, key, value)
 
 
 def safe_deep_copy(data):
@@ -982,25 +983,36 @@ def _usage_field(usage: object, name: str) -> object:
     return getattr(usage, name, None)
 
 
-def _cost_number(value: object) -> float | None:
-    if isinstance(value, bool) or not isinstance(value, int | float):
+def finite_cost(value: object) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, int | float) or not math.isfinite(value):
         return None
     return float(value)
 
 
+def single_log_line(value: object) -> str:
+    return str(value).replace("\r", "").replace("\n", "")
+
+
+def finite_reported_cost(value: object) -> float | None:
+    cost: Final = finite_cost(value)
+    if cost is None and isinstance(value, float):
+        verbose_logger.warning("Ignoring a non-finite provider-reported cost %s", value)
+    return cost
+
+
 def _reported_cost_value(value: object) -> float | None:
     """A reported cost is a number, or a breakdown whose total lives under ``total_cost``."""
     raw: Final[object] = value
     if isinstance(value, Mapping):
-        return _cost_number(_usage_field(raw, "total_cost"))
-    return _cost_number(value)
+        return finite_reported_cost(_usage_field(raw, "total_cost"))
+    return finite_reported_cost(value)
 
 
 def response_cost_in_hidden_params(response: _CarriesHiddenParams) -> float | None:
     additional_headers: Final[object] = response.hidden_params.get("additional_headers")
     if not isinstance(additional_headers, Mapping):
         return None
-    return _cost_number(_USAGE_BLOCK_ADAPTER.validate_python(additional_headers).get(RESPONSE_COST_HEADER))
+    return finite_reported_cost(_USAGE_BLOCK_ADAPTER.validate_python(additional_headers).get(RESPONSE_COST_HEADER))
 
 
 def override_stamped_response_cost(response: _CarriesHiddenParams, cost: float) -> None:
diff --git a/litellm/litellm_core_utils/exception_mapping_utils.py b/litellm/litellm_core_utils/exception_mapping_utils.py
index 5a27f5446ad..33b6d4e1857 100644
--- a/litellm/litellm_core_utils/exception_mapping_utils.py
+++ b/litellm/litellm_core_utils/exception_mapping_utils.py
@@ -18,6 +18,7 @@ from litellm.litellm_core_utils.bug_report import (
 )
 from litellm.litellm_core_utils.core_helpers import as_str_mapping, attribute_or_none
 from litellm.litellm_core_utils.secret_redaction import redact_string as redact_secret_string
+from litellm.llms.bedrock.common_utils import bedrock_model_reaches_converse_by_default
 from litellm.llms.bigmodel.common_utils import raise_bigmodel_business_error
 from litellm.types.utils import LlmProviders
 
@@ -938,13 +939,22 @@ _BEDROCK_MANTLE_CONTEXT_WINDOW_GENERIC_MESSAGE: Final = (
 )
 
 
-def _bedrock_mantle_context_window_response(original_exception: _ProviderHTTPException) -> httpx.Response:
+def _bedrock_response_with_status(original_exception: _ProviderHTTPException, status_code: int) -> httpx.Response:
     original_response: Final = getattr(original_exception, "response", None)
     if not isinstance(original_response, httpx.Response) or getattr(original_response, "_request", None) is None:
-        return httpx.Response(status_code=400, request=httpx.Request(method="POST", url="https://api.openai.com/v1/"))
-    if original_response.status_code == 400:
+        return httpx.Response(
+            status_code=status_code, request=httpx.Request(method="POST", url="https://api.openai.com/v1/")
+        )
+    if original_response.status_code == status_code:
         return original_response
-    return httpx.Response(status_code=400, headers=original_response.headers, request=original_response.request)
+    return httpx.Response(status_code=status_code, headers=original_response.headers, request=original_response.request)
+
+
+def _came_from_bedrock_converse(original_exception: _ProviderHTTPException) -> bool:
+    original_response: Final = getattr(original_exception, "response", None)
+    if not isinstance(original_response, httpx.Response) or getattr(original_response, "_request", None) is None:
+        return False
+    return original_response.request.url.path.endswith(("/converse", "/converse-stream"))
 
 
 def _get_bedrock_mantle_context_window_message(error_str: str) -> str | None:
@@ -980,7 +990,7 @@ def _map_bedrock_exception(
                 message=mantle_context_window_message,
                 model=model,
                 llm_provider=custom_llm_provider,
-                response=_bedrock_mantle_context_window_response(original_exception),
+                response=_bedrock_response_with_status(original_exception, 400),
             )
     if (
         "too many tokens" in error_str
@@ -1003,6 +1013,18 @@ def _map_bedrock_exception(
             llm_provider="bedrock",
             response=getattr(original_exception, "response", None),
         )
+    elif (
+        "The provided model identifier is invalid" in error_str
+        and bool(model)
+        and _came_from_bedrock_converse(original_exception)
+        and bedrock_model_reaches_converse_by_default(model)
+    ):
+        raise NotFoundError(
+            message=f"BedrockException - {error_str}",
+            model=model,
+            llm_provider="bedrock",
+            response=_bedrock_response_with_status(original_exception, 404),
+        )
     elif "Malformed input request" in error_str:
         raise BadRequestError(
             message=f"BedrockException - {error_str}",
diff --git a/litellm/litellm_core_utils/hidden_params.py b/litellm/litellm_core_utils/hidden_params.py
index a74337d2549..c04d7614b90 100644
--- a/litellm/litellm_core_utils/hidden_params.py
+++ b/litellm/litellm_core_utils/hidden_params.py
@@ -1,8 +1,9 @@
 from collections.abc import Iterator, Mapping, MutableMapping
+from functools import cache, lru_cache
 from types import MappingProxyType
 from typing import Final, Protocol, cast
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, create_model
 
 from litellm.types.llms.base import HiddenParams
 
@@ -60,6 +61,38 @@ def stored_attribute(obj: object, name: str) -> object:
     return extras.get(name)
 
 
+@cache
+def _assigned_extras_join_fields_set() -> bool:
+    probe: Final = create_model("_ExtraAssignmentProbe", __config__=ConfigDict(extra="allow"))()
+    setattr(probe, "assigned", None)
+    return "assigned" in probe.model_fields_set
+
+
+@lru_cache(maxsize=1024)
+def _writes_plain_extra(model_class: type[BaseModel], name: str) -> bool:
+    config: Final = model_class.model_config
+    return (
+        model_class.__setattr__ is BaseModel.__setattr__
+        and config.get("extra") == "allow"
+        and not config.get("frozen")
+        and not config.get("validate_assignment")
+        and not name.startswith("_")
+        and name not in model_class.__pydantic_fields__
+        and name not in model_class.__class_vars__
+        and not hasattr(model_class, name)
+        and _assigned_extras_join_fields_set()
+    )
+
+
+def set_extra_attribute(model: BaseModel, name: str, value: object) -> None:
+    extras: Final = model.__pydantic_extra__
+    if extras is None or not _writes_plain_extra(type(model), name):
+        setattr(model, name, value)
+        return
+    extras[name] = value
+    model.__pydantic_fields_set__.add(name)
+
+
 def _get_hidden_params_storage(obj: object) -> object | None:
     if isinstance(obj, dict):
         return obj.get(_HIDDEN_PARAMS_ATTR)
diff --git a/litellm/litellm_core_utils/internal_call_metadata.py b/litellm/litellm_core_utils/internal_call_metadata.py
index f3dbd612bee..453d4358b35 100644
--- a/litellm/litellm_core_utils/internal_call_metadata.py
+++ b/litellm/litellm_core_utils/internal_call_metadata.py
@@ -35,6 +35,12 @@ from litellm.types.utils import (
 
 BUDGET_RESERVATION_METADATA_KEYS: Final = frozenset({"user_api_key_budget_reservation"})
 
+ITPM_RESERVED_KEY: Final = "_litellm_itpm_reserved"
+OTPM_RESERVED_KEY: Final = "_litellm_otpm_reserved"
+ITPM_CACHE_KEY: Final = "_litellm_itpm_cache_key"
+OTPM_CACHE_KEY: Final = "_litellm_otpm_cache_key"
+IO_TOKEN_RESERVATION_KEYS: Final = frozenset({ITPM_RESERVED_KEY, OTPM_RESERVED_KEY, ITPM_CACHE_KEY, OTPM_CACHE_KEY})
+
 MODEL_ACCESS_GROUP_METADATA_KEY: Final = "user_api_key_matched_model_access_groups"
 """Where auth records the model access groups that authorized the request, for the spend writer.
 
diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py
index 4dd33fa5565..26949d9bbfb 100644
--- a/litellm/litellm_core_utils/litellm_logging.py
+++ b/litellm/litellm_core_utils/litellm_logging.py
@@ -76,6 +76,7 @@ from litellm.litellm_core_utils.classifier_logging import (
     is_classifier_call,
 )
 from litellm.litellm_core_utils.core_helpers import (
+    finite_cost,
     get_provider_response_headers_from_hidden_params,
     is_expected_client_error,
     native_messages_reported_cost,
@@ -84,6 +85,7 @@ from litellm.litellm_core_utils.core_helpers import (
     proxy_stamped_used_client_oauth_token,
     reconstruct_model_name,
     set_response_cost_in_hidden_params,
+    single_log_line,
 )
 from litellm.litellm_core_utils.error_normalization import normalize_error
 from litellm.litellm_core_utils.get_litellm_params import get_litellm_params
@@ -567,7 +569,13 @@ def _resolve_mantle_region_for_cost(
 
 _PER_CALL_LITELLM_PARAM_DICTS: Final = frozenset({"metadata", "litellm_metadata"})
 _LITELLM_PARAMS: Final = TypeAdapter(dict[str, object])
+_SERVED_ANTHROPIC_BODY: Final = TypeAdapter(dict[str, object])
 _REDACTED_RESULT: Final = TypeAdapter(object)
+_GUARDRAIL_INFORMATION_KEY: Final = "standard_logging_guardrail_information"
+
+
+def _without_guardrail_information(metadata: Mapping[str, object]) -> Mapping[str, object]:
+    return {key: value for key, value in metadata.items() if key != _GUARDRAIL_INFORMATION_KEY}
 
 
 def _provider_response_id(source: object) -> str | None:
@@ -2088,7 +2096,7 @@ class Logging(LiteLLMLoggingBaseClass):
                     litellm_model_name=litellm_model_name,
                     router_model_id=router_model_id or hidden_params.get("model_id"),
                 )
-                return hidden_params["response_cost"]
+                return self._recorded_response_cost(hidden_params["response_cost"])
             elif router_model_id is None and "model_id" in hidden_params:  # use model_id if not already set
                 router_model_id = hidden_params["model_id"]
 
@@ -2188,7 +2196,7 @@ class Logging(LiteLLMLoggingBaseClass):
                 litellm_model_name=litellm_model_name,
                 router_model_id=router_model_id,
             )
-            return total_response_cost
+            return self._recorded_response_cost(total_response_cost)
         except Exception as e:  # error calculating cost
             debug_info = StandardLoggingModelCostFailureDebugInformation(
                 error_str=str(e),
@@ -2214,6 +2222,15 @@ class Logging(LiteLLMLoggingBaseClass):
 
     _response_cost_calculator = response_cost_calculator
 
+    def _recorded_response_cost(self, cost: float | None) -> float | None:
+        if cost is None or finite_cost(cost) is not None:
+            return cost
+        verbose_logger.warning(
+            "Recording a non-finite response_cost as 0 for litellm_call_id=%s", single_log_line(self.litellm_call_id)
+        )
+        self.cost_breakdown = None
+        return 0.0
+
     def uncached_price(self, result: object) -> UncachedPrice:
         previous_cost_breakdown: Final = self.cost_breakdown
         previous_billed_token_rates: Final = self.billed_token_rates
@@ -2566,6 +2583,23 @@ class Logging(LiteLLMLoggingBaseClass):
         attempt.model_call_details = dict(self.model_call_details)
         return attempt
 
+    def guardrail_scoped_copy(self) -> "Logging":
+        request_params: Final = _LITELLM_PARAMS.validate_python(
+            self.litellm_params or {}  # pyright: ignore[reportUnknownMemberType]  # Logging.litellm_params is untyped
+        )
+        litellm_params: Final = {
+            **request_params,
+            **{
+                key: _without_guardrail_information(_METADATA_MAPPING.validate_python(value))
+                for key, value in request_params.items()
+                if key in _PER_CALL_LITELLM_PARAM_DICTS and isinstance(value, dict)
+            },
+        }
+        scoped: Final = copy.copy(self)
+        scoped.litellm_params = litellm_params
+        scoped.model_call_details = {**self.model_call_details, "litellm_params": litellm_params}
+        return scoped
+
     def dispatch_attempt_failure_handlers(
         self, exception: Exception, traceback_exception: str
     ) -> Coroutine[None, None, None]:
@@ -5034,13 +5068,15 @@ class Logging(LiteLLMLoggingBaseClass):
             verbose_logger.warning("LiteLLM: the anthropic_messages stream assembled no response, logging an empty one")
             return litellm.ModelResponse(model=self.model)
         else:
-            from litellm.types.llms.anthropic import AnthropicResponse
-
-            pydantic_result: Final = AnthropicResponse.model_validate({"stop_sequence": None, **(served_body or {})})
-            import httpx
-
+            anthropic_body: Final = (
+                served_body
+                if served_body is not None
+                else _SERVED_ANTHROPIC_BODY.validate_python(
+                    result.model_dump() if isinstance(result, BaseModel) else result
+                )
+            )
             result = litellm.AnthropicConfig().transform_parsed_response(
-                completion_response=pydantic_result.model_dump(),
+                completion_response={"stop_sequence": None, **anthropic_body},
                 raw_response=httpx.Response(
                     status_code=200,
                     headers={},
@@ -7560,7 +7596,15 @@ def get_standard_logging_object_payload(
         )
         custom_pricing: Final = False if spilled_over else logging_obj.custom_pricing_for(init_response_obj)
         raw_response_cost: Final = kwargs.get("response_cost")
-        llm_response_cost: Final[float] = raw_response_cost or 0.0
+        numeric_response_cost: Final = raw_response_cost if isinstance(raw_response_cost, int | float) else None
+        priced_response_cost: Final = finite_cost(numeric_response_cost)
+        if numeric_response_cost is not None and priced_response_cost is None:
+            verbose_logger.warning(
+                "Logging a non-finite response_cost=%s as 0 for litellm_call_id=%s",
+                numeric_response_cost,
+                single_log_line(logging_obj.litellm_call_id),
+            )
+        llm_response_cost: Final[float] = priced_response_cost or 0.0
         guardrail_cost: Final = guardrail_information_cost(metadata.get("standard_logging_guardrail_information"))
         finalized_cost: Final = _finalized_cost_of(logging_obj)
         response_cost: Final[float] = (
diff --git a/litellm/litellm_core_utils/llm_request_utils.py b/litellm/litellm_core_utils/llm_request_utils.py
index 9c2ec0b8984..84f161e0c62 100644
--- a/litellm/litellm_core_utils/llm_request_utils.py
+++ b/litellm/litellm_core_utils/llm_request_utils.py
@@ -1,4 +1,3 @@
-import datetime
 from collections.abc import Iterable, Iterator, Mapping
 from dataclasses import dataclass
 from typing import Final, cast
@@ -9,6 +8,7 @@ from typing_extensions import NotRequired, ReadOnly, TypedDict
 import litellm
 from litellm.constants import DEFAULT_MAX_RECURSE_DEPTH
 from litellm.litellm_core_utils.get_llm_provider_logic import inferred_provider
+from litellm.litellm_core_utils.model_retirement import is_past_deprecation_date
 
 
 def _form_field_value(value: object) -> str:
@@ -168,7 +168,9 @@ class RankedChatModel:
 
 
 def rank_chat_models_from_llm_provider(custom_llm_provider: str) -> tuple[RankedChatModel, ...]:
-    known_models: Final[Iterable[str]] = litellm.models_by_provider.get(custom_llm_provider, ())
+    from litellm.utils import bundled_provider_models
+
+    known_models: Final = bundled_provider_models(custom_llm_provider)
     ranked_models: Final = (
         RankedChatModel(
             model=model, route_rank=route_rank, cost=cost, is_past_deprecation_date=is_past_deprecation_date
@@ -187,18 +189,11 @@ _COST_MAP_DEPRECATION: Final = TypeAdapter(_CostMapDeprecation)
 
 
 def _is_past_deprecation_date(cost_map_key: str) -> bool:
-    deprecation_date: Final = _COST_MAP_DEPRECATION.validate_python(
-        litellm.model_cost.get(cost_map_key) or {}  # pyright: ignore[reportUnknownMemberType]  # untyped cost map JSON
-    ).get("deprecation_date")
-    if not isinstance(deprecation_date, str):
-        return False
-    try:
-        return (
-            datetime.date.fromisoformat(deprecation_date)
-            <= datetime.datetime.now(datetime.timezone.utc).astimezone().date()
+    return is_past_deprecation_date(
+        _COST_MAP_DEPRECATION.validate_python(
+            litellm.model_cost.get(cost_map_key) or {}  # pyright: ignore[reportUnknownMemberType]  # untyped cost map JSON
         )
-    except ValueError:
-        return False
+    )
 
 
 def _chat_row_costs(models: Iterable[str], custom_llm_provider: str) -> Iterator[tuple[str, float, bool]]:
diff --git a/litellm/litellm_core_utils/model_retirement.py b/litellm/litellm_core_utils/model_retirement.py
new file mode 100644
index 00000000000..3bfb834733d
--- /dev/null
+++ b/litellm/litellm_core_utils/model_retirement.py
@@ -0,0 +1,19 @@
+import datetime
+from collections.abc import Mapping
+from typing import Final
+
+PROVIDERS_HIDING_RETIRED_MODELS: Final = frozenset({"aiand", "baseten", "together_ai"})
+
+
+def is_past_deprecation_date(value: Mapping[str, object]) -> bool:
+    deprecation_date: Final = value.get("deprecation_date")
+    if not isinstance(deprecation_date, str):
+        return False
+    try:
+        return datetime.date.fromisoformat(deprecation_date) <= datetime.datetime.now(datetime.timezone.utc).date()
+    except ValueError:
+        return False
+
+
+def is_hidden_as_retired(value: Mapping[str, object]) -> bool:
+    return value.get("litellm_provider") in PROVIDERS_HIDING_RETIRED_MODELS and is_past_deprecation_date(value)
diff --git a/litellm/litellm_core_utils/reasoning_effort_utils.py b/litellm/litellm_core_utils/reasoning_effort_utils.py
index acd20aeb37d..e9c94e32f8f 100644
--- a/litellm/litellm_core_utils/reasoning_effort_utils.py
+++ b/litellm/litellm_core_utils/reasoning_effort_utils.py
@@ -1,6 +1,12 @@
+import reprlib
+from collections.abc import Collection, Mapping
+from dataclasses import dataclass
 from typing import Final, Literal
 
+from pydantic import TypeAdapter
+
 import litellm
+from litellm._logging import verbose_logger
 from litellm.constants import (
     DEFAULT_REASONING_EFFORT_HIGH_THINKING_BUDGET,
     DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET,
@@ -11,6 +17,54 @@ from litellm.litellm_core_utils.core_helpers import as_str_mapping
 
 OpenAIStyleReasoningEffort = Literal["minimal", "low", "medium", "high"]
 
+_DROP_WARNING: Final = "Dropping %s=%s for model=%r because %s"
+_DROP_PARAMS_DROP_WARNING: Final = "Dropping %s=%s for model=%r (drop_params=True) because %s"
+_NON_NUMERIC_BUDGET_REASON: Final = "it is not a number. Send budget_tokens as an integer to set a reasoning level."
+_NON_STRING_EFFORT_REASON: Final = (
+    "it is not a string. Send reasoning_effort as a level name such as 'high' to set a reasoning level."
+)
+_REASONING_PARAMS: Final = ("reasoning", "reasoning_effort", "thinking")
+OPAQUE_VALUE: Final = TypeAdapter(object)
+
+
+def warn_dropped_reasoning(
+    param: str, value: object, model: str | None, reason: str, *, drop_params_gated: bool
+) -> None:
+    verbose_logger.warning(
+        _DROP_PARAMS_DROP_WARNING if drop_params_gated else _DROP_WARNING, param, reprlib.repr(value), model, reason
+    )
+
+
+def warn_non_string_reasoning_effort(value: object, model: str | None) -> None:
+    effort: Final = as_str_mapping(value)
+    requested_level: Final = effort.get("effort") if effort is not None else value
+    if requested_level is None or isinstance(value, str):
+        return
+    warn_dropped_reasoning("reasoning_effort", value, model, _NON_STRING_EFFORT_REASON, drop_params_gated=False)
+
+
+def warn_dropped_reasoning_params(
+    dropped: Collection[object],
+    request: Mapping[str, object],
+    model: str | None,
+    reason: str,
+    *,
+    drop_params_gated: bool,
+) -> None:
+    for param in _REASONING_PARAMS:
+        if param in dropped and param in request:
+            warn_dropped_reasoning(param, request[param], model, reason, drop_params_gated=drop_params_gated)
+
+
+@dataclass(frozen=True, slots=True)
+class DroppedThinkingBudget:
+    budget_tokens: object
+
+    def warn(self, model: str) -> None:
+        warn_dropped_reasoning(
+            "thinking.budget_tokens", self.budget_tokens, model, _NON_NUMERIC_BUDGET_REASON, drop_params_gated=True
+        )
+
 
 def reasoning_effort_from_thinking_budget(
     budget_tokens: float,
@@ -29,7 +83,9 @@ def reasoning_effort_from_thinking_budget(
     return "minimal"
 
 
-def reasoning_effort_from_thinking(thinking: object, *, drop_params: bool) -> OpenAIStyleReasoningEffort | None:
+def _effort_or_dropped_budget(
+    thinking: object, *, drop_params: bool
+) -> OpenAIStyleReasoningEffort | DroppedThinkingBudget | None:
     fields: Final = as_str_mapping(thinking)
     if fields is None or fields.get("type") != "enabled":
         return None
@@ -37,10 +93,27 @@ def reasoning_effort_from_thinking(thinking: object, *, drop_params: bool) -> Op
     if isinstance(budget, (int, float)) and not isinstance(budget, bool):
         return reasoning_effort_from_thinking_budget(budget)
     if drop_params or litellm.drop_params is True:
-        return None
+        return DroppedThinkingBudget(budget)
     raise non_numeric_thinking_budget_error(budget)
 
 
+def reasoning_effort_from_thinking(
+    thinking: object, *, model: str, drop_params: bool
+) -> OpenAIStyleReasoningEffort | None:
+    effort: Final = _effort_or_dropped_budget(thinking, drop_params=drop_params)
+    if not isinstance(effort, DroppedThinkingBudget):
+        return effort
+    effort.warn(model)
+    return None
+
+
+def reasoning_effort_from_thinking_silently(
+    thinking: object, *, drop_params: bool
+) -> OpenAIStyleReasoningEffort | None:
+    effort: Final = _effort_or_dropped_budget(thinking, drop_params=drop_params)
+    return None if isinstance(effort, DroppedThinkingBudget) else effort
+
+
 def non_numeric_thinking_budget_error(budget: object) -> UnsupportedParamsError:
     return UnsupportedParamsError(
         message=(
diff --git a/litellm/litellm_core_utils/redact_messages.py b/litellm/litellm_core_utils/redact_messages.py
index 8cc8b2a8ef6..ca508fc9d08 100644
--- a/litellm/litellm_core_utils/redact_messages.py
+++ b/litellm/litellm_core_utils/redact_messages.py
@@ -265,6 +265,7 @@ def _redacted_provider_specific_fields(fields: Mapping[str, object]) -> Mapping[
                 "reasoningContentBlocks",
                 "citations",
                 "compaction_blocks",
+                "compaction_start",
                 "compaction_delta",
                 "token_ids",
             )
diff --git a/litellm/litellm_core_utils/safe_json_dumps.py b/litellm/litellm_core_utils/safe_json_dumps.py
index 24c401281ef..909e1222ae6 100644
--- a/litellm/litellm_core_utils/safe_json_dumps.py
+++ b/litellm/litellm_core_utils/safe_json_dumps.py
@@ -1,4 +1,5 @@
 import json
+import math
 from collections.abc import Callable
 from typing import Any, Final
 
@@ -14,16 +15,23 @@ def strip_null_bytes(value: str) -> str:
     return value.replace("\x00", "")
 
 
+def _finite_or_none(value: float | None) -> float | None:
+    return None if isinstance(value, float) and not math.isfinite(value) else value
+
+
 def safe_json_structure(
     data: object,
     max_depth: int = DEFAULT_MAX_RECURSE_DEPTH,
     value_transform: Callable[[str | None, str], str] | None = None,
     key: str | None = None,
+    *,
+    non_finite_as_null: bool = False,
 ) -> object:
     """
     Rebuild data out of JSON-native pieces while detecting circular references.
     If a circular reference is detected then a marker string is returned.
-    NUL bytes are stripped from strings to prevent PostgreSQL 22P05 errors.
+    NUL bytes are stripped from strings to prevent PostgreSQL 22P05 errors. With
+    non_finite_as_null, NaN and infinite floats become null, since jsonb rejects them.
 
     value_transform, when given, is applied to every string leaf (and to the
     str() fallback for non-serializable objects) with the mapping key the leaf
@@ -43,7 +51,7 @@ def safe_json_structure(
             cleaned = obj.replace("\x00", "") if "\x00" in obj else obj
             return _transform(key, cleaned)
         if isinstance(obj, (int, float, bool, type(None))):
-            return obj
+            return _finite_or_none(obj) if non_finite_as_null else obj
         # Check for circular reference.
         if id(obj) in seen:
             return "CircularReference Detected"
@@ -65,8 +73,9 @@ def safe_json_structure(
             seen.remove(id(obj))
             return tuple_result
         elif isinstance(obj, set):
-            sortable_values: Final[list[Any]] = [_serialize(item, seen, depth + 1, key) for item in obj]
-            set_result: Final = sorted(sortable_values)
+            members: Final[list[Any]] = [_serialize(item, seen, depth + 1, key) for item in obj]
+            present: Final = sorted(member for member in members if member is not None)
+            set_result: Final = present + [None] * members.count(None)
             seen.remove(id(obj))
             return set_result
         elif isinstance(obj, BaseModel):
@@ -88,6 +97,10 @@ def safe_dumps(
     data: object,
     max_depth: int = DEFAULT_MAX_RECURSE_DEPTH,
     value_transform: Callable[[str | None, str], str] | None = None,
+    *,
+    non_finite_as_null: bool = False,
 ) -> str:
     """Serialize data to JSON text through safe_json_structure."""
-    return json.dumps(safe_json_structure(data, max_depth, value_transform), default=str)
+    return json.dumps(
+        safe_json_structure(data, max_depth, value_transform, non_finite_as_null=non_finite_as_null), default=str
+    )
diff --git a/litellm/litellm_core_utils/streaming_chunk_builder_utils.py b/litellm/litellm_core_utils/streaming_chunk_builder_utils.py
index 6441276de01..3d8bb908eb9 100644
--- a/litellm/litellm_core_utils/streaming_chunk_builder_utils.py
+++ b/litellm/litellm_core_utils/streaming_chunk_builder_utils.py
@@ -16,6 +16,7 @@ from litellm.constants import VLLM_CHOICE_FIELDS
 from litellm.litellm_core_utils.core_helpers import (
     PROVIDERS_BILLED_FROM_THEIR_OWN_USAGE_FIELDS,
     chunk_usage,
+    finite_cost,
     provider_reported_usage_cost,
     stamp_litellm_bill_on_usage,
 )
@@ -1018,7 +1019,9 @@ class ChunkProcessor:
                     prompt_tokens_details, cache_creation_token_details
                 )
 
-                if usage_chunk_dict["cost"] is not None:
+                if Usage.dropped_non_finite_cost(usage_chunk):
+                    cost = None
+                elif usage_chunk_dict["cost"] is not None:
                     cost = usage_chunk_dict["cost"]
 
         prompt_tokens_details = attach_cache_creation_token_details(prompt_tokens_details, cache_creation_token_details)
@@ -1449,8 +1452,8 @@ def _set_stream_builder_response_cost(
 def _stamp_streaming_usage_cost(usage: Usage, response: ModelResponse, logging_obj: Optional["Logging"]) -> None:
     if logging_obj is None:
         return
-    if _logged_provider(logging_obj) in PROVIDERS_BILLED_FROM_THEIR_OWN_USAGE_FIELDS and isinstance(
-        getattr(usage, "cost", None), (int, float)
+    if _logged_provider(logging_obj) in PROVIDERS_BILLED_FROM_THEIR_OWN_USAGE_FIELDS and (
+        finite_cost(getattr(usage, "cost", None)) is not None
     ):
         return
     computed_cost: Final = logging_obj.response_cost_calculator(result=response)
diff --git a/litellm/litellm_core_utils/streaming_handler.py b/litellm/litellm_core_utils/streaming_handler.py
index d9d7efa02d4..0dd8e545caa 100644
--- a/litellm/litellm_core_utils/streaming_handler.py
+++ b/litellm/litellm_core_utils/streaming_handler.py
@@ -29,6 +29,7 @@ from litellm.litellm_core_utils.core_helpers import chunk_usage, provider_report
 from litellm.litellm_core_utils.hidden_params import (
     HIDDEN_PARAMS_ATTR,
     get_hidden_params,
+    set_extra_attribute,
     set_hidden_param,
     stored_attribute,
 )
@@ -1100,7 +1101,7 @@ class CustomStreamWrapper:
             _initial_delta: Final = model_response.choices[0].delta.model_dump()
 
             _initial_delta.pop("role", None)
-            model_response.choices[0].delta = Delta(**_initial_delta)
+            set_extra_attribute(model_response.choices[0], "delta", Delta(**_initial_delta))
         return model_response
 
     def _prebuilt_plain_delta(self, chunk: object) -> Delta | None:
@@ -1126,13 +1127,13 @@ class CustomStreamWrapper:
     def _set_role_on_fresh_delta(self, model_response: ModelResponseStream) -> None:
         delta: Final = model_response.choices[0].delta
         if self.sent_first_chunk is False:
-            delta.role = "assistant"
+            set_extra_attribute(delta, "role", "assistant")
             self.sent_first_chunk = True
             return
         if not _holds_only_scalars(delta):
             self.strip_role_from_delta(model_response)
             return
-        delta.role = None
+        set_extra_attribute(delta, "role", None)
         if "provider_specific_fields" not in delta.model_fields_set:
             delta.provider_specific_fields = None
 
@@ -1256,8 +1257,8 @@ class CustomStreamWrapper:
                             and _holds_only_scalars(upstream_delta)
                         )
                         if can_reuse_choice and upstream_choice is not None:
-                            model_response.choices[0].finish_reason = None  # rebind-ok: keep reused choice
-                            model_response.choices[0].index = upstream_choice.index  # rebind-ok: keep reused choice
+                            set_extra_attribute(model_response.choices[0], "finish_reason", None)
+                            set_extra_attribute(model_response.choices[0], "index", upstream_choice.index)
                             _prepend_upstream_choice_extras(
                                 model_response.choices[0],
                                 upstream_choice,
@@ -1282,11 +1283,7 @@ class CustomStreamWrapper:
                     else:
                         return
                     model_response.system_fingerprint = upstream_chunk.system_fingerprint
-                    setattr(
-                        model_response,
-                        "citations",
-                        stored_attribute(upstream_chunk, "citations"),
-                    )
+                    set_extra_attribute(model_response, "citations", stored_attribute(upstream_chunk, "citations"))
                     preserve_upstream_non_openai_attributes(
                         model_response=model_response,
                         original_chunk=original_chunk,
@@ -2662,6 +2659,25 @@ class CustomStreamWrapper:
     def bill_failure_after_earlier_rounds(self, earlier: "BilledRoundsSpend") -> None:
         self._earlier_rounds_spend = earlier
 
+    def partial_response(self) -> "ModelResponse | TextCompletionResponse | None":
+        partial: Final = (
+            litellm.stream_chunk_builder(
+                chunks=self.chunks,
+                messages=self.messages if isinstance(self.messages, list) else None,
+                logging_obj=self.logging_obj,
+                count_prompt_tokens=self.count_prompt_tokens,
+            )
+            if self.chunks
+            else None
+        )
+        usage: Final[object] = getattr(partial, "usage", None)
+        if partial is None or not isinstance(usage, Usage):
+            return None
+        if self.model:
+            partial.model = self.model
+        backfill_missing_cache_usage_fields(usage)
+        return partial
+
     def _record_partial_usage_for_failure(self) -> None:
         """
         A stream that breaks mid-flight still billed the provider for the chunks
@@ -2671,23 +2687,15 @@ class CustomStreamWrapper:
         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:
+        if self.logging_obj is None:
             return
         try:
-            partial_response: Final = litellm.stream_chunk_builder(
-                chunks=self.chunks,
-                messages=self.messages if isinstance(self.messages, list) else None,
-                logging_obj=self.logging_obj,
-                count_prompt_tokens=self.count_prompt_tokens,
-            )
+            partial_response: Final = self.partial_response()
             if partial_response is None:
                 return
-            usage: Final = cast(Usage | None, getattr(partial_response, "usage", None))
-            if usage is None:
+            usage: Final[object] = getattr(partial_response, "usage", None)
+            if not isinstance(usage, Usage):
                 return
-            if self.model:
-                partial_response.model = self.model
-            backfill_missing_cache_usage_fields(usage)
             partial_cost: Final = self.logging_obj.response_cost_calculator(result=partial_response) or 0.0
             if self._earlier_rounds_spend is None:
                 self.logging_obj.model_call_details["combined_usage_object"] = usage
diff --git a/litellm/llms/anthropic/chat/transformation.py b/litellm/llms/anthropic/chat/transformation.py
index 865247afc63..d773e31c733 100644
--- a/litellm/llms/anthropic/chat/transformation.py
+++ b/litellm/llms/anthropic/chat/transformation.py
@@ -48,6 +48,7 @@ from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import
     place_mid_conversation_system,
     split_leading_system_run,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE, warn_non_string_reasoning_effort
 from litellm.llms.base_llm.base_utils import (
     ResponseFormatSchema,
     as_json_object,
@@ -1951,6 +1952,7 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                 if isinstance(effort_value, dict):
                     effort_value = effort_value.get("effort")
                 if not isinstance(effort_value, str):
+                    warn_non_string_reasoning_effort(OPAQUE_VALUE.validate_python(value), model)
                     continue
                 mapped_thinking = AnthropicConfig._map_reasoning_effort(
                     reasoning_effort=effort_value,
diff --git a/litellm/llms/anthropic/common_utils.py b/litellm/llms/anthropic/common_utils.py
index 82977f97854..e1f9a7d540f 100644
--- a/litellm/llms/anthropic/common_utils.py
+++ b/litellm/llms/anthropic/common_utils.py
@@ -37,7 +37,7 @@ from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import
     message_field,
     parts_of,
 )
-from litellm.litellm_core_utils.reasoning_effort_utils import non_numeric_thinking_budget_error
+from litellm.litellm_core_utils.reasoning_effort_utils import DroppedThinkingBudget, 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,
@@ -58,6 +58,7 @@ from litellm.types.llms.anthropic import (
     ANTHROPIC_THINKING_BINDING_CONTROLS_BETA_HEADER,
     ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER,
     ANTHROPIC_TOOL_SEARCH_TOOL_TYPES,
+    LEGACY_THINKING_DISPLAY_UPDATES_PROVIDERS,
     AllAnthropicToolsValues,
     AnthropicMcpServerTool,
     AnthropicMessagesToolChoice,
@@ -126,6 +127,8 @@ _JSON_VALUE: Final = TypeAdapter(JsonValue)
 
 _CLAUDE_CODE_USER_AGENT_PREFIXES: Final = ("claude-cli/", "claude-code/")
 
+NATIVE_COMPACTION_PROVIDERS: Final = frozenset({"anthropic", "azure_ai", "vertex_ai"})
+
 
 def is_claude_tool_target(custom_llm_provider: str | None, model: str) -> bool:
     if custom_llm_provider == "anthropic":
@@ -204,7 +207,7 @@ def requires_native_compaction_beta(
     optional_params: Mapping[str, object],
     messages: Sequence[object],
 ) -> bool:
-    return custom_llm_provider == "anthropic" and (
+    return custom_llm_provider in NATIVE_COMPACTION_PROVIDERS and (
         optional_params.get("compaction") is not None or carries_signed_compaction_block(messages)
     )
 
@@ -246,6 +249,27 @@ def context_management_betas(context_management: JsonValue) -> tuple[str, ...]:
     )
 
 
+def count_tokens_feature_betas(
+    custom_llm_provider: str,
+    optional_params: Mapping[str, object],
+    messages: Sequence[object],
+) -> tuple[str, ...]:
+    return tuple(
+        beta
+        for beta, used in (
+            (
+                ANTHROPIC_BETA_HEADER_VALUES.COMPACT_2026_09_04.value,
+                requires_native_compaction_beta(custom_llm_provider, optional_params, messages),
+            ),
+            (
+                ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER,
+                AnthropicModelInfo().is_mid_conversation_tool_change_used(messages),
+            ),
+        )
+        if used
+    )
+
+
 def supports_anthropic_cache_control(model: str, custom_llm_provider: str | None) -> bool:
     from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
     from litellm.utils import supports_prompt_caching
@@ -610,11 +634,11 @@ def _numeric_budget_tokens(budget_tokens: object) -> int | None:
         return None
 
 
-def _legacy_budget_tokens(budget_tokens: object, *, drop_params: bool) -> int | None:
+def _legacy_budget_tokens(budget_tokens: object, *, drop_params: bool) -> int | DroppedThinkingBudget:
     if (numeric := _numeric_budget_tokens(budget_tokens)) is not None:
         return numeric
     if drop_params or litellm.drop_params is True:
-        return None
+        return DroppedThinkingBudget(budget_tokens)
     raise non_numeric_thinking_budget_error(budget_tokens)
 
 
@@ -645,10 +669,12 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         file_ids: Final = get_file_ids_from_messages(messages)
         return len(file_ids) > 0
 
-    def is_thinking_display_updates_used(self, thinking: AnthropicThinkingParam | None) -> bool:
-        if not isinstance(thinking, dict):
-            return False
-        return thinking.get("type") in ("adaptive", "enabled") and thinking.get("display") == "updates"
+    def is_thinking_display_updates_used(self, thinking: object) -> bool:
+        match thinking:
+            case {"type": "adaptive" | "enabled", "display": "updates"}:
+                return True
+            case _:
+                return False
 
     def thinking_betas(self, thinking: AnthropicThinkingParam | None) -> tuple[str, ...]:
         return (
@@ -1097,6 +1123,22 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         custom_llm_provider: str,
         drop_params: bool,
     ) -> None:
+        dropped: Final = AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model_silently(
+            model=model,
+            optional_params=optional_params,
+            custom_llm_provider=custom_llm_provider,
+            drop_params=drop_params,
+        )
+        if dropped is not None:
+            dropped.warn(model)
+
+    @staticmethod
+    def translate_legacy_thinking_for_adaptive_model_silently(
+        model: str,
+        optional_params: MutableMapping[str, object],  # mutable-ok: in-place out-param like the sibling helpers
+        custom_llm_provider: str,
+        drop_params: bool,
+    ) -> DroppedThinkingBudget | None:
         """Translate legacy ``thinking.type=enabled`` to adaptive for the
         adaptive-thinking models that reject it (4.7+ and the 5 families).
         Models flagged ``supports_legacy_thinking`` (the 4.6 family) accept the
@@ -1105,22 +1147,25 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         ``output_config.effort`` is never overridden.
         """
         if not AnthropicModelInfo._is_adaptive_thinking_model(model, custom_llm_provider):
-            return
+            return None
         if AnthropicModelInfo._supports_legacy_thinking(model, custom_llm_provider):
-            return
+            return None
         thinking: Final = validated_object_mapping(optional_params.get("thinking"))
         if thinking is None or thinking.get("type") != "enabled":
-            return
+            return None
 
         budget_tokens: Final = _legacy_budget_tokens(thinking.get("budget_tokens", 0), drop_params=drop_params)
         display: Final = thinking.get("display")
-        supported_display: Final = {"display": display} if display in ("summarized", "omitted") else {}
+        keeps_display: Final = display in ("summarized", "omitted") or (
+            display == "updates" and custom_llm_provider in LEGACY_THINKING_DISPLAY_UPDATES_PROVIDERS
+        )
+        supported_display: Final = {"display": display} if keeps_display else {}
         carried_keys: Final = carried_thinking_keys(
             thinking, rebuilt_keys=frozenset(("type", "budget_tokens", "display")), drop_params=drop_params
         )
         optional_params["thinking"] = {**carried_keys, "type": "adaptive", **supported_display}
-        if budget_tokens is None:
-            return
+        if isinstance(budget_tokens, DroppedThinkingBudget):
+            return budget_tokens
         effort: Final = AnthropicModelInfo._legacy_budget_to_effort(
             model=model, budget_tokens=budget_tokens, custom_llm_provider=custom_llm_provider
         )
@@ -1129,6 +1174,7 @@ class AnthropicModelInfo(BaseLLMModelInfo):
             "effort": effort,
             **(existing_output_config if isinstance(existing_output_config, dict) else MappingProxyType({})),
         }
+        return None
 
     @staticmethod
     def _legacy_budget_to_effort(model: str, budget_tokens: int, custom_llm_provider: str) -> str:
diff --git a/litellm/llms/anthropic/messages/adapters/transformation.py b/litellm/llms/anthropic/messages/adapters/transformation.py
index 8ea6293bbe6..bc9649ed867 100644
--- a/litellm/llms/anthropic/messages/adapters/transformation.py
+++ b/litellm/llms/anthropic/messages/adapters/transformation.py
@@ -134,6 +134,7 @@ from litellm.litellm_core_utils.prompt_templates.factory import (
 )
 from litellm.litellm_core_utils.reasoning_effort_utils import (
     reasoning_effort_from_thinking,
+    reasoning_effort_from_thinking_silently,
 )
 from litellm.llms.anthropic.common_utils import (
     eager_input_streaming_flag,
@@ -297,6 +298,7 @@ class AnthropicAdapter:
             custom_llm_provider=custom_llm_provider,
             api_base=api_base,
             drop_params=drop_params,
+            report_reasoning_drops=True,
         )
 
         return translated_body, tool_name_mapping
@@ -666,7 +668,9 @@ class LiteLLMAnthropicMessagesAdapter:
     def translate_anthropic_thinking_to_reasoning_effort(
         thinking: AnthropicThinkingParam,
         *,
+        model: str,
         drop_params: bool = True,
+        report_reasoning_drops: bool = False,
     ) -> str | None:
         """
         Translate Anthropic's thinking parameter to OpenAI's reasoning_effort.
@@ -685,7 +689,9 @@ class LiteLLMAnthropicMessagesAdapter:
         if thinking_type == "disabled":
             return "none"
         elif thinking_type == "enabled":
-            return reasoning_effort_from_thinking(thinking, drop_params=drop_params)
+            if report_reasoning_drops:
+                return reasoning_effort_from_thinking(thinking, model=model, drop_params=drop_params)
+            return reasoning_effort_from_thinking_silently(thinking, drop_params=drop_params)
         elif thinking_type == "adaptive":
             # Adaptive thinking: effort is controlled by output_config.effort,
             # not budget_tokens. Return a default; caller should override with
@@ -752,7 +758,7 @@ class LiteLLMAnthropicMessagesAdapter:
             return {"thinking": thinking}
         else:
             reasoning_effort: Final = LiteLLMAnthropicMessagesAdapter.translate_anthropic_thinking_to_reasoning_effort(
-                thinking
+                thinking, model=model
             )
             if reasoning_effort:
                 return {
@@ -1147,6 +1153,7 @@ class LiteLLMAnthropicMessagesAdapter:
         *,
         custom_llm_provider: str | None = None,
         drop_params: bool = True,
+        report_reasoning_drops: bool = False,
     ) -> None:
         """Translate Anthropic thinking to either thinking or reasoning_effort.
 
@@ -1207,7 +1214,10 @@ class LiteLLMAnthropicMessagesAdapter:
             return
 
         reasoning_effort: Final = declared_effort or self.translate_anthropic_thinking_to_reasoning_effort(
-            cast(AnthropicThinkingParam, thinking), drop_params=drop_params
+            cast(AnthropicThinkingParam, thinking),
+            model=model,
+            drop_params=drop_params,
+            report_reasoning_drops=report_reasoning_drops,
         )
         if not reasoning_effort:
             return
@@ -1267,6 +1277,7 @@ class LiteLLMAnthropicMessagesAdapter:
         api_base: str | None = None,
         preserve_midturn_system: bool = False,
         drop_params: bool = True,
+        report_reasoning_drops: bool = False,
     ) -> tuple[ChatCompletionRequest, dict[str, str]]:
         """
         This is used by the beta Anthropic Adapter, for translating anthropic `/v1/messages` requests to the openai format.
@@ -1321,6 +1332,7 @@ class LiteLLMAnthropicMessagesAdapter:
             new_kwargs=new_kwargs,
             custom_llm_provider=custom_llm_provider,
             drop_params=drop_params,
+            report_reasoning_drops=report_reasoning_drops,
         )
         ## CONVERT STOP_SEQUENCES
         self._translate_stop_sequences_to_openai(
diff --git a/litellm/llms/anthropic/messages/native/handler.py b/litellm/llms/anthropic/messages/native/handler.py
index 6f97a019a96..1da7c2efdda 100644
--- a/litellm/llms/anthropic/messages/native/handler.py
+++ b/litellm/llms/anthropic/messages/native/handler.py
@@ -20,6 +20,7 @@ from litellm.litellm_core_utils.core_helpers import as_str_mapping
 from litellm.litellm_core_utils.exception_mapping_utils import exception_type
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.llms.anthropic.common_utils import (
+    AnthropicModelInfo,
     strip_provider_specific_fields_from_anthropic_messages,
     tools_marked_for_a_tool_config_point,
 )
@@ -36,7 +37,6 @@ from litellm.router_utils.reasoning_effort_capability import (
     keeps_effort,
     model_group_from_metadata,
     resolve_deployment_reasoning_effort,
-    with_adaptive_thinking_as_effort,
 )
 from litellm.types.llms.anthropic import AllAnthropicToolsValues
 from litellm.types.llms.anthropic_messages.anthropic_request import AnthropicMetadata
@@ -185,9 +185,11 @@ def _with_deployment_output_effort(
         ).value
 
     def translate(source: Mapping[str, object]) -> Mapping[str, object]:
-        return with_adaptive_thinking_as_effort(
-            source, model=model, custom_llm_provider=custom_llm_provider, drop_params=drop_params
+        translated: Final = dict(source)
+        AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model(
+            model=model, optional_params=translated, custom_llm_provider=custom_llm_provider, drop_params=drop_params
         )
+        return translated
 
     requested_output: Final = as_str_mapping(params.get("output_config"))
     caller_output: Final = None if requested_output is None else resolve(requested_output)
diff --git a/litellm/llms/anthropic/messages/native/transformation.py b/litellm/llms/anthropic/messages/native/transformation.py
index ef855eff180..5281ad99620 100644
--- a/litellm/llms/anthropic/messages/native/transformation.py
+++ b/litellm/llms/anthropic/messages/native/transformation.py
@@ -21,6 +21,7 @@ from litellm.constants import ANTHROPIC_BILLING_METADATA_PREFIX
 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.reasoning_effort_utils import OPAQUE_VALUE, warn_non_string_reasoning_effort
 from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.anthropic.messages.convertible_blocks import drop_non_string_tool_result_texts
 from litellm.llms.anthropic.messages.safeguards import proxy_serves_safeguards
@@ -40,6 +41,7 @@ from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
 from litellm.types.router import GenericLiteLLMParams
 
 from ...common_utils import (
+    NATIVE_COMPACTION_PROVIDERS,
     OBJECT_LIST_ADAPTER,
     AnthropicError,
     AnthropicModelInfo,
@@ -103,6 +105,7 @@ _MESSAGES_ADAPTER: Final = TypeAdapter(list[dict[str, object]])
 
 class AnthropicMessagesConfig(BaseAnthropicMessagesConfig):
     _workload_identity_eligible: ClassVar[bool] = True
+    _report_reasoning_drops: ClassVar[bool] = True
 
     @property
     def custom_llm_provider(self) -> str | None:
@@ -126,7 +129,7 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig):
             "tool_choice",
             "thinking",
             "context_management",
-            *(("compaction",) if self._resolved_provider == "anthropic" else ()),
+            *(("compaction",) if self._resolved_provider in NATIVE_COMPACTION_PROVIDERS else ()),
             "output_format",
             "inference_geo",
             "speed",
@@ -695,12 +698,17 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig):
         ):
             anthropic_messages_optional_request_params.pop("output_format")  # pyright: ignore[reportUnknownMemberType]  # the request params arrive as a bare dict
 
+        requested_reasoning_effort: Final = OPAQUE_VALUE.validate_python(
+            anthropic_messages_optional_request_params.get("reasoning_effort")  # pyright: ignore[reportUnknownMemberType]  # the request params arrive as a bare dict
+        )
         self._translate_reasoning_effort_to_anthropic(
             model=model,
             optional_params=anthropic_messages_optional_request_params,
             max_tokens=max_tokens,
             custom_llm_provider=self._resolved_provider,
         )
+        if self._report_reasoning_drops:
+            warn_non_string_reasoning_effort(requested_reasoning_effort, model)
 
         AnthropicModelInfo.maybe_drop_disabled_thinking(
             model=model,
@@ -708,12 +716,14 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig):
             custom_llm_provider=self._resolved_provider,
         )
 
-        AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model(
+        dropped_budget: Final = AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model_silently(
             model=model,
             optional_params=anthropic_messages_optional_request_params,
             custom_llm_provider=self._resolved_provider,
             drop_params=getattr(litellm_params, "drop_params", None) is True,
         )
+        if dropped_budget is not None and self._report_reasoning_drops:
+            dropped_budget.warn(model)
 
         self._translate_adaptive_effort_for_non_adaptive_model(
             model=model,
diff --git a/litellm/llms/anthropic/messages/responses_adapters/transformation.py b/litellm/llms/anthropic/messages/responses_adapters/transformation.py
index 94c608f90e6..0630bef0311 100644
--- a/litellm/llms/anthropic/messages/responses_adapters/transformation.py
+++ b/litellm/llms/anthropic/messages/responses_adapters/transformation.py
@@ -534,6 +534,7 @@ class LiteLLMAnthropicToResponsesAPIAdapter:
         output_config: dict[str, object] | None = None,
         auto_summary_level: str = "detailed",
         *,
+        model: str,
         drop_params: bool = True,
     ) -> dict[str, object] | None:
         """
@@ -555,7 +556,7 @@ class LiteLLMAnthropicToResponsesAPIAdapter:
             if isinstance(output_config, dict) and output_config.get("effort"):
                 effort = output_config["effort"]
         elif thinking_type == "enabled":
-            budget_effort: Final = reasoning_effort_from_thinking(thinking, drop_params=drop_params)
+            budget_effort: Final = reasoning_effort_from_thinking(thinking, model=model, drop_params=drop_params)
             if budget_effort is None:
                 return None
             effort = budget_effort
@@ -667,6 +668,7 @@ class LiteLLMAnthropicToResponsesAPIAdapter:
                 thinking,
                 output_config=cast(dict[str, object] | None, output_config),
                 auto_summary_level=auto_summary_level,
+                model=model,
                 drop_params=drop_params,
             )
             if reasoning:
diff --git a/litellm/llms/anthropic/prompt_cache_prediction.py b/litellm/llms/anthropic/prompt_cache_prediction.py
index 27e003ce8b6..2da071ebdd2 100644
--- a/litellm/llms/anthropic/prompt_cache_prediction.py
+++ b/litellm/llms/anthropic/prompt_cache_prediction.py
@@ -9,7 +9,7 @@ from dataclasses import dataclass, field
 from functools import reduce
 from itertools import accumulate, groupby
 from types import MappingProxyType
-from typing import Annotated, Final, Literal, Protocol, TypeAlias
+from typing import Annotated, ClassVar, Final, Literal, Protocol, TypeAlias
 
 import httpx
 from pydantic import ConfigDict, Field, JsonValue, StrictInt, TypeAdapter, ValidationError
@@ -81,6 +81,10 @@ _DEPLOYMENT_OPTIONS: Final = frozenset(
 )
 
 
+class _BaselineAnthropicMessagesConfig(AnthropicMessagesConfig):
+    _report_reasoning_drops: ClassVar[bool] = False
+
+
 class _StrictModel(LiteLLMBaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True, strict=True)
 
@@ -661,7 +665,7 @@ def prepare_native_baseline_body(request: Mapping[str, object], model: str) -> M
             TypeAdapter(tuple[str, ...]).validate_python(owned.get("additional_drop_params") or ()),
             dict(options),
         )
-        config: Final = AnthropicMessagesConfig()
+        config: Final = _BaselineAnthropicMessagesConfig()
         body: Final = config.transform_anthropic_messages_request(
             model=resolved_model,
             messages=strip_provider_specific_fields_from_anthropic_messages(messages),
diff --git a/litellm/llms/azure_ai/anthropic/count_tokens/handler.py b/litellm/llms/azure_ai/anthropic/count_tokens/handler.py
index 4b3f263201a..c324f0f0980 100644
--- a/litellm/llms/azure_ai/anthropic/count_tokens/handler.py
+++ b/litellm/llms/azure_ai/anthropic/count_tokens/handler.py
@@ -84,6 +84,7 @@ class AzureAIAnthropicCountTokensHandler(AzureAIAnthropicCountTokensConfig):
             headers: Final = self.get_required_headers(
                 api_key=api_key,
                 litellm_params=litellm_params,
+                messages=messages,
             )
             if not {"x-api-key", "Authorization"} & headers.keys():
                 raise AnthropicError(
diff --git a/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py b/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py
index 6e3cfce5eb4..c02c92a95d6 100644
--- a/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py
+++ b/litellm/llms/azure_ai/anthropic/count_tokens/transformation.py
@@ -4,11 +4,13 @@ Azure AI Anthropic CountTokens API transformation logic.
 Extends the base Anthropic CountTokens transformation with Azure authentication.
 """
 
+from collections.abc import Sequence
 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.common_utils import count_tokens_feature_betas, merge_anthropic_beta_headers
 from litellm.llms.anthropic.count_tokens.transformation import (
     AnthropicCountTokensConfig,
 )
@@ -28,6 +30,7 @@ class AzureAIAnthropicCountTokensConfig(AnthropicCountTokensConfig):
         self,
         api_key: str | None,
         litellm_params: dict[str, object] | None = None,
+        messages: Sequence[object] = (),
     ) -> dict[str, str]:
         """
         Get the required headers for the Azure AI Anthropic CountTokens API.
@@ -38,6 +41,7 @@ class AzureAIAnthropicCountTokensConfig(AnthropicCountTokensConfig):
         Args:
             api_key: The Azure AI API key
             litellm_params: Optional LiteLLM parameters for additional auth config
+            messages: The request messages, read for betas the counted features need
 
         Returns:
             Dictionary of required headers with both x-api-key and Azure authentication
@@ -46,7 +50,9 @@ class AzureAIAnthropicCountTokensConfig(AnthropicCountTokensConfig):
         headers: Final = {
             "Content-Type": "application/json",
             "anthropic-version": "2023-06-01",
-            "anthropic-beta": ANTHROPIC_TOKEN_COUNTING_BETA_VERSION,
+            "anthropic-beta": merge_anthropic_beta_headers(
+                ANTHROPIC_TOKEN_COUNTING_BETA_VERSION, count_tokens_feature_betas("azure_ai", {}, messages)
+            ),
             **({"x-api-key": api_key} if api_key else {}),
         }
 
diff --git a/litellm/llms/azure_ai/chat/transformation.py b/litellm/llms/azure_ai/chat/transformation.py
index 5381447f28f..5214d31fb2e 100644
--- a/litellm/llms/azure_ai/chat/transformation.py
+++ b/litellm/llms/azure_ai/chat/transformation.py
@@ -20,6 +20,7 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import (
     prompt_cache_breakpoint_for_wire,
     with_prompt_cache_breakpoint,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning_params
 from litellm.llms.azure.common_utils import BaseAzureLLM
 from litellm.llms.azure_ai.common_utils import (
     api_key_header_for_base,
@@ -40,6 +41,14 @@ if TYPE_CHECKING:
     from litellm.litellm_core_utils.tokenizer import Encoding as Tokenizer
 
 
+_REQUEST_BODY: Final = TypeAdapter(dict[str, object])
+
+
+def _request_model(request: Mapping[str, object]) -> str | None:
+    model: Final = request.get("model")
+    return model if isinstance(model, str) else None
+
+
 class AzureFoundryErrorStrings(str, enum.Enum):
     SET_EXTRA_PARAMETERS_TO_PASS_THROUGH = "Set extra-parameters to 'pass-through'"
 
@@ -510,7 +519,13 @@ class AzureAIStudioConfig(OpenAIConfig):
             request_data = self._drop_extra_params_from_request_data(request_data, error_text)
         if "Extra inputs are not permitted" in error_text and self._error_has_tool_level_extra_fields(error_text):
             request_data = self._drop_tool_level_extra_fields(request_data, error_text)
-        data: Final = drop_params_from_unprocessable_entity_error(e=e, data=request_data)
+        data: Final = drop_params_from_unprocessable_entity_error(
+            e=e,
+            data=request_data,
+            model=_request_model(_REQUEST_BODY.validate_python(request_data)),
+            drop_params_gated="Extra inputs are not permitted" in error_text
+            and not self._error_has_tool_level_extra_fields(error_text),
+        )
         return data
 
     def _drop_tool_level_extra_fields(self, request_data: dict, error_text: str) -> dict:
@@ -526,6 +541,14 @@ class AzureAIStudioConfig(OpenAIConfig):
     def _drop_extra_params_from_request_data(self, request_data: dict, error_text: str) -> dict:
         params_to_drop: Final = self._extract_params_to_drop_from_error_text(error_text)
         if params_to_drop:
+            request: Final = _REQUEST_BODY.validate_python(request_data)
+            warn_dropped_reasoning_params(
+                params_to_drop,
+                request,
+                _request_model(request),
+                "Azure AI rejected it as an extra parameter its deployment does not pass through.",
+                drop_params_gated=False,
+            )
             for param in params_to_drop:
                 if param in request_data:
                     request_data.pop(param, None)
diff --git a/litellm/llms/bedrock/chat/chat_completions/transformation.py b/litellm/llms/bedrock/chat/chat_completions/transformation.py
index 123e4a9e6b4..dd2277a6c35 100644
--- a/litellm/llms/bedrock/chat/chat_completions/transformation.py
+++ b/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.reasoning_effort_utils import warn_dropped_reasoning
 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
@@ -42,6 +43,7 @@ from litellm.llms.bedrock.common_utils import (
     bedrock_rejects_stop_sequences,
     bedrock_runtime_chat_completions_serves_reasoning_inline,
     split_bedrock_region_path,
+    strip_bedrock_routing_prefix,
 )
 from litellm.llms.openai.chat.gpt_transformation import OpenAIChatCompletionStreamingHandler
 from litellm.llms.openai_like.chat.transformation import OpenAILikeChatConfig
@@ -121,6 +123,13 @@ def without_refused_reasoning_effort(model: str, params: Mapping[str, object]) -
     effort: Final = params.get("reasoning_effort")
     if not isinstance(effort, str) or effort not in chat_completions_reasoning_efforts_refused_for(model):
         return params
+    warn_dropped_reasoning(
+        "reasoning_effort",
+        effort,
+        strip_bedrock_routing_prefix(model),
+        "AWS's Chat Completions endpoint rejects that level for this model family, so AWS applies its default effort.",
+        drop_params_gated=False,
+    )
     return _without_params(params, frozenset(("reasoning_effort",)))
 
 
@@ -445,6 +454,14 @@ class AmazonBedrockRuntimeChatCompletionsConfig(OpenAILikeChatConfig):
                 ),
                 status_code=400,
             )
+        if malformed_effort:
+            warn_dropped_reasoning(
+                "reasoning_effort",
+                raw_params["reasoning_effort"],
+                strip_bedrock_routing_prefix(model),
+                "Bedrock's Chat Completions endpoint takes it only as a string, so AWS applies its default effort.",
+                drop_params_gated=True,
+            )
         rejected_stop: Final = frozenset(("stop",)) if bedrock_rejects_stop_sequences(model) else frozenset[str]()
         return dict(
             without_refused_reasoning_effort(
diff --git a/litellm/llms/bedrock/chat/converse_transformation.py b/litellm/llms/bedrock/chat/converse_transformation.py
index 443e722168d..3800489ec05 100644
--- a/litellm/llms/bedrock/chat/converse_transformation.py
+++ b/litellm/llms/bedrock/chat/converse_transformation.py
@@ -50,6 +50,7 @@ from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import
     message_field,
     parts_of,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE, warn_dropped_reasoning
 from litellm.llms.anthropic.chat.transformation import (
     DROP_UNSUPPORTED_ADAPTIVE_THINKING_WARNING,
     DROP_UNSUPPORTED_OUTPUT_CONFIG_WARNING,
@@ -63,6 +64,7 @@ from litellm.llms.bedrock.chat.tool_result_images import place_tool_result_image
 from litellm.llms.bedrock.common_utils import (
     bedrock_chat_uses_native_structured_output,
     bedrock_cleaned_output_schema,
+    bedrock_model_is_unknown,
     bedrock_model_supports_regex_lookaround,
     bedrock_native_output_format,
     bedrock_native_output_is_opt_in,
@@ -186,6 +188,8 @@ def _tools_the_model_accepts(
 
 
 _OUTPUT_CONFIG_BLOCK: Final = TypeAdapter(OutputConfigBlock)
+_DEEPSEEK_THINKING_REASON: Final = "DeepSeek on Bedrock reasons natively and takes no thinking field."
+_DEEPSEEK_R1_EFFORT_REASON: Final = "DeepSeek R1 on Bedrock always reasons and rejects reasoning_effort."
 
 
 def _has_native_text_format(output_config: object) -> bool:
@@ -529,13 +533,14 @@ class AmazonConverseConfig(BaseConfig):
         """
         Handle the reasoning_effort parameter based on the model type.
 
-        - GPT-OSS and DeepSeek V3 models: passed through unchanged via additionalModelRequestFields.
+        - GPT-OSS, DeepSeek V3 and unknown models (``bedrock_model_is_unknown``): passed through unchanged
+          via additionalModelRequestFields.
         - OpenAI GPT-5.x and GPT-6 models: mapped to ``reasoning.effort`` via additionalModelRequestFields.
         - Nova 2 models: transformed to reasoningConfig.
         - Anthropic models: mapped to ``thinking`` (and ``output_config.effort`` on
           adaptive Claude 4.6 / 4.7).
         """
-        if "gpt-oss" in model or "deepseek" in model:
+        if "gpt-oss" in model or "deepseek" in model or bedrock_model_is_unknown(model):
             optional_params["reasoning_effort"] = reasoning_effort
         elif self._is_openai_gpt_reasoning_model(model):
             reasoning: Final[BedrockConverseGptReasoningEffortBlock] = {"effort": reasoning_effort}
@@ -638,6 +643,10 @@ class AmazonConverseConfig(BaseConfig):
             or supports_reasoning(model=base_model, custom_llm_provider=self.custom_llm_provider)
         )
 
+    def _warn_native_reasoning_drop(self, param: str, value: object, model: str, reason: str) -> None:
+        if param in self.get_supported_openai_params(model):
+            warn_dropped_reasoning(param, value, model, reason, drop_params_gated=False)
+
     def _model_rejects_reasoning_effort_param(self, model: str, base_model: str) -> bool:
         """Whether the model returns a 400 for every ``reasoning_effort`` shape on Converse.
 
@@ -681,7 +690,7 @@ class AmazonConverseConfig(BaseConfig):
             "parallel_tool_calls",
         ]
 
-        if "arn" in model:  # we can't infer the model from the arn, so just add all params
+        if "arn" in model or bedrock_model_is_unknown(model):
             supported_params.append("tools")
             supported_params.append("tool_choice")
             supported_params.append("thinking")
@@ -1141,9 +1150,8 @@ class AmazonConverseConfig(BaseConfig):
                     "tool_choice": {"type": "auto", "disable_parallel_tool_use": not value}
                 }
             if param == "thinking" and drop_thinking_param:
-                verbose_logger.debug(
-                    "Dropping unsupported `thinking` param for Bedrock model=%s; it reasons natively.",
-                    model,
+                self._warn_native_reasoning_drop(
+                    param, OPAQUE_VALUE.validate_python(value), model, _DEEPSEEK_THINKING_REASON
                 )
             elif param == "thinking" and not self._is_openai_gpt_reasoning_model(model):
                 if (
@@ -1177,10 +1185,7 @@ class AmazonConverseConfig(BaseConfig):
                         drop_params=drop_params,
                     )
             elif param == "reasoning_effort" and isinstance(value, str) and drop_reasoning_effort_param:
-                verbose_logger.debug(
-                    "Dropping unsupported `reasoning_effort` param for Bedrock model=%s; it always reasons and rejects it.",
-                    model,
-                )
+                self._warn_native_reasoning_drop(param, value, model, _DEEPSEEK_R1_EFFORT_REASON)
             elif (
                 param == "reasoning_effort"
                 and isinstance(value, str)
diff --git a/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py b/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
index 852179e8caa..877fb4ca692 100644
--- a/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
+++ b/litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
@@ -2,7 +2,7 @@ import copy
 import json
 import time
 from collections.abc import Mapping, Sequence
-from typing import TYPE_CHECKING, Any, Final, cast, get_args
+from typing import TYPE_CHECKING, Any, Final
 
 import httpx
 from pydantic import ConfigDict, TypeAdapter, ValidationError, with_config
@@ -74,10 +74,6 @@ _GUARDRAIL_CONFIG_EXPECTED_FORMAT: Final = (
     "{'guardrailIdentifier': str, 'guardrailVersion': str, 'trace': 'enabled'|'disabled'|'enabled_full'}"
 )
 
-_INVOKE_PROVIDERS: Final = TypeAdapter(tuple[litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL, ...]).validate_python(
-    get_args(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL)
-)
-
 
 def _response_header(headers: Mapping[str, str], name: str) -> str | None:
     return headers.get(name, None)
@@ -562,62 +558,6 @@ class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
         """
         return False
 
-    @staticmethod
-    def get_bedrock_invoke_provider(
-        model: str,
-    ) -> litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL | None:
-        """
-        Helper function to get the bedrock provider from the model
-
-        handles 4 scenarios:
-        1. model=invoke/anthropic.claude-3-5-sonnet-20240620-v1:0 -> Returns `anthropic`
-        2. model=anthropic.claude-3-5-sonnet-20240620-v1:0 -> Returns `anthropic`
-        3. model=llama/arn:aws:bedrock:us-east-1:086734376398:imported-model/r4c4kewx2s0n -> Returns `llama`
-        4. model=us.amazon.nova-pro-v1:0 -> Returns `nova`
-        """
-        if model.startswith("invoke/"):
-            model = model.replace("invoke/", "", 1)
-
-        # Special case: Check for "nova" in model name first (before "amazon")
-        # This handles amazon.nova-* models which would otherwise match "amazon" (Titan)
-        if "nova" in model.lower():
-            if "nova" in get_args(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL):
-                return cast(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL, "nova")
-
-        _split_model: Final = model.split(".")[0]
-        if _split_model in get_args(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL):
-            return cast(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL, _split_model)
-
-        # If not a known provider, check for pattern with two slashes
-        provider = AmazonInvokeConfig._get_provider_from_model_path(model)
-        if provider is not None:
-            return provider
-
-        for provider in _INVOKE_PROVIDERS:
-            if provider in model:
-                return provider
-        return None
-
-    @staticmethod
-    def _get_provider_from_model_path(
-        model_path: str,
-    ) -> litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL | None:
-        """
-        Helper function to get the provider from a model path with format: provider/model-name
-
-        Args:
-            model_path (str): The model path (e.g., 'llama/arn:aws:bedrock:us-east-1:086734376398:imported-model/r4c4kewx2s0n' or 'anthropic/model-name')
-
-        Returns:
-            Optional[str]: The provider name, or None if no valid provider found
-        """
-        parts: Final = model_path.split("/")
-        if len(parts) >= 1:
-            provider: Final = parts[0]
-            if provider in get_args(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL):
-                return cast(litellm.BEDROCK_INVOKE_PROVIDERS_LITERAL, provider)
-        return None
-
     def convert_messages_to_prompt(self, model: str, messages, provider, custom_prompt_dict) -> tuple[str, list | None]:
         # handle anthropic prompts and amazon titan prompts
         prompt = ""
diff --git a/litellm/llms/bedrock/common_utils.py b/litellm/llms/bedrock/common_utils.py
index d88d7e6280c..d6f5d5b6bd7 100644
--- a/litellm/llms/bedrock/common_utils.py
+++ b/litellm/llms/bedrock/common_utils.py
@@ -1098,6 +1098,11 @@ def _model_cost_entry(key: str) -> Mapping[str, object] | None:
     return None if raw is None else _MODEL_COST_ENTRY_ADAPTER.validate_python(raw)
 
 
+def _cost_map_row_names_a_provider(key: str) -> bool:
+    entry: Final = _model_cost_entry(key)
+    return entry is not None and entry.get("litellm_provider") is not None
+
+
 def _bedrock_price_map_entries(model: str) -> tuple[Mapping[str, object] | None, ...]:
     return tuple(
         _model_cost_entry(key)
@@ -1567,7 +1572,8 @@ def bedrock_model_supports_regex_lookaround(model: str, litellm_params: Mapping[
 
     The deployment's ``model_info.supports_regex_lookaround`` wins, then the
     ``model_prices_and_context_window.json`` entry of its ``base_model``, then the
-    entry of ``model`` itself. A model nobody flagged keeps its schema as sent.
+    entry of ``model`` itself. A model nobody flagged keeps its schema as sent, unless
+    no candidate names a model LiteLLM knows, whatever route prefix it carries.
     """
     params: Final = litellm_params or {}
     deployment_flag: Final = deployment_model_info(params).get("supports_regex_lookaround")
@@ -1576,7 +1582,41 @@ def bedrock_model_supports_regex_lookaround(model: str, litellm_params: Mapping[
     base_model: Final = params.get("base_model")
     candidates: Final = (*((base_model,) if isinstance(base_model, str) else ()), model)
     flags: Final = (_bedrock_converse_model_flag(candidate, "supports_regex_lookaround") for candidate in candidates)
-    return next((flag for flag in flags if flag is not None), True)
+    flag: Final = next((flag for flag in flags if flag is not None), None)
+    if flag is not None:
+        return flag
+    return not all(bedrock_model_is_unknown(split_bedrock_region_path(candidate)[1]) for candidate in candidates)
+
+
+def _bedrock_model_id_without_region(model: str) -> str:
+    routed_id: Final = model.removeprefix("bedrock/")
+    region, separator, regional_id = routed_id.partition("/")
+    return regional_id if separator and region in get_all_bedrock_regions() else routed_id
+
+
+def bedrock_model_is_unknown(model: str) -> bool:
+    model_id: Final = _bedrock_model_id_without_region(model)
+    if "/" in model_id:
+        return False
+    base: Final = get_bedrock_base_model(model_id)
+    regional_ids: Final = (f"{region}.{base}" for region in get_bedrock_cross_region_inference_regions())
+    if any(_cost_map_row_names_a_provider(key) for key in (*_bedrock_model_info_candidates(model_id), *regional_ids)):
+        return False
+    from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
+
+    return BaseAWSLLM.get_bedrock_invoke_provider(model_id) is None
+
+
+def _names_no_invoke_provider(model: str) -> bool:
+    from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
+
+    model_id: Final = _bedrock_model_id_without_region(model)
+    names_one_model: Final = bool(model_id) and ("/" not in model_id or model_id.startswith("arn:"))
+    return names_one_model and BaseAWSLLM.get_bedrock_invoke_provider(model) is None
+
+
+def bedrock_model_reaches_converse_by_default(model: str) -> bool:
+    return BedrockModelInfo.named_bedrock_route(model, None) is None and _names_no_invoke_provider(model)
 
 
 _BedrockConverseModelFlag: TypeAlias = Literal[
@@ -1585,10 +1625,13 @@ _BedrockConverseModelFlag: TypeAlias = Literal[
 ]
 
 
-def _bedrock_converse_model_flag(model: str, key: _BedrockConverseModelFlag) -> bool | None:
+def _bedrock_model_info_candidates(model: str) -> tuple[str, ...]:
     base: Final = get_bedrock_base_model(model)
-    candidates: Final = dict.fromkeys((model, base, _BEDROCK_MODEL_VERSION_SUFFIX_RE.sub("", base)))
-    for candidate in candidates:
+    return tuple(dict.fromkeys((model, base, _BEDROCK_MODEL_VERSION_SUFFIX_RE.sub("", base))))
+
+
+def _bedrock_converse_model_flag(model: str, key: _BedrockConverseModelFlag) -> bool | None:
+    for candidate in _bedrock_model_info_candidates(model):
         with contextlib.suppress(Exception):
             model_info = get_cached_model_info()(
                 model=candidate,
@@ -1766,8 +1809,19 @@ class BedrockModelInfo(BaseLLMModelInfo):
         default (``bedrock_runtime_chat_completions_is_default``) and ``chat_completions/`` opts any other model in;
         ``request_params`` (the caller's chat params) sends such a request to Converse when it needs a
         feature only Converse serves, and ``converse/`` pins a model to Converse. Every other OpenAI-family
-        model stays on Converse without the prefix.
+        model stays on Converse without the prefix. A model the cost map does not list as Converse goes to
+        Invoke only when its id names an Invoke provider, and to Converse otherwise.
         """
+        named_route: Final = BedrockModelInfo.named_bedrock_route(model, request_params)
+        if named_route is not None:
+            return named_route
+        return "converse" if _names_no_invoke_provider(model) else "invoke"
+
+    @staticmethod
+    def named_bedrock_route(
+        model: str,
+        request_params: Mapping[str, object] | None,
+    ) -> BedrockRoute | None:
         route_mappings: dict[
             str,
             Literal[
@@ -1822,7 +1876,7 @@ class BedrockModelInfo(BaseLLMModelInfo):
             return "converse"
         if _OPENAI_FAMILY_MODEL_RE.search(base_model):
             return "converse"
-        return "invoke"
+        return None
 
     @staticmethod
     def _explicit_converse_route(model: str) -> bool:
diff --git a/litellm/llms/custom_httpx/llm_http_handler.py b/litellm/llms/custom_httpx/llm_http_handler.py
index 61fc23589ac..9a2b352dd86 100644
--- a/litellm/llms/custom_httpx/llm_http_handler.py
+++ b/litellm/llms/custom_httpx/llm_http_handler.py
@@ -249,7 +249,7 @@ if TYPE_CHECKING:
         FakeAnthropicMessagesStreamIterator,
     )
     from litellm.llms.base_llm.passthrough.transformation import BasePassthroughConfig
-    from litellm.responses.streaming_iterator import ResponsesWsFrameGuard
+    from litellm.responses.streaming_iterator import ResponsesWsFrameGuard, ResponsesWsTurnAdmission
     from litellm.types.google_genai.main import GenerateContentResponse
     from litellm.types.llms.openai_evals import (
         CancelEvalResponse,
@@ -7269,7 +7269,7 @@ class BaseLLMHTTPHandler:
         custom_llm_provider: str | None = None,
         first_message: str | None = None,
         request_defaults: ResponsesWebSocketRequestDefaults | None = None,
-        turn_admission: Callable[[], Awaitable[None]] | None = None,
+        turn_admission: "ResponsesWsTurnAdmission | None" = None,
         frame_guard: "ResponsesWsFrameGuard | None" = None,
         **kwargs: object,
     ) -> Exception | None:
diff --git a/litellm/llms/deepseek/chat/transformation.py b/litellm/llms/deepseek/chat/transformation.py
index ecaa0a2ef16..5b7c2a2c410 100644
--- a/litellm/llms/deepseek/chat/transformation.py
+++ b/litellm/llms/deepseek/chat/transformation.py
@@ -6,10 +6,12 @@ from collections.abc import Coroutine, Mapping, Sequence
 from typing import Final, Literal, cast, overload
 
 import litellm
+from litellm.litellm_core_utils.core_helpers import as_str_mapping
 from litellm.litellm_core_utils.prompt_templates.common_utils import (
     convert_content_list_to_str,
     extract_search_results_text,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE, warn_dropped_reasoning
 from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.llms.openai import AllMessageValues
@@ -18,6 +20,16 @@ from litellm.utils import supports_reasoning, supports_vision
 from ...openai.chat.gpt_transformation import OpenAIGPTConfig
 
 SUPPORTED_REASONING_EFFORTS: Final = ("minimal", "low", "medium", "high", "xhigh", "max", "ultra")
+_NO_BUDGET_REASON: Final = "DeepSeek takes thinking only as enabled or disabled, with no budget."
+
+
+def _warn_on_dropped_budget(thinking: object, model: str) -> None:
+    fields: Final = as_str_mapping(thinking)
+    if fields is None or fields.get("type") != "enabled" or "budget_tokens" not in fields:
+        return
+    warn_dropped_reasoning(
+        "thinking.budget_tokens", fields["budget_tokens"], model, _NO_BUDGET_REASON, drop_params_gated=False
+    )
 
 
 class DeepSeekChatConfig(OpenAIGPTConfig):
@@ -53,6 +65,7 @@ class DeepSeekChatConfig(OpenAIGPTConfig):
         # Then re-add only if valid for DeepSeek
         thinking_value: Final = optional_params.pop("thinking", None)
         reasoning_effort: Final = optional_params.pop("reasoning_effort", None)
+        _warn_on_dropped_budget(OPAQUE_VALUE.validate_python(thinking_value), model)
 
         # Handle thinking parameter - accept both enabled and disabled, ignore budget_tokens
         if isinstance(thinking_value, dict) and thinking_value.get("type") in ("enabled", "disabled"):
diff --git a/litellm/llms/fal_ai/chat/transformation.py b/litellm/llms/fal_ai/chat/transformation.py
index 115b1f840de..848ae498cdd 100644
--- a/litellm/llms/fal_ai/chat/transformation.py
+++ b/litellm/llms/fal_ai/chat/transformation.py
@@ -12,7 +12,9 @@ from typing import TYPE_CHECKING, Final
 import httpx
 from pydantic import ConfigDict, TypeAdapter
 
+import litellm
 from litellm.litellm_core_utils.core_helpers import map_finish_reason
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.llms.base import LiteLLMBaseModel
@@ -29,6 +31,10 @@ PROVIDER_PREFIX: Final[str] = "fal_ai/"
 PASSTHROUGH_PARAMS: Final[frozenset[str]] = frozenset(("reasoning", "temperature", "top_p"))
 REASONING_DISABLED_EFFORTS: Final[frozenset[str]] = frozenset(("none", "minimal"))
 REASONING_ENABLED_EFFORTS: Final[frozenset[str]] = frozenset(("low", "medium", "high"))
+_UNSUPPORTED_EFFORT_REASON: Final = (
+    f"fal only turns reasoning off for {sorted(REASONING_DISABLED_EFFORTS)} "
+    f"and on for {sorted(REASONING_ENABLED_EFFORTS)}."
+)
 
 
 class _FalUsage(LiteLLMBaseModel):
@@ -120,9 +126,10 @@ class FalAIChatConfig(BaseConfig):
             return False
         if isinstance(value, str) and value in REASONING_ENABLED_EFFORTS:
             return True
-        if drop_params:
-            return None
-        raise FalAIError(status_code=400, message=f"Unsupported reasoning_effort {value!r} for {model}")
+        if not (drop_params or litellm.drop_params is True):
+            raise FalAIError(status_code=400, message=f"Unsupported reasoning_effort {value!r} for {model}")
+        warn_dropped_reasoning("reasoning_effort", value, model, _UNSUPPORTED_EFFORT_REASON, drop_params_gated=True)
+        return None
 
     def _translate_param(self, param: str, value: object, model: str, drop_params: bool) -> tuple[str, object] | None:
         if param in ("temperature", "top_p"):
diff --git a/litellm/llms/fireworks_ai/chat/transformation.py b/litellm/llms/fireworks_ai/chat/transformation.py
index fa5794d71b3..92c6c8439b3 100644
--- a/litellm/llms/fireworks_ai/chat/transformation.py
+++ b/litellm/llms/fireworks_ai/chat/transformation.py
@@ -17,6 +17,7 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import (
     strip_litellm_response_only_fields,
     unpack_legacy_defs,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE, warn_dropped_reasoning
 from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.secret_managers.main import get_secret_str
 from litellm.types.llms.openai import (
@@ -97,6 +98,7 @@ def _json_schema_response_format(schema: object, name: str) -> Mapping[str, obje
 
 
 EFFORT_KWARG_KEYS: Final = frozenset({"enable_thinking", "thinking", "reasoning_budget", "low_effort"})
+_NOT_A_REASONING_MODEL_REASON: Final = "litellm's model map does not list it as a reasoning model."
 
 
 def _bool_from_kwargs(kwargs: Mapping[str, object], keys: tuple[str, ...]) -> bool | None:
@@ -107,6 +109,13 @@ def _bool_from_kwargs(kwargs: Mapping[str, object], keys: tuple[str, ...]) -> bo
     return None
 
 
+def warn_dropped_effort_kwargs(chat_template_kwargs: object, effort: object, model: str) -> None:
+    if effort != "none":
+        warn_dropped_reasoning(
+            "chat_template_kwargs", chat_template_kwargs, model, _NOT_A_REASONING_MODEL_REASON, drop_params_gated=False
+        )
+
+
 def effort_from_chat_template_kwargs(kwargs: Mapping[str, object]) -> object:
     enable_thinking: Final = _bool_from_kwargs(kwargs, ("enable_thinking", "thinking"))
     if enable_thinking is False:
@@ -438,10 +447,7 @@ class FireworksAIConfig(FireworksAIMixin, OpenAIGPTConfig):
         if effort is None:
             return ()
         if not supports_reasoning(model=model, custom_llm_provider="fireworks_ai"):
-            verbose_logger.debug(
-                "fireworks_ai model %r does not support reasoning; dropping chat_template_kwargs effort keys.",
-                model,
-            )
+            warn_dropped_effort_kwargs(OPAQUE_VALUE.validate_python(chat_template_kwargs), effort, model)
             return ()
         return (("reasoning_effort", effort),)
 
diff --git a/litellm/llms/fireworks_ai/completion/transformation.py b/litellm/llms/fireworks_ai/completion/transformation.py
index 1f5d4f306a9..611e60cedd4 100644
--- a/litellm/llms/fireworks_ai/completion/transformation.py
+++ b/litellm/llms/fireworks_ai/completion/transformation.py
@@ -2,6 +2,7 @@ from collections.abc import Mapping
 from typing import Final
 
 from litellm._logging import verbose_logger
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE
 from litellm.types.llms.openai import AllMessageValues, OpenAITextCompletionUserMessage
 from litellm.utils import supports_reasoning
 
@@ -12,6 +13,7 @@ from ..chat.transformation import (
     NIM_VLLM_STRIP_PARAMS,
     FireworksAIConfig,
     effort_from_chat_template_kwargs,
+    warn_dropped_effort_kwargs,
 )
 from ..common_utils import FireworksAIMixin, resolve_fireworks_resource_name
 
@@ -129,10 +131,7 @@ class FireworksAITextCompletionConfig(FireworksAIMixin, BaseTextCompletionConfig
             )
             return result
         if not supports_reasoning(model=model, custom_llm_provider="fireworks_ai"):
-            verbose_logger.debug(
-                "fireworks_ai model %r does not support reasoning; dropping chat_template_kwargs effort keys.",
-                model,
-            )
+            warn_dropped_effort_kwargs(OPAQUE_VALUE.validate_python(chat_template_kwargs), effort, model)
             return result
         return {**result, "reasoning_effort": effort}
 
diff --git a/litellm/llms/hosted_vllm/chat/transformation.py b/litellm/llms/hosted_vllm/chat/transformation.py
index 63e6cb2b5da..9f9503f93b6 100644
--- a/litellm/llms/hosted_vllm/chat/transformation.py
+++ b/litellm/llms/hosted_vllm/chat/transformation.py
@@ -99,7 +99,7 @@ class HostedVLLMChatConfig(OpenAIGPTConfig):
         thinking_effort: Final = (
             None
             if "reasoning_effort" in non_default_params
-            else reasoning_effort_from_thinking(thinking, drop_params=drop_params)
+            else reasoning_effort_from_thinking(thinking, model=model, drop_params=drop_params)
         )
         if thinking_effort is not None:
             non_default_params["reasoning_effort"] = thinking_effort
diff --git a/litellm/llms/mistral/chat/transformation.py b/litellm/llms/mistral/chat/transformation.py
index 15e348453e0..a402e2c4048 100644
--- a/litellm/llms/mistral/chat/transformation.py
+++ b/litellm/llms/mistral/chat/transformation.py
@@ -25,6 +25,7 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import (
     strip_litellm_internal_message_fields,
     strip_none_values_from_message,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE, warn_dropped_reasoning
 from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.openai.chat.gpt_transformation import (
     OpenAIChatCompletionStreamingHandler,
@@ -74,6 +75,12 @@ _MISTRAL_REQUEST_ROUTING: Final = TypeAdapter(MistralRequestRouting)
 _MISTRAL_CACHE_KEY_PARAMS: Final = TypeAdapter(MistralCacheKeyParams)
 _MISTRAL_REASONING_EFFORT_PARAMS: Final = TypeAdapter(MistralReasoningEffortParams)
 _MISTRAL_FILE_PART: Final = TypeAdapter(MistralFilePart)
+_REASONING_PROMPT_REASON: Final = "litellm sends Magistral a reasoning system prompt instead of the requested level."
+_NON_LEVEL_EFFORT_REASON: Final = (
+    "the Mistral API takes it only as a level such as 'high', so Mistral applies its default effort."
+)
+_DOCUMENTED_MAGISTRAL_EFFORTS: Final = frozenset({"low", "medium", "high"})
+_REASONING_ON_THINKING_TYPES: Final = frozenset({"enabled", "adaptive"})
 
 
 def _reasoning_level_and_summary(reasoning_effort: object) -> tuple[object, object]:
@@ -83,6 +90,16 @@ def _reasoning_level_and_summary(reasoning_effort: object) -> tuple[object, obje
     return requested.get("effort"), requested.get("summary")
 
 
+def _warn_unless_reasoning_prompt_honors(param: str, value: object, model: str) -> None:
+    if param == "reasoning_effort" and isinstance(value, str) and value in _DOCUMENTED_MAGISTRAL_EFFORTS:
+        return
+    thinking: Final = as_str_mapping(value)
+    thinking_type: Final = thinking.get("type") if thinking is not None else None
+    if param == "thinking" and isinstance(thinking_type, str) and thinking_type in _REASONING_ON_THINKING_TYPES:
+        return
+    warn_dropped_reasoning(param, value, model, _REASONING_PROMPT_REASON, drop_params_gated=False)
+
+
 def _is_json_array(value: object) -> TypeIs[Sequence[object]]:  # guard-ok: a decoded JSON array is a list
     return isinstance(value, list)
 
@@ -253,6 +270,7 @@ class MistralConfig(OpenAIGPTConfig):
             if param in ("reasoning_effort", "thinking") and "magistral" in model.lower():
                 # Flag that we need to add reasoning system prompt
                 optional_params["_add_reasoning_prompt"] = True
+                _warn_unless_reasoning_prompt_honors(param, OPAQUE_VALUE.validate_python(value), model)
             if param in ("parallel_tool_calls", "prompt_cache_key"):
                 optional_params[param] = value
         return optional_params
@@ -260,13 +278,18 @@ class MistralConfig(OpenAIGPTConfig):
     def _reasoning_level_to_send(
         self, model: str, requested: MistralReasoningEffortParams, drop_params: bool
     ) -> str | None:
-        level, summary = _reasoning_level_and_summary(requested.get("reasoning_effort"))
+        requested_effort: Final = requested.get("reasoning_effort")
+        level, summary = _reasoning_level_and_summary(requested_effort)
         sendable: Final = (
             _accepted_reasoning_effort(model, level, self.custom_llm_provider) if isinstance(level, str) else None
         )
         if sendable is not None and summary is None:
             return sendable
         if drop_params or litellm.drop_params is True:
+            if sendable is None and level is not None:
+                warn_dropped_reasoning(
+                    "reasoning_effort", requested_effort, model, _NON_LEVEL_EFFORT_REASON, drop_params_gated=True
+                )
             return sendable
         raise UnsupportedParamsError(
             message=(
diff --git a/litellm/llms/oci/chat/transformation.py b/litellm/llms/oci/chat/transformation.py
index 8257a75b4a5..9c827822dc1 100644
--- a/litellm/llms/oci/chat/transformation.py
+++ b/litellm/llms/oci/chat/transformation.py
@@ -21,6 +21,7 @@ from litellm._logging import verbose_logger
 from litellm.constants import DEFAULT_OCI_CHAT_MAX_TOKENS
 from litellm.litellm_core_utils.logging_utils import track_llm_api_timing
 from litellm.litellm_core_utils.prompt_templates.common_utils import messages_with_file_parts_as_image_urls
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
@@ -428,6 +429,13 @@ class OCIChatConfig(BaseConfig):
             alias = param_map.get(key)
             if key == "reasoning_effort" and alias and not _model_supports_reasoning_effort(model):
                 if drop_params or litellm.drop_params:
+                    warn_dropped_reasoning(
+                        key,
+                        value,
+                        model,
+                        "the model map lists no reasoning_effort levels for it, so OCI would reject reasoningEffort.",
+                        drop_params_gated=True,
+                    )
                     continue
                 raise OCIError(
                     status_code=400,
@@ -451,6 +459,14 @@ class OCIChatConfig(BaseConfig):
                 if key == "n" and (value is None or value == 1):
                     continue
                 if drop_params or litellm.drop_params:
+                    if key == "reasoning_effort":
+                        warn_dropped_reasoning(
+                            key,
+                            value,
+                            model,
+                            "OCI's Cohere chat API has no reasoning effort field.",
+                            drop_params_gated=True,
+                        )
                     continue
                 raise OCIError(
                     status_code=400,
diff --git a/litellm/llms/ollama/chat/transformation.py b/litellm/llms/ollama/chat/transformation.py
index f9e7071db41..755d647da1d 100644
--- a/litellm/llms/ollama/chat/transformation.py
+++ b/litellm/llms/ollama/chat/transformation.py
@@ -14,6 +14,7 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import (
     extract_images_from_message,
     extract_reasoning_content,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE
 from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
@@ -29,7 +30,7 @@ from litellm.types.llms.openai import (
 )
 from litellm.types.utils import ModelResponse, ModelResponseStream
 
-from ..common_utils import OllamaError
+from ..common_utils import OllamaError, ollama_think
 
 if TYPE_CHECKING:
     from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
@@ -172,10 +173,7 @@ class OllamaChatConfig(BaseConfig):
                 if value.get("json_schema") and value["json_schema"].get("schema"):
                     optional_params["format"] = value["json_schema"]["schema"]
             if param == "reasoning_effort" and value is not None:
-                if model.startswith("gpt-oss"):
-                    optional_params["think"] = value
-                else:
-                    optional_params["think"] = value in {"low", "medium", "high"}
+                optional_params["think"] = ollama_think(model, OPAQUE_VALUE.validate_python(value))
             ### FUNCTION CALLING LOGIC ###
             # Ollama 0.4+ supports native tool calling - pass tools directly
             # and let Ollama handle model capability detection
diff --git a/litellm/llms/ollama/common_utils.py b/litellm/llms/ollama/common_utils.py
index f313c62f026..fcf6a396a13 100644
--- a/litellm/llms/ollama/common_utils.py
+++ b/litellm/llms/ollama/common_utils.py
@@ -8,11 +8,14 @@ from pydantic import BaseModel, TypeAdapter
 
 from litellm import verbose_logger
 from litellm._uuid import uuid
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning
 from litellm.litellm_core_utils.url_utils import join_api_base
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.types.utils import ModelResponse, ModelResponseStream
 
 _PROVIDER_FIELDS: Final = TypeAdapter(dict[str, object])
+_THINK_ON_EFFORTS: Final = frozenset({"low", "medium", "high"})
+_THINK_OFF_REASON: Final = "Ollama takes think only as on or off, and litellm maps this level to off."
 _DECODED_JSON: Final = TypeAdapter(object)
 
 
@@ -296,3 +299,12 @@ class OllamaModelInfo(BaseLLMModelInfo):
         Return the base model name for Ollama (no-op).
         """
         return model
+
+
+def ollama_think(model: str, reasoning_effort: object) -> object:
+    if model.startswith("gpt-oss"):
+        return reasoning_effort
+    think: Final = reasoning_effort in _THINK_ON_EFFORTS
+    if isinstance(reasoning_effort, str) and not think and reasoning_effort != "none":
+        warn_dropped_reasoning("reasoning_effort", reasoning_effort, model, _THINK_OFF_REASON, drop_params_gated=False)
+    return think
diff --git a/litellm/llms/ollama/completion/transformation.py b/litellm/llms/ollama/completion/transformation.py
index 239b4e32645..6dbcb050e11 100644
--- a/litellm/llms/ollama/completion/transformation.py
+++ b/litellm/llms/ollama/completion/transformation.py
@@ -23,6 +23,7 @@ from litellm.litellm_core_utils.prompt_templates.image_handling import (
     async_inline_remote_media,
     inline_remote_image_urls,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE
 from litellm.litellm_core_utils.url_utils import ensure_api_route
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
@@ -43,7 +44,7 @@ from litellm.types.utils import (
     generate_id,
 )
 
-from ..common_utils import OllamaError, OllamaModelInfo, convert_image
+from ..common_utils import OllamaError, OllamaModelInfo, convert_image, ollama_think
 
 if TYPE_CHECKING:
     from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
@@ -249,10 +250,7 @@ class OllamaConfig(BaseConfig):
             elif param == "stop":
                 optional_params["stop"] = value
             elif param == "reasoning_effort" and value is not None:
-                if model.startswith("gpt-oss"):
-                    optional_params["think"] = value
-                else:
-                    optional_params["think"] = value in {"low", "medium", "high"}
+                optional_params["think"] = ollama_think(model, OPAQUE_VALUE.validate_python(value))
             elif param == "response_format" and isinstance(value, dict):
                 if value["type"] == "json_object":
                     optional_params["format"] = "json"
diff --git a/litellm/llms/openai/common_utils.py b/litellm/llms/openai/common_utils.py
index aa14a985afe..c113cb351d8 100644
--- a/litellm/llms/openai/common_utils.py
+++ b/litellm/llms/openai/common_utils.py
@@ -32,6 +32,7 @@ import litellm
 from litellm.exceptions import error_response_without_credentials
 from litellm.litellm_core_utils.completion_timeout import CompletionTimeout
 from litellm.litellm_core_utils.core_helpers import as_str_mapping, decoded_json_object
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning_params
 from litellm.litellm_core_utils.token_counter import token_counter, usage_tokenizer_model
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.custom_httpx.http_handler import (
@@ -165,17 +166,11 @@ _DECODED_JSON: Final = TypeAdapter(object)
 def drop_params_from_unprocessable_entity_error(
     e: openai.UnprocessableEntityError | httpx.HTTPStatusError,
     data: Mapping[str, object],
+    *,
+    model: str | None,
+    drop_params_gated: bool,
 ) -> dict[str, object]:
-    """
-    Helper function to read OpenAI UnprocessableEntityError and drop the params that raised an error from the error message.
-
-    Args:
-    e (UnprocessableEntityError): The UnprocessableEntityError exception
-    data (Dict[str, Any]): The original data dictionary containing all parameters
-
-    Returns:
-    Dict[str, Any]: A new dictionary with invalid parameters removed
-    """
+    """Return a copy of ``data`` without the params a 422 response names as invalid."""
     invalid_params: Final[list[str]] = []
     if isinstance(e, httpx.HTTPStatusError):
         error_json: Final = decoded_json_object(_DECODED_JSON.validate_python(e.response.json()))
@@ -203,6 +198,13 @@ def drop_params_from_unprocessable_entity_error(
                     invalid_params.append(error_dict["loc"][1])
 
     new_data: Final = {k: v for k, v in data.items() if k not in invalid_params}
+    warn_dropped_reasoning_params(
+        invalid_params,
+        data,
+        model,
+        "the provider answered 422 naming it an invalid param.",
+        drop_params_gated=drop_params_gated,
+    )
 
     return new_data
 
diff --git a/litellm/llms/openai/openai.py b/litellm/llms/openai/openai.py
index bef99fd0719..bdd9f285823 100644
--- a/litellm/llms/openai/openai.py
+++ b/litellm/llms/openai/openai.py
@@ -940,7 +940,9 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM):
                 except openai.UnprocessableEntityError as e:
                     ## check if body contains unprocessable params - related issue https://github.com/BerriAI/litellm/issues/4800
                     if litellm.drop_params is True or drop_params is True:
-                        inference_params = drop_params_from_unprocessable_entity_error(e, inference_params)
+                        inference_params = drop_params_from_unprocessable_entity_error(
+                            e, inference_params, model=model, drop_params_gated=True
+                        )
                     else:
                         raise e
                     # e.message
@@ -1097,7 +1099,7 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM):
             except openai.UnprocessableEntityError as e:
                 ## check if body contains unprocessable params - related issue https://github.com/BerriAI/litellm/issues/4800
                 if litellm.drop_params is True or drop_params is True:
-                    data = drop_params_from_unprocessable_entity_error(e, data)
+                    data = drop_params_from_unprocessable_entity_error(e, data, model=model, drop_params_gated=True)
                 else:
                     raise e
                 # e.message
@@ -1252,7 +1254,7 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM):
             except openai.UnprocessableEntityError as e:
                 ## check if body contains unprocessable params - related issue https://github.com/BerriAI/litellm/issues/4800
                 if litellm.drop_params is True or drop_params is True:
-                    data = drop_params_from_unprocessable_entity_error(e, data)
+                    data = drop_params_from_unprocessable_entity_error(e, data, model=model, drop_params_gated=True)
                 else:
                     raise e
             except (
diff --git a/litellm/llms/openrouter/chat/transformation.py b/litellm/llms/openrouter/chat/transformation.py
index 9aaf552e79a..cca6815399f 100644
--- a/litellm/llms/openrouter/chat/transformation.py
+++ b/litellm/llms/openrouter/chat/transformation.py
@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Final, cast
 import httpx
 from pydantic import ConfigDict, TypeAdapter
 
+from litellm.litellm_core_utils.core_helpers import finite_cost
 from litellm.litellm_core_utils.hidden_params import HIDDEN_PARAMS_ATTR, set_hidden_params
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
@@ -225,8 +226,11 @@ class OpenrouterConfig(OpenAIGPTConfig):
                     additional_headers: Final = cast(  # cast-ok: preserve mapping operations on response metadata
                         dict[str, object], hidden_params["additional_headers"]
                     )
-                    if isinstance(response_cost, str | int | float):
-                        additional_headers["llm_provider-x-litellm-response-cost"] = float(response_cost)
+                    reported_cost: Final = (
+                        finite_cost(float(response_cost)) if isinstance(response_cost, str | int | float) else None
+                    )
+                    if reported_cost is not None:
+                        additional_headers["llm_provider-x-litellm-response-cost"] = reported_cost
         except Exception:
             # If we can't extract cost, continue without it - don't fail the response
             pass
diff --git a/litellm/llms/pass_through/typesafe_logging_handler.py b/litellm/llms/pass_through/typesafe_logging_handler.py
index 9eae57774c2..7a41d2a5d14 100644
--- a/litellm/llms/pass_through/typesafe_logging_handler.py
+++ b/litellm/llms/pass_through/typesafe_logging_handler.py
@@ -6,6 +6,7 @@ import httpx
 from pydantic import TypeAdapter, ValidationError
 
 import litellm
+from litellm.litellm_core_utils.core_helpers import finite_reported_cost
 from litellm.litellm_core_utils.decisions_pricing import apply_decisions_pricing
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.litellm_core_utils.litellm_logging import (
@@ -100,9 +101,10 @@ class TypeSafePassthroughLoggingHandler:
             f"{custom_llm_provider}/{model}" for model in candidate_models if model is not None
         )
         pricing: Final = _pricing_for(candidate_model_keys)
+        reported_cost: Final = finite_reported_cost(usage.cost) if custom_llm_provider == "openrouter" else None
         response_cost: Final = (
-            usage.cost
-            if custom_llm_provider == "openrouter" and usage.cost is not None
+            reported_cost
+            if reported_cost is not None
             else input_tokens * pricing.input_cost_per_token + output_tokens * pricing.output_cost_per_token
         )
         usage_object: Final = Usage(
diff --git a/litellm/llms/perplexity/cost_calculator.py b/litellm/llms/perplexity/cost_calculator.py
index 2d762adf958..c3d178771a5 100644
--- a/litellm/llms/perplexity/cost_calculator.py
+++ b/litellm/llms/perplexity/cost_calculator.py
@@ -6,6 +6,7 @@ Helper util for handling perplexity-specific cost calculation
 from datetime import datetime
 from typing import Final
 
+from litellm.litellm_core_utils.core_helpers import finite_reported_cost
 from litellm.litellm_core_utils.llm_cost_calc.utils import TokenRates, apply_off_peak_pricing
 from litellm.types.utils import Usage
 from litellm.utils import get_model_info
@@ -34,10 +35,9 @@ def cost_per_token(model: str, usage: Usage, current_time: datetime | None = Non
         total_cost = cost_info.get("total_cost")
     elif isinstance(cost_info, (int, float)) and not isinstance(cost_info, bool):
         total_cost = float(cost_info)
-    if total_cost is not None:
-        # Return total cost as completion_cost (prompt_cost=0) since Perplexity
-        # doesn't break down by input/output in their cost object
-        return (0.0, float(total_cost))
+    reported_cost: Final = None if total_cost is None else finite_reported_cost(float(total_cost))
+    if reported_cost is not None:
+        return (0.0, reported_cost)
 
     ## FALLBACK: Calculate cost manually if Perplexity doesn't provide it
     ## GET MODEL INFO
diff --git a/litellm/llms/tencent/chat/transformation.py b/litellm/llms/tencent/chat/transformation.py
index 1f0bcd218d6..23a6ccd52c6 100644
--- a/litellm/llms/tencent/chat/transformation.py
+++ b/litellm/llms/tencent/chat/transformation.py
@@ -9,12 +9,15 @@ from typing import Final, TypedDict
 from typing_extensions import ReadOnly
 
 import litellm
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning
 from litellm.litellm_core_utils.url_utils import ensure_api_route, join_api_base
 from litellm.secret_managers.main import get_secret_str
 from litellm.utils import supports_reasoning
 
 from ...openai.chat.gpt_transformation import OpenAIGPTConfig
 
+_ADAPTIVE_BUDGET_REASON: Final = "it is not an integer, so litellm sends adaptive thinking with no budget."
+
 
 class ThinkingPayload(TypedDict, total=False):
     """Tencent TokenHub `thinking` object.
@@ -102,6 +105,10 @@ class TencentChatConfig(OpenAIGPTConfig):
         if isinstance(budget, int):
             coerced_with_budget: Final[ThinkingPayload] = {"type": "adaptive", "budget_tokens": budget}
             return coerced_with_budget
+        if budget is not None:
+            warn_dropped_reasoning(
+                "thinking.budget_tokens", budget, model, _ADAPTIVE_BUDGET_REASON, drop_params_gated=False
+            )
         coerced: Final[ThinkingPayload] = {"type": "adaptive"}
         return coerced
 
diff --git a/litellm/llms/vertex_ai/common_utils.py b/litellm/llms/vertex_ai/common_utils.py
index 0fa80cb2cad..ad64d852ef9 100644
--- a/litellm/llms/vertex_ai/common_utils.py
+++ b/litellm/llms/vertex_ai/common_utils.py
@@ -1257,7 +1257,7 @@ def get_vertex_model_id_from_url(url: str) -> str | None:
 
     `https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:streamGenerateContent`
     """
-    match: Final = re.search(r"/models/([^:]+)", url)
+    match: Final = re.search(r"/models/([^:?#]+)", url)
     return match.group(1) if match else None
 
 
diff --git a/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py b/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
index c506192f253..1ef5267df14 100644
--- a/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
+++ b/litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
@@ -34,6 +34,7 @@ from litellm.litellm_core_utils.json_fragment_accumulator import JSONFragmentAcc
 from litellm.litellm_core_utils.prompt_templates.factory import (
     encode_tool_call_id_with_signature,
 )
+from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning
 from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
 from litellm.llms.custom_httpx.http_handler import (
     AsyncHTTPHandler,
@@ -201,6 +202,13 @@ def _unsupported_reasoning_effort(reasoning_effort: str) -> UnsupportedParamsErr
 
 
 _SAMPLING_DEPRECATION_UNMAPPED_MODELS: Final = "models outside litellm's model map"
+_NON_INTEGER_BUDGET_REASON: Final = (
+    "Gemini takes budget_tokens only as an integer, so it uses its default thinking budget."
+)
+_LEVEL_ONLY_BUDGET_REASON: Final = (
+    "Gemini 3 and later set reasoning by thinking level, not budget, so litellm does not send the budget. "
+    "Send reasoning_effort to pick a level."
+)
 _sampling_deprecation_lock: Final = threading.Lock()
 
 
@@ -1466,6 +1474,14 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
                     params["includeThoughts"] = False
                 else:
                     params["includeThoughts"] = sends_thoughts
+                    if thinking_budget is not None:
+                        warn_dropped_reasoning(
+                            "thinking.budget_tokens",
+                            thinking_budget,
+                            model,
+                            _LEVEL_ONLY_BUDGET_REASON,
+                            drop_params_gated=False,
+                        )
                     # Follow provider defaults unless explicitly opted into legacy behavior.
                     if litellm.enable_gemini_default_thinking_level_low is True:
                         params["thinkingLevel"] = (
@@ -1478,8 +1494,16 @@ class VertexGeminiConfig(VertexAIBaseConfig, BaseConfig):
             # For older Gemini models, use thinkingBudget
             if thinking_enabled and not VertexGeminiConfig._is_thinking_budget_zero(thinking_budget):
                 params["includeThoughts"] = sends_thoughts
-            if thinking_budget is not None and isinstance(thinking_budget, int):
+            if isinstance(thinking_budget, int):
                 params["thinkingBudget"] = thinking_budget
+            elif thinking_budget is not None:
+                warn_dropped_reasoning(
+                    "thinking.budget_tokens",
+                    thinking_budget,
+                    model,
+                    _NON_INTEGER_BUDGET_REASON,
+                    drop_params_gated=False,
+                )
 
         return params
 
diff --git a/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py b/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py
index da82766c2b9..98fa8ed2b77 100644
--- a/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py
+++ b/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/messages/transformation.py
@@ -1,9 +1,15 @@
 from collections.abc import Mapping, Sequence
 from typing import Final
 
+from pydantic import TypeAdapter
+
 from litellm.exceptions import UnsupportedParamsError
 from litellm.litellm_core_utils.core_helpers import drops_unsupported_params
-from litellm.llms.anthropic.common_utils import AnthropicModelInfo, context_management_betas
+from litellm.llms.anthropic.common_utils import (
+    AnthropicModelInfo,
+    context_management_betas,
+    requires_native_compaction_beta,
+)
 from litellm.llms.anthropic.messages.native.transformation import (
     AnthropicMessagesConfig,
     messages_carry_output_config,
@@ -11,6 +17,7 @@ from litellm.llms.anthropic.messages.native.transformation import (
 from litellm.types.llms.anthropic import (
     ANTHROPIC_BETA_HEADER_VALUES,
     ANTHROPIC_HOSTED_TOOLS,
+    ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER,
 )
 from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
 from litellm.types.llms.vertex_ai import VertexPartnerProvider
@@ -19,6 +26,8 @@ from litellm.types.router import GenericLiteLLMParams
 from ....vertex_llm_base import VertexBase
 from ..output_params_utils import sanitize_vertex_anthropic_output_params
 
+_OPTIONAL_PARAMS: Final = TypeAdapter(Mapping[str, object])
+
 _VERSION_HEADER_VERTEX_READS_FROM_BODY: Final = "anthropic-version"
 _VERTEX_DEFAULT_VERSION: Final = "vertex-2023-10-16"
 _VERSIONS_SERVED_AS_VERTEX_DEFAULT: Final = frozenset({"", "2023-01-01", "2023-06-01"})
@@ -190,14 +199,23 @@ class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, Vert
         if messages_carry_output_config(messages):
             beta_values.add(ANTHROPIC_BETA_HEADER_VALUES.PER_TURN_CONTROL_2026_07_01.value)
 
-        beta_values.update(
+        typed_params: Final = _OPTIONAL_PARAMS.validate_python(optional_params)
+        if requires_native_compaction_beta("vertex_ai", typed_params, messages):
+            beta_values.add(ANTHROPIC_BETA_HEADER_VALUES.COMPACT_2026_09_04.value)
+
+        tool_change_betas: Final = (
+            (ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER,)
+            if anthropic_model_info.is_mid_conversation_tool_change_used(messages)
+            else ()
+        )
+        all_beta_values: Final = beta_values.union(
             anthropic_model_info.thinking_betas(
                 optional_params.get("thinking"),  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]  # optional_params is the base config's bare dict
-            )
+            ),
+            tool_change_betas,
         )
-
-        if beta_values:
-            request_headers["anthropic-beta"] = ",".join(beta_values)
+        if all_beta_values:
+            request_headers["anthropic-beta"] = ",".join(sorted(all_beta_values))
 
         return request_headers, api_base
 
diff --git a/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py b/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
index 79fd9f9e8b1..3d1690fca33 100644
--- a/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
+++ b/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
@@ -2,19 +2,23 @@
 ## Handler file for calling claude-3 on vertex ai
 import base64
 import json
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from typing import TYPE_CHECKING, Final
 
 import httpx
-from pydantic import TypeAdapter
+from pydantic import TypeAdapter, ValidationError
 
 import litellm
+from litellm.anthropic_beta_headers_manager import get_header_only_betas
+from litellm.litellm_core_utils.core_helpers import drops_unsupported_params
 from litellm.litellm_core_utils.prompt_templates.image_handling import RemoteMedia, inline_remote_image_urls
 from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
+from litellm.types.llms.anthropic import ANTHROPIC_BETA_HEADER_VALUES
 from litellm.types.llms.openai import AllMessageValues
 from litellm.types.utils import ModelResponse
 
 from ....anthropic.chat.transformation import AnthropicConfig
+from ....anthropic.common_utils import AnthropicError, requires_native_compaction_beta
 from .output_params_utils import sanitize_vertex_anthropic_output_params
 
 if TYPE_CHECKING:
@@ -36,6 +40,32 @@ def _vertex_labels_header(labels: object, header_names: Mapping[str, object]) ->
     return base64.b64encode(json.dumps(string_labels).encode()).decode() if string_labels else None
 
 
+_BETA_VALUE: Final[TypeAdapter[str | tuple[str, ...] | None]] = TypeAdapter(str | tuple[str, ...] | None)
+
+_REQUEST_MESSAGES: Final = TypeAdapter(Sequence[object])
+
+
+def _beta_names(value: object) -> frozenset[str] | None:
+    try:
+        parsed: Final = _BETA_VALUE.validate_python(value)
+    except ValidationError:
+        return None
+    names: Final = parsed.split(",") if isinstance(parsed, str) else parsed or ()
+    return frozenset(name.strip() for name in names if name.strip())
+
+
+def _client_betas(value: object, field: str, drop_params: bool) -> frozenset[str]:
+    names: Final = _beta_names(value)
+    if names is not None:
+        return names
+    if drop_params:
+        return frozenset()
+    raise AnthropicError(
+        status_code=400,
+        message=f"{field} must be a string or a list of strings, got {type(value).__name__}",
+    )
+
+
 class VertexAIError(Exception):
     def __init__(self, status_code, message):
         self.status_code = status_code
@@ -157,21 +187,43 @@ class VertexAIAnthropicConfig(AnthropicConfig):
         if context_management:
             self._add_context_management_beta_headers(beta_set, context_management)
 
-        extra_headers: Final = optional_params.get("extra_headers") or {}
-        anthropic_beta_value: Final = extra_headers.get("anthropic-beta", "")
-        if isinstance(anthropic_beta_value, str) and anthropic_beta_value:
-            for beta in anthropic_beta_value.split(","):
-                beta = beta.strip()
-                if beta:
-                    beta_set.add(beta)
-        elif isinstance(anthropic_beta_value, list):
-            beta_set.update(anthropic_beta_value)
-
+        request_params: Final = _NON_DEFAULT_PARAMS.validate_python(optional_params)
+        compaction_betas: Final = (
+            frozenset({ANTHROPIC_BETA_HEADER_VALUES.COMPACT_2026_09_04.value})
+            if requires_native_compaction_beta(
+                "vertex_ai", request_params, _REQUEST_MESSAGES.validate_python(data["messages"])
+            )
+            else frozenset[str]()
+        )
+        drop_params: Final = drops_unsupported_params(litellm_params.get("drop_params"))
+        extra_headers: Final = _NON_DEFAULT_PARAMS.validate_python(request_params.get("extra_headers") or {})
         data.pop("extra_headers", None)
+        injected_betas: Final = frozenset(beta_set) | _client_betas(
+            extra_headers.get("anthropic-beta"), "The anthropic-beta header", drop_params
+        )
+        client_body_betas: Final = _client_betas(
+            _NON_DEFAULT_PARAMS.validate_python(data).get("anthropic_beta"), "anthropic_beta", drop_params
+        )
 
-        if beta_set:
-            data["anthropic_beta"] = list(beta_set)
-            headers["anthropic-beta"] = ",".join(beta_set)
+        requested_betas: Final = injected_betas | client_body_betas
+        header_only_betas: Final = get_header_only_betas("vertex_ai") if requested_betas else frozenset[str]()
+        body_betas: Final = requested_betas - header_only_betas
+        if body_betas:
+            data["anthropic_beta"] = sorted(body_betas)
+        elif "anthropic_beta" in data:
+            del data["anthropic_beta"]
+        header_betas: Final = (
+            injected_betas
+            | compaction_betas
+            | (client_body_betas & header_only_betas)
+            | _client_betas(
+                _NON_DEFAULT_PARAMS.validate_python(headers).get("anthropic-beta"),
+                "The anthropic-beta header",
+                drop_params,
+            )
+        )
+        if header_betas:
+            headers["anthropic-beta"] = ",".join(sorted(header_betas))
 
         return data
 
diff --git a/litellm/llms/vertex_ai/vertex_ai_partner_models/count_tokens/handler.py b/litellm/llms/vertex_ai/vertex_ai_partner_models/count_tokens/handler.py
index 180761f15d9..e341c8f5f48 100644
--- a/litellm/llms/vertex_ai/vertex_ai_partner_models/count_tokens/handler.py
+++ b/litellm/llms/vertex_ai/vertex_ai_partner_models/count_tokens/handler.py
@@ -6,12 +6,19 @@ Unlike Gemini models which use Google's token counting API, partner models use
 their respective publisher-specific count-tokens endpoints.
 """
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from typing import Any, Final
 
+from pydantic import TypeAdapter
+
 from litellm.litellm_core_utils.core_helpers import drops_unsupported_params
 from litellm.litellm_core_utils.url_utils import join_api_base
-from litellm.llms.anthropic.common_utils import OBJECT_LIST_ADAPTER, is_claude_model_target, tools_without_custom_field
+from litellm.llms.anthropic.common_utils import (
+    OBJECT_LIST_ADAPTER,
+    count_tokens_feature_betas,
+    is_claude_model_target,
+    tools_without_custom_field,
+)
 from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
 from litellm.llms.vertex_ai.common_utils import get_vertex_base_url
 from litellm.llms.vertex_ai.vertex_llm_base import VertexBase
@@ -23,6 +30,9 @@ _COUNT_TOKENS_PUBLISHERS: Final = (
 )
 
 
+_REQUEST_MESSAGES: Final = TypeAdapter(Sequence[object])
+
+
 def count_tokens_request_body(
     request_data: Mapping[str, object], model: str, drop_params: object
 ) -> Mapping[str, object]:
@@ -43,6 +53,14 @@ def count_tokens_publisher(model: str) -> str | None:
     return next((publisher for marker, publisher in _COUNT_TOKENS_PUBLISHERS if marker in model), None)
 
 
+def count_tokens_headers(access_token: str, request_data: Mapping[str, object]) -> Mapping[str, str]:
+    authorization: Final = {"Authorization": f"Bearer {access_token}"}
+    betas: Final = count_tokens_feature_betas(
+        "vertex_ai", request_data, _REQUEST_MESSAGES.validate_python(request_data["messages"])
+    )
+    return {**authorization, "anthropic-beta": ",".join(betas)} if betas else authorization
+
+
 class VertexAIPartnerModelsTokenCounter(VertexBase):
     """
     Token counter for Vertex AI Partner Models.
@@ -175,8 +193,7 @@ class VertexAIPartnerModelsTokenCounter(VertexBase):
             api_base=litellm_params.get("api_base"),
         )
 
-        # Prepare headers
-        headers: Final = {"Authorization": f"Bearer {access_token}"}
+        headers: Final = dict(count_tokens_headers(access_token, request_data))
 
         # Get async HTTP client
         from litellm import LlmProviders
diff --git a/litellm/llms/vllm/common_utils.py b/litellm/llms/vllm/common_utils.py
index 6484cdc88e3..014fabd5187 100644
--- a/litellm/llms/vllm/common_utils.py
+++ b/litellm/llms/vllm/common_utils.py
@@ -1,3 +1,4 @@
+from collections.abc import Mapping
 from typing import Final
 
 import httpx
@@ -10,6 +11,14 @@ from litellm.types.llms.openai import AllMessageValues
 from litellm.utils import add_path_to_api_base
 
 
+def endpoint_under_api_base(endpoint: str, api_base: str | None) -> str:
+    return (
+        endpoint.lstrip("/").removeprefix("v1/")
+        if api_base is not None and api_base.rstrip("/").endswith("/v1")
+        else endpoint
+    )
+
+
 class VLLMError(BaseLLMException):
     def __init__(
         self,
@@ -39,9 +48,14 @@ class VLLMModelInfo(BaseLLMModelInfo):
         api_key: str | None = None,
         api_base: str | None = None,
     ) -> dict:
-        if api_key is not None:
-            headers["x-api-key"] = api_key
-        return headers
+        upstream_key: Final = self.upstream_api_key(api_key, api_base)
+        return {**headers, **self.upstream_auth_headers(upstream_key)} if upstream_key else headers
+
+    def upstream_api_key(self, api_key: str | None, api_base: str | None) -> str | None:
+        return api_key
+
+    def upstream_auth_headers(self, api_key: str) -> Mapping[str, str]:
+        return {"Authorization": f"Bearer {api_key}", "x-api-key": api_key}
 
     @staticmethod
     def get_api_base(api_base: str | None = None) -> str | None:
diff --git a/litellm/llms/vllm/passthrough/transformation.py b/litellm/llms/vllm/passthrough/transformation.py
index e7da6e54410..2b253e7fa38 100644
--- a/litellm/llms/vllm/passthrough/transformation.py
+++ b/litellm/llms/vllm/passthrough/transformation.py
@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Final
 
 from httpx import Response
 
+from litellm.constants import PLACEHOLDER_API_KEY
 from litellm.litellm_core_utils.litellm_logging import Logging
 from litellm.llms.base_llm.passthrough.transformation import BasePassthroughConfig
 from litellm.llms.openai_like.passthrough.transformation import (
@@ -12,8 +13,14 @@ from litellm.llms.openai_like.passthrough.transformation import (
     logged_text_completion_stream,
     relays_text_completion,
 )
+from litellm.secret_managers.main import (
+    GOOGLE_OIDC_SECRET_PREFIX,
+    UnresolvableSecretReference,
+    get_secret_str,
+    resolve_local_oidc_reference,
+)
 
-from ..common_utils import VLLMModelInfo
+from ..common_utils import VLLMModelInfo, endpoint_under_api_base
 
 if TYPE_CHECKING:
     from httpx import URL
@@ -22,6 +29,30 @@ if TYPE_CHECKING:
 
 
 class VLLMPassthroughConfig(VLLMModelInfo, BasePassthroughConfig):
+    @staticmethod
+    def get_api_key(api_key: str | None = None) -> str | None:
+        return None if api_key == PLACEHOLDER_API_KEY else api_key
+
+    def upstream_api_key(self, api_key: str | None, api_base: str | None) -> str | None:
+        if api_key is not None or not self._is_vllm_api_base(api_base):
+            return api_key
+        vllm_api_key: Final = get_secret_str("VLLM_API_KEY")
+        if vllm_api_key is None or vllm_api_key.startswith(GOOGLE_OIDC_SECRET_PREFIX):
+            return None
+        match resolve_local_oidc_reference(vllm_api_key):
+            case UnresolvableSecretReference():
+                return None
+            case str() as resolved:
+                return resolved
+
+    @staticmethod
+    def _is_vllm_api_base(api_base: str | None) -> bool:
+        vllm_api_base: Final = get_secret_str("VLLM_API_BASE")
+        return api_base is not None and vllm_api_base is not None and api_base.rstrip("/") == vllm_api_base.rstrip("/")
+
+    def upstream_auth_headers(self, api_key: str) -> Mapping[str, str]:
+        return {"Authorization": f"Bearer {api_key}"}
+
     def is_streaming_request(self, endpoint: str, request_data: dict) -> bool:
         return "stream" in request_data
 
@@ -40,7 +71,7 @@ class VLLMPassthroughConfig(VLLMModelInfo, BasePassthroughConfig):
             raise Exception("VLLM api base not found")
 
         return (
-            self.format_url(endpoint, base_target_url, request_query_params),
+            self.format_url(endpoint_under_api_base(endpoint, base_target_url), base_target_url, request_query_params),
             base_target_url,
         )
 
diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json
index 0799a298942..ea9cacbdabe 100644
--- a/litellm/model_prices_and_context_window_backup.json
+++ b/litellm/model_prices_and_context_window_backup.json
@@ -8715,7 +8715,7 @@
             "search_context_size_low": 0.014,
             "search_context_size_medium": 0.014
         },
-        "source": "https://prices.azure.com/api/retail/prices?$filter=serviceName%20eq%20'Foundry%20Models'%20and%20armRegionName%20eq%20'eastus'%20and%20priceType%20eq%20'Consumption'",
+        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/responses"
@@ -8742,7 +8742,11 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_web_search": true,
-        "supports_xhigh_reasoning_effort": true
+        "supports_xhigh_reasoning_effort": true,
+        "cache_creation_input_token_cost_above_272k_tokens_flex": 1.25e-05,
+        "cache_read_input_token_cost_above_272k_tokens_flex": 1e-06,
+        "input_cost_per_token_above_272k_tokens_flex": 1e-05,
+        "output_cost_per_token_above_272k_tokens_flex": 3.75e-05
     },
     "azure/gpt-6-astra-2026-09-03": {
         "cache_creation_input_token_cost": 1.25e-05,
@@ -8763,7 +8767,7 @@
             "search_context_size_low": 0.014,
             "search_context_size_medium": 0.014
         },
-        "source": "https://prices.azure.com/api/retail/prices?$filter=serviceName%20eq%20'Foundry%20Models'%20and%20armRegionName%20eq%20'eastus'%20and%20priceType%20eq%20'Consumption'",
+        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/responses"
@@ -8790,7 +8794,11 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_web_search": true,
-        "supports_xhigh_reasoning_effort": true
+        "supports_xhigh_reasoning_effort": true,
+        "cache_creation_input_token_cost_above_272k_tokens_flex": 1.25e-05,
+        "cache_read_input_token_cost_above_272k_tokens_flex": 1e-06,
+        "input_cost_per_token_above_272k_tokens_flex": 1e-05,
+        "output_cost_per_token_above_272k_tokens_flex": 3.75e-05
     },
     "azure/gpt-6-luna": {
         "cache_creation_input_token_cost": 1.25e-07,
@@ -30856,8 +30864,9 @@
         "output_cost_per_token": 0,
         "output_vector_size": 3072,
         "rpm": 10000,
-        "source": "https://ai.google.dev/gemini-api/docs/embeddings#model-versions",
-        "tpm": 10000000
+        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "tpm": 10000000,
+        "input_cost_per_token_batches": 7.5e-08
     },
     "gemini/gemini-embedding-2": {
         "input_cost_per_audio_token": 6.5e-06,
@@ -31713,7 +31722,10 @@
         "input_cost_per_token_flex": 6.25e-07,
         "output_cost_per_token_batches": 5e-06,
         "output_cost_per_token_flex": 5e-06,
-        "supports_url_context": true
+        "supports_url_context": true,
+        "cache_read_input_token_cost_above_200k_tokens_batches": 2.5e-07,
+        "input_cost_per_token_above_200k_tokens_batches": 1.25e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 7.5e-06
     },
     "gemini/gemini-2.5-computer-use-preview-10-2025": {
         "deprecation_date": "2026-07-28",
@@ -31871,7 +31883,8 @@
         },
         "search_free_requests": {"count": 5000, "period": "month", "shared_group": "gemini-3"},
         "web_search_billing_unit": "per_query",
-        "google_maps_grounding_cost_per_query": 0.014
+        "google_maps_grounding_cost_per_query": 0.014,
+        "supports_computer_use": true
     },
     "gemini/gemini-3-flash-preview": {
         "cache_read_input_audio_token_cost": 1e-07,
@@ -31937,7 +31950,8 @@
         "input_cost_per_token_flex": 2.5e-07,
         "output_cost_per_token_batches": 1.5e-06,
         "output_cost_per_token_flex": 1.5e-06,
-        "supports_audio_input": true
+        "supports_audio_input": true,
+        "supports_computer_use": true
     },
     "gemini/gemini-3.5-flash": {
         "prompt_cache_min_tokens": 4096,
@@ -32184,7 +32198,8 @@
         },
         "search_free_requests": {"count": 5000, "period": "month", "shared_group": "gemini-3"},
         "web_search_billing_unit": "per_query",
-        "google_maps_grounding_cost_per_query": 0.014
+        "google_maps_grounding_cost_per_query": 0.014,
+        "supports_computer_use": true
     },
     "gemini/gemini-omni-flash-preview": {
         "input_cost_per_audio_token": 1.5e-06,
@@ -32280,7 +32295,10 @@
         "web_search_billing_unit": "per_query",
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token_flex": 1e-06,
-        "output_cost_per_token_flex": 6e-06
+        "output_cost_per_token_flex": 6e-06,
+        "cache_read_input_token_cost_above_200k_tokens_batches": 4e-07,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06
     },
     "gemini/gemini-3.1-pro-preview-customtools": {
         "prompt_cache_min_tokens": 4096,
@@ -32343,7 +32361,10 @@
         "web_search_billing_unit": "per_query",
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token_flex": 1e-06,
-        "output_cost_per_token_flex": 6e-06
+        "output_cost_per_token_flex": 6e-06,
+        "cache_read_input_token_cost_above_200k_tokens_batches": 4e-07,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06
     },
     "gemini-3-flash-preview": {
         "cache_read_input_audio_token_cost": 1e-07,
@@ -72228,6 +72249,7 @@
     },
     "aiand/deepseek-ai/deepseek-v4-flash": {
         "cache_read_input_token_cost": 8e-08,
+        "deprecation_date": "2026-10-27",
         "input_cost_per_token": 1.5e-07,
         "litellm_provider": "aiand",
         "max_input_tokens": 1048576,
@@ -72257,6 +72279,22 @@
         "supports_vision": false
     },
     "aiand/deepseek-ai/deepseek-v4.1-flash": {
+        "cache_read_input_token_cost": 2e-08,
+        "deprecation_date": "2026-11-05",
+        "input_cost_per_token": 3e-07,
+        "litellm_provider": "aiand",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 384000,
+        "mode": "chat",
+        "output_cost_per_token": 6e-07,
+        "source": "https://api.aiand.com/v1/models",
+        "supports_function_calling": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
+    "aiand/deepseek-ai/deepseek-v4.1-flash-1017": {
         "cache_read_input_token_cost": 2e-08,
         "input_cost_per_token": 3e-07,
         "litellm_provider": "aiand",
@@ -72286,8 +72324,24 @@
         "supports_tool_choice": true,
         "supports_vision": true
     },
+    "aiand/meta/muse-spark-open": {
+        "cache_read_input_token_cost": 1.5e-07,
+        "input_cost_per_token": 1.25e-06,
+        "litellm_provider": "aiand",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 943718,
+        "mode": "chat",
+        "output_cost_per_token": 4.25e-06,
+        "source": "https://api.aiand.com/v1/models",
+        "supports_function_calling": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
     "aiand/moonshotai/kimi-k2.7-code": {
         "cache_read_input_token_cost": 2e-07,
+        "deprecation_date": "2026-10-27",
         "input_cost_per_token": 7.5e-07,
         "litellm_provider": "aiand",
         "max_input_tokens": 262144,
@@ -72378,6 +72432,7 @@
     },
     "aiand/zai-org/glm-5.2": {
         "cache_read_input_token_cost": 3e-07,
+        "deprecation_date": "2026-10-27",
         "input_cost_per_token": 1e-06,
         "litellm_provider": "aiand",
         "max_input_tokens": 1048576,
@@ -76540,6 +76595,7 @@
         ],
         "supports_audio_input": true,
         "supports_audio_output": false,
+        "supports_computer_use": true,
         "supports_function_calling": true,
         "supports_minimal_reasoning_effort": false,
         "supports_native_streaming": true,
diff --git a/litellm/proxy/_lazy_openapi_snapshot.json b/litellm/proxy/_lazy_openapi_snapshot.json
index c76b9be7c33..dc8b9415020 100644
--- a/litellm/proxy/_lazy_openapi_snapshot.json
+++ b/litellm/proxy/_lazy_openapi_snapshot.json
@@ -3491,6 +3491,7 @@
               "additionalProperties": {
                 "$ref": "#/components/schemas/GuardrailMetric"
               },
+              "description": "Spend by guardrail ID, already included in key and model spend. Populated on user, team and organization aggregated activity only, without a model filter",
               "title": "Guardrails",
               "type": "object"
             },
@@ -3812,10 +3813,12 @@
         "GuardrailKeyMetric": {
           "properties": {
             "metadata": {
-              "$ref": "#/components/schemas/KeyMetadata"
+              "$ref": "#/components/schemas/KeyMetadata",
+              "description": "API key alias and existence information"
             },
             "metrics": {
-              "$ref": "#/components/schemas/GuardrailSpendMetrics"
+              "$ref": "#/components/schemas/GuardrailSpendMetrics",
+              "description": "Guardrail spend and unpriced units for this API key"
             }
           },
           "required": [
@@ -3828,6 +3831,7 @@
         "GuardrailMetadata": {
           "properties": {
             "guardrail_name": {
+              "description": "Guardrail display name, falling back to the guardrail ID",
               "title": "Guardrail Name",
               "type": "string"
             }
@@ -3844,14 +3848,17 @@
               "additionalProperties": {
                 "$ref": "#/components/schemas/GuardrailKeyMetric"
               },
+              "description": "Per-key guardrail spend and unpriced units, limited to keys in the day's API key breakdown",
               "title": "Api Key Breakdown",
               "type": "object"
             },
             "metadata": {
-              "$ref": "#/components/schemas/GuardrailMetadata"
+              "$ref": "#/components/schemas/GuardrailMetadata",
+              "description": "Guardrail name information"
             },
             "metrics": {
-              "$ref": "#/components/schemas/GuardrailSpendMetrics"
+              "$ref": "#/components/schemas/GuardrailSpendMetrics",
+              "description": "Guardrail spend and unpriced units across all matching API keys"
             }
           },
           "required": [
@@ -3865,11 +3872,13 @@
           "properties": {
             "spend": {
               "default": 0.0,
+              "description": "Guardrail spend in USD, already included in key and model spend",
               "title": "Spend",
               "type": "number"
             },
             "untracked_units": {
               "default": 0,
+              "description": "Guardrail units with no known price, excluded from spend",
               "title": "Untracked Units",
               "type": "integer"
             }
diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py
index b8d9530d2eb..79a46ef355e 100644
--- a/litellm/proxy/auth/auth_checks.py
+++ b/litellm/proxy/auth/auth_checks.py
@@ -84,6 +84,7 @@ from litellm.proxy._types import (
     UserAPIKeyAuth,
 )
 from litellm.proxy.agent_endpoints.auth.agent_access_groups import (
+    AgentAccessGroupCeiling,
     CeilingResolver,
     resolve_agent_access_group_ceiling,
 )
@@ -1684,6 +1685,7 @@ def get_actual_routes(allowed_routes: list) -> list:
 
 KEY_END_USER_BUDGET_ID_METADATA_FIELD: Final = "end_user_budget_id"
 _KEY_METADATA_ADAPTER: Final[TypeAdapter[Mapping[str, object] | None]] = TypeAdapter(Mapping[str, object] | None)
+_OBJECTS_ADAPTER: Final[TypeAdapter[tuple[object, ...]]] = TypeAdapter(tuple[object, ...])
 
 
 def get_key_end_user_budget_id(key_metadata: Mapping[str, object] | None) -> str | None:
@@ -3455,28 +3457,35 @@ async def delete_cache_key_objects(
     proxy_logging_obj: ProxyLogging | None,
 ) -> None:
     """
-    Evict a batch of key objects, for callers that delete keys in bulk rather than through
-    `/key/delete`. Auth resolves a cached key object without re-reading its team, so a key left
-    cached after its row is gone keeps buying access until its TTL expires.
-
-    Evicting locally only reaches this worker; `_delete_cache_key_object` itself broadcasts each
-    token, so a deleted key left in a peer worker's in-memory cache still authenticates there until
-    its TTL expires.
+    Evict a batch of deleted key objects here and on every other worker. Auth resolves a cached key
+    object without re-reading its team, so a key left cached after its row is gone keeps buying
+    access until its TTL expires.
 
     Best-effort per key: the rows are already deleted by the time this runs, so an unreachable
     cache backend must not abort the caller partway through its own cascade.
 
-    Every token is dropped from this worker's memory first, then from the auth cache and the
-    internal usage cache in one batch each, so a deleted key stops authenticating here the instant
-    its rows are gone instead of refilling from Redis on the next miss. Every other worker then
-    gets the eviction in one pipelined broadcast: a publish per key would pass the publisher's
-    pending cap on a bulk delete, and the dropped keys would keep authenticating there until their
-    TTL.
+    Every token is dropped from this worker's memory first, then from the auth cache's Redis layer,
+    so a deleted key stops authenticating here the instant its rows are gone instead of refilling
+    from Redis on the next miss. Every other worker then gets the eviction in one pipelined
+    broadcast: a publish per key would pass the publisher's pending cap on a bulk delete, and the
+    dropped keys would keep authenticating there until their TTL. The internal usage cache is not
+    an auth refill source, so its batch delete runs beside that chain and a hung Redis costs one
+    bounded wait there instead of another in line.
     """
     evict_local(cache_keys=hashed_tokens, user_api_key_cache=user_api_key_cache)
+    usage_eviction: Final = (
+        ()
+        if proxy_logging_obj is None
+        else (evict_shared(cache_keys=hashed_tokens, cache=proxy_logging_obj.internal_usage_cache.dual_cache),)
+    )
+    _ = await asyncio.gather(
+        _evict_auth_cache_then_broadcast(hashed_tokens=hashed_tokens, user_api_key_cache=user_api_key_cache),
+        *usage_eviction,
+    )
+
+
+async def _evict_auth_cache_then_broadcast(hashed_tokens: Sequence[str], user_api_key_cache: UserApiKeyCache) -> None:
     await evict_shared(cache_keys=hashed_tokens, cache=user_api_key_cache)
-    if proxy_logging_obj is not None:
-        await evict_shared(cache_keys=hashed_tokens, cache=proxy_logging_obj.internal_usage_cache.dual_cache)
     await broadcast_evictions(cache_keys=hashed_tokens)
 
 
@@ -5085,6 +5094,36 @@ async def can_agent_call_model(
     )
 
 
+async def _agent_access_group_ceilings(
+    valid_token: UserAPIKeyAuth, resolve_ceiling: CeilingResolver
+) -> tuple[AgentAccessGroupCeiling, ...]:
+    if not valid_token.agent_id:
+        return ()
+
+    from litellm.proxy.agent_endpoints.auth.agent_access_groups import resolve_managed_agent_ceilings
+
+    managed: Final = managed_agent_policy(valid_token)
+    if managed is not None:
+        return await resolve_managed_agent_ceilings(managed)
+    unmanaged: Final = await resolve_ceiling(valid_token.agent_id)
+    return (unmanaged,) if unmanaged is not None else ()
+
+
+def _managed_agent_model_grants(valid_token: UserAPIKeyAuth) -> frozenset[str]:
+    managed: Final = managed_agent_policy(valid_token)
+    granted: Final = (managed.object_permission or {}).get("models") if managed is not None else None
+    if not isinstance(granted, (list, tuple)):
+        return frozenset()
+    return frozenset(name for name in _OBJECTS_ADAPTER.validate_python(granted) if isinstance(name, str))
+
+
+async def agent_model_grants(
+    valid_token: UserAPIKeyAuth, resolve_ceiling: CeilingResolver = resolve_agent_access_group_ceiling
+) -> frozenset[str]:
+    ceilings: Final = await _agent_access_group_ceilings(valid_token, resolve_ceiling)
+    return _managed_agent_model_grants(valid_token).union(*(ceiling.models for ceiling in ceilings))
+
+
 async def _check_agent_access_group_model_access(
     model: str | list[str] | None,  # mutable-ok: _can_object_call_model and the client message helper take list[str]
     valid_token: UserAPIKeyAuth | None,
@@ -5092,20 +5131,9 @@ async def _check_agent_access_group_model_access(
     resolve_ceiling: CeilingResolver = resolve_agent_access_group_ceiling,
 ) -> Literal[True]:
     """Attached groups naming no model deny every model; the empty allowlist in ``_can_object_call_model`` allows."""
-    if not model or valid_token is None or not valid_token.agent_id:
+    if not model or valid_token is None:
         return True
-
-    from litellm.proxy.agent_endpoints.auth.agent_access_groups import resolve_managed_agent_ceilings
-
-    managed: Final = managed_agent_policy(valid_token)
-    unmanaged: Final = await resolve_ceiling(valid_token.agent_id) if managed is None else None
-    ceilings: Final = (
-        await resolve_managed_agent_ceilings(managed)
-        if managed is not None
-        else (unmanaged,)
-        if unmanaged is not None
-        else ()
-    )
+    ceilings: Final = await _agent_access_group_ceilings(valid_token, resolve_ceiling)
     dispatched: Final = _resolve_team_alias(
         model, team_model_aliases_for_auth_check(valid_token), valid_token.team_id, llm_router
     )
diff --git a/litellm/proxy/common_request_processing.py b/litellm/proxy/common_request_processing.py
index a79d8fe29db..762f552dadc 100644
--- a/litellm/proxy/common_request_processing.py
+++ b/litellm/proxy/common_request_processing.py
@@ -60,6 +60,7 @@ from litellm.litellm_core_utils.bug_report import (
     strip_bug_report_notice,
 )
 from litellm.litellm_core_utils.core_helpers import (
+    finite_cost,
     get_or_create_metadata_bucket,
     independent_snapshot,
     is_expected_client_error,
@@ -140,6 +141,7 @@ from litellm.proxy.utils import (  # noqa: F401  # legacy module exports
     _check_and_merge_model_level_guardrails,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]  # backwards-compatible package export
     check_and_merge_model_level_guardrails,
 )
+from litellm.responses.mcp.parked_stream_dispatch import in_flight_round_biller, parked_success
 from litellm.responses.streaming_iterator import partial_responses_incomplete_event_on_disconnect, spawn_logging_task
 from litellm.router import Router
 from litellm.router_api import RoutingContext
@@ -535,6 +537,16 @@ async def _bill_partial_streamed_spend_on_disconnect(request_data: dict, respons
     return await _dispatch_disconnect_billing_event(logging_obj, partial_response)
 
 
+async def _bill_in_flight_round_on_disconnect(request_data: Mapping[str, object]) -> None:
+    bill_in_flight_round: Final = in_flight_round_biller(request_data.get("litellm_logging_obj"))
+    if bill_in_flight_round is None:
+        return
+    try:
+        await bill_in_flight_round()
+    except Exception as e:  # noqa: BLE001  # disconnect billing is best-effort; never break stream teardown
+        verbose_proxy_logger.debug("Failed to bill the in-flight round after client disconnect: %s", e)
+
+
 async def _dispatch_disconnect_billing_event(logging_obj: LiteLLMLoggingObj, partial_response: object) -> bool:
     try:
         await logging_obj.dispatch_success_handlers(
@@ -1801,14 +1813,16 @@ def _get_cost_breakdown_from_logging_obj(
 
 
 def _header_value(value: float | None) -> str | None:
-    return str(value) if value is not None else None
+    return str(value) if finite_cost(value) is not None else None
 
 
 def _response_cost_header_value(hidden_params: Mapping[str, object]) -> float | str:
     if hidden_params.get("cache_hit") is True:
         return 0.0
     response_cost: Final = hidden_params.get("response_cost")
-    return response_cost if isinstance(response_cost, (int, float, str)) and response_cost else ""
+    if isinstance(response_cost, str):
+        return response_cost
+    return response_cost if isinstance(response_cost, int | float) and finite_cost(response_cost) else ""
 
 
 def cost_headers(
@@ -2083,6 +2097,13 @@ class _ClientStreamFailureReport:
             )
 
 
+def _metadata_logged_on(logged_on: LiteLLMLoggingObj) -> Mapping[str, object]:
+    logged_params: Final = object_mapping(logged_on.model_call_details.get("litellm_params")) or MappingProxyType({})
+    return MappingProxyType(
+        {key: logged_params[key] for key in ("metadata", "litellm_metadata") if key in logged_params}
+    )
+
+
 class ProxyBaseLLMRequestProcessing:
     def __init__(self, data: dict, served_model: str | None = None):
         self.data = data
@@ -4151,11 +4172,21 @@ class ProxyBaseLLMRequestProcessing:
             _captured_user_api_key_dict: Final = user_api_key_dict
             _captured_logging_obj: Final = logging_obj
 
-            async def _on_deferred_stream_complete(assembled_response: object, cache_hit: object) -> None:
+            async def _on_deferred_stream_complete(
+                assembled_response: object, cache_hit: object, logged_on: LiteLLMLoggingObj | None = None
+            ) -> None:
                 await ProxyBaseLLMRequestProcessing._run_deferred_stream_guardrails(
-                    captured_data=_captured_data,
+                    captured_data=_captured_data
+                    if logged_on is None
+                    else {
+                        **_captured_data,
+                        **{
+                            key: value for key, value in _metadata_logged_on(logged_on).items() if key in _captured_data
+                        },
+                        "litellm_logging_obj": logged_on,
+                    },
                     captured_user_api_key_dict=_captured_user_api_key_dict,
-                    captured_logging_obj=_captured_logging_obj,
+                    captured_logging_obj=_captured_logging_obj if logged_on is None else logged_on,
                     assembled_response=assembled_response,
                     cache_hit=cache_hit,
                 )
@@ -4180,14 +4211,8 @@ class ProxyBaseLLMRequestProcessing:
                     GLOBAL_LOGGING_WORKER.ensure_initialized_and_enqueue(async_coroutine=logging_coroutine)
                 case (logging_coroutine,) if asyncio.iscoroutine(logging_coroutine):
                     GLOBAL_LOGGING_WORKER.ensure_initialized_and_enqueue(async_coroutine=logging_coroutine)
-                case (assembled_response, cache_hit):
-                    await _as_success_dispatcher(_captured_native_logging_obj).dispatch_success_handlers(
-                        assembled_response,
-                        cache_hit=cache_hit,
-                        start_time=None,
-                        end_time=None,
-                        prefer_async_handlers=True,
-                    )
+                case _ if (success := parked_success(args)) is not None:
+                    await success.dispatch(_captured_native_logging_obj)
                 case _:
                     verbose_proxy_logger.error(
                         "Deferred stream logging dropped: unexpected stored args shape %s",
@@ -4487,7 +4512,7 @@ class ProxyBaseLLMRequestProcessing:
         """
         if isinstance(chunk, dict):
             # Use safe_dumps for proper JSON serialization with circular reference detection
-            chunk_str: Final = safe_dumps(chunk)
+            chunk_str: Final = safe_dumps(chunk, non_finite_as_null=True)
             return f"{STREAM_SSE_DATA_PREFIX}{chunk_str}\n\n"
         else:
             return chunk
@@ -4524,6 +4549,7 @@ class ProxyBaseLLMRequestProcessing:
                     client_disconnected,
                 )
             if recorded_client_disconnect:
+                await _bill_in_flight_round_on_disconnect(_REQUEST_FIELDS.validate_python(request_data))
                 deferred_stream_logging_armed: Final = _deferred_stream_logging_is_armed(request_data)
                 ProxyLogging.fire_deferred_stream_logging(request_data)
                 # A disconnect-time success event (the deferred-guardrail flush
@@ -4862,7 +4888,11 @@ class ProxyBaseLLMRequestProcessing:
                             obj, model_name, litellm_logging_obj
                         )
                         if maybe_modified is not None:
-                            lines[idx] = "data: " + safe_dumps(maybe_modified) + ("\r" if ln.endswith("\r") else "")
+                            lines[idx] = (
+                                "data: "
+                                + safe_dumps(maybe_modified, non_finite_as_null=True)
+                                + ("\r" if ln.endswith("\r") else "")
+                            )
                             return "\n".join(lines)
             return None
         except Exception:
diff --git a/litellm/proxy/common_utils/model_listing_utils.py b/litellm/proxy/common_utils/model_listing_utils.py
index ad4c3bd8770..a9424018d9a 100644
--- a/litellm/proxy/common_utils/model_listing_utils.py
+++ b/litellm/proxy/common_utils/model_listing_utils.py
@@ -219,7 +219,7 @@ def caller_alias_maps(
 
 def alias_map(aliases: object) -> Mapping[str, str]:
     try:
-        entries: Final = _ALIAS_ENTRIES.validate_python(aliases, strict=True)
+        entries: Final = _ALIAS_ENTRIES.validate_python(aliases)
     except ValidationError:
         return _NO_ALIASES
     return MappingProxyType(
@@ -287,6 +287,15 @@ def _dispatch(model_id: str, layers: Sequence[_AliasLayer]) -> tuple[str, bool]:
     return reduce(_through_layer, layers, (model_id, False))
 
 
+def dispatched_model(model_id: str, aliases: CallerAliases) -> str:
+    target, _ = _dispatch(model_id, _alias_layers(aliases))
+    return target
+
+
+def requestable_alias_names(aliases: CallerAliases) -> frozenset[str]:
+    return frozenset(chain.from_iterable(layer.aliases for layer in _alias_layers(aliases)))
+
+
 def _lookup_id(name: str, lookup_by_response: Mapping[str, str], lookup_ids: Container[str]) -> str | None:
     if name in lookup_by_response:
         return lookup_by_response[name]
diff --git a/litellm/proxy/common_utils/openai_error_payload.py b/litellm/proxy/common_utils/openai_error_payload.py
index 53b2a05d40f..a948c390375 100644
--- a/litellm/proxy/common_utils/openai_error_payload.py
+++ b/litellm/proxy/common_utils/openai_error_payload.py
@@ -28,6 +28,8 @@ _OPENAI_ERROR_TYPE_BY_STATUS: Final[Mapping[int, str]] = MappingProxyType(
 
 _AUTH_FAILURE_STATUS_CODES: Final = frozenset({status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN})
 
+_HTTP_ERROR_STATUSES: Final = range(status.HTTP_400_BAD_REQUEST, 600)
+
 _ERROR_BODY: Final = TypeAdapter(dict[str, object])
 
 _FAILOVER_SQLSTATES: Final = frozenset({"25006", "57P01", "57P02", "57P03"})
@@ -47,13 +49,26 @@ def attribute_of(value: object, name: str, default: object = None) -> object:
 
 
 def error_status_code(exc: object, default: int) -> int:
-    """The HTTP status an exception carries as ``status_code`` or, the way ``ProxyException``
-    stores it, as a stringified ``code``; ``default`` when it carries neither."""
-    carried: Final = attribute_of(exc, "status_code")
-    if isinstance(carried, int) and not isinstance(carried, bool):
+    """The 4xx or 5xx HTTP status an exception carries as ``status_code`` (an int or a decimal string) or,
+    the way ``ProxyException`` stores it, as a stringified ``code``; ``default`` when it carries neither."""
+    carried: Final = _http_error_status(attribute_of(exc, "status_code"))
+    if carried is not None:
         return carried
     stringified: Final = attribute_of(exc, "code")
-    return int(stringified) if isinstance(stringified, str) and stringified.isdecimal() else default
+    from_code: Final = _http_error_status(stringified) if isinstance(stringified, str) else None
+    return default if from_code is None else from_code
+
+
+def _http_error_status(value: object) -> int | None:
+    match value:
+        case bool():
+            return None
+        case int() if value in _HTTP_ERROR_STATUSES:
+            return value
+        case str() if len(value) == 3 and value.isascii() and value.isdigit() and int(value) in _HTTP_ERROR_STATUSES:
+            return int(value)
+        case _:
+            return None
 
 
 def openai_error_type(exc: object, status_code: int) -> str:
@@ -105,9 +120,9 @@ def proxy_exception_for(exc: Exception, default_status_code: int) -> ProxyExcept
                 code=status.HTTP_503_SERVICE_UNAVAILABLE,
             )
         case HTTPException(status_code=status_code, detail=detail):
-            return _openai_shaped_proxy_exception(exc, str(detail), status_code)
+            return openai_shaped_proxy_exception(exc, str(detail), status_code)
         case _:
-            return _openai_shaped_proxy_exception(
+            return openai_shaped_proxy_exception(
                 exc, str(exc) or type(exc).__name__, error_status_code(exc, default_status_code)
             )
 
@@ -176,14 +191,19 @@ def _route_failure_error_type(exc: Exception, raised_status: int, answered_statu
     return openai_error_type(exc, answered_status)
 
 
-def _openai_shaped_proxy_exception(exc: Exception, message: str, status_code: int) -> ProxyException:
+def openai_shaped_proxy_exception(exc: Exception, message: str, status_code: int) -> ProxyException:
     answered_status: Final = answered_status_code(message, status_code)
-    return ProxyException(
-        message=message,
-        type=_catch_all_error_type(exc, answered_status),
-        param=openai_error_param(exc),
-        code=answered_status,
-    )
+    return _proxy_exception(exc, message, answered_status, _catch_all_error_type(exc, answered_status))
+
+
+def status_typed_proxy_exception(exc: HTTPException) -> ProxyException:
+    message: Final = str(exc.detail)
+    answered_status: Final = answered_status_code(message, exc.status_code)
+    return _proxy_exception(exc, message, answered_status, openai_error_type(exc, answered_status))
+
+
+def _proxy_exception(exc: Exception, message: str, answered_status: int, error_type: str) -> ProxyException:
+    return ProxyException(message=message, type=error_type, param=openai_error_param(exc), code=answered_status)
 
 
 def _catch_all_error_type(exc: Exception, status_code: int) -> str:
diff --git a/litellm/proxy/db/db_spend_update_writer.py b/litellm/proxy/db/db_spend_update_writer.py
index fe804a82e96..d9fb236632b 100644
--- a/litellm/proxy/db/db_spend_update_writer.py
+++ b/litellm/proxy/db/db_spend_update_writer.py
@@ -34,6 +34,7 @@ from litellm.constants import (
     DB_SPEND_UPDATE_JOB_NAME,
     INTERNAL_CALL_ORIGIN_METADATA_KEY,
 )
+from litellm.litellm_core_utils.core_helpers import finite_cost, single_log_line
 from litellm.litellm_core_utils.litellm_logging import coerce_model_access_groups
 from litellm.litellm_core_utils.safe_json_loads import safe_json_loads
 from litellm.proxy._types import (
@@ -652,7 +653,14 @@ class DBSpendUpdateWriter:
                 end_time=end_time,
                 llm_router=llm_router,
             )
-            payload["spend"] = response_cost or 0.0
+            billable_cost: Final = finite_cost(response_cost)
+            if response_cost is not None and billable_cost is None:
+                verbose_proxy_logger.warning(
+                    "Spend tracking - recording a non-finite response_cost=%s as 0 for request_id=%s",
+                    response_cost,
+                    single_log_line(payload["request_id"]),
+                )
+            payload["spend"] = billable_cost or 0.0
             if isinstance(payload["startTime"], datetime):
                 payload["startTime"] = payload["startTime"].isoformat()
             if isinstance(payload["endTime"], datetime):
@@ -702,7 +710,7 @@ class DBSpendUpdateWriter:
             spawn_logging_task(
                 asyncio.get_running_loop(),
                 self._batch_database_updates(
-                    response_cost=response_cost,
+                    response_cost=billable_cost,
                     user_id=user_id,
                     hashed_token=hashed_token,
                     team_id=team_id,
diff --git a/litellm/proxy/db/db_transaction_queue/redis_update_buffer.py b/litellm/proxy/db/db_transaction_queue/redis_update_buffer.py
index 3a4375ac54a..459f95972ce 100644
--- a/litellm/proxy/db/db_transaction_queue/redis_update_buffer.py
+++ b/litellm/proxy/db/db_transaction_queue/redis_update_buffer.py
@@ -8,7 +8,7 @@ import asyncio
 import json
 from collections.abc import Mapping, Sequence
 from datetime import datetime
-from functools import reduce
+from functools import partial, reduce
 from itertools import chain
 from typing import TYPE_CHECKING, Any, Final, Literal, TypeAlias, TypeVar, cast
 
@@ -109,6 +109,16 @@ _ValueT = TypeVar("_ValueT")
 _DECODED_JSON: Final = TypeAdapter(object)
 
 
+def _zero_for_non_finite_constant(constant: str) -> float:
+    verbose_proxy_logger.warning(
+        "Redis spend buffer - reading a parked %s spend as 0, the spend it held is lost", constant
+    )
+    return 0.0
+
+
+_load_buffered_transaction: Final = partial(json.loads, parse_constant=_zero_for_non_finite_constant)
+
+
 def _spend_log_json_default(value: object) -> str:
     return value.isoformat() if isinstance(value, datetime) else str(value)
 
@@ -118,7 +128,7 @@ def _encode_spend_log_row(row: SpendLogRow) -> str:
 
 
 def _decode_spend_log_row(encoded: str) -> dict[str, object] | None:
-    decoded: Final = _DECODED_JSON.validate_python(json.loads(encoded))
+    decoded: Final = _DECODED_JSON.validate_python(_load_buffered_transaction(encoded))
     return decoded if isinstance(decoded, dict) else None
 
 
@@ -825,13 +835,13 @@ class RedisUpdateBuffer:
             if slot_result is None:
                 daily_results.append(None)
             else:
-                list_of_daily = [json.loads(t) for t in slot_result]
+                list_of_daily = [_load_buffered_transaction(t) for t in slot_result]
                 aggregated = DailySpendUpdateQueue.get_aggregated_daily_spend_update_transactions(list_of_daily)
                 daily_results.append(aggregated)
 
         window_spend: Final = (
             WindowSpendUpdateQueue.get_aggregated_window_spend_transactions(
-                tuple(json.loads(transaction) for transaction in raw_results[6])
+                tuple(_load_buffered_transaction(transaction) for transaction in raw_results[6])
             )
             if raw_results[6] is not None
             else None
@@ -880,7 +890,7 @@ class RedisUpdateBuffer:
         )
         if list_of_transactions is None:
             return None
-        return [json.loads(transaction) for transaction in list_of_transactions]
+        return [_load_buffered_transaction(transaction) for transaction in list_of_transactions]
 
     async def get_all_daily_spend_update_transactions_from_redis_buffer(
         self,
@@ -1010,9 +1020,9 @@ class RedisUpdateBuffer:
         Parses the list of transactions from Redis
         """
         if isinstance(list_of_transactions, list):
-            return [json.loads(transaction) for transaction in list_of_transactions]
+            return [_load_buffered_transaction(transaction) for transaction in list_of_transactions]
         else:
-            return [json.loads(list_of_transactions)]
+            return [_load_buffered_transaction(list_of_transactions)]
 
     @staticmethod
     def _combine_list_of_transactions(
diff --git a/litellm/proxy/guardrails/guardrail_endpoints.py b/litellm/proxy/guardrails/guardrail_endpoints.py
index a5822bfb0e3..363b9162e00 100644
--- a/litellm/proxy/guardrails/guardrail_endpoints.py
+++ b/litellm/proxy/guardrails/guardrail_endpoints.py
@@ -22,6 +22,7 @@ from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
 from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
 from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
 from litellm.proxy.common_utils.callback_utils import CALLBACK_VAR_ENCRYPTED_PREFIX
+from litellm.proxy.common_utils.openai_error_payload import status_typed_proxy_exception
 from litellm.proxy.common_utils.path_utils import is_within, safe_join
 from litellm.proxy.guardrails.content_filter_data import CATEGORIES_DIR, DATA_ROOTS, category_dirs, find_category_file
 from litellm.proxy.guardrails.guardrail_hooks.custom_code.bounded_execution import (
@@ -2533,7 +2534,7 @@ async def apply_guardrail(
                 e = transformed_exception
         except Exception:
             verbose_proxy_logger.exception("apply_guardrail: post_call_failure_hook failed")
-        raise handle_exception_on_proxy(e)
+        raise handle_exception_on_proxy(status_typed_proxy_exception(e) if isinstance(e, HTTPException) else e)
 
     # Success logging outside except so a hook error never triggers failure handlers.
     response = await _emit_guardrail_success_logs(
diff --git a/litellm/proxy/health_endpoints/_health_endpoints.py b/litellm/proxy/health_endpoints/_health_endpoints.py
index 59c63a18f0f..8545e0609db 100644
--- a/litellm/proxy/health_endpoints/_health_endpoints.py
+++ b/litellm/proxy/health_endpoints/_health_endpoints.py
@@ -7,13 +7,15 @@ import secrets
 import time
 import traceback
 from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
+from itertools import chain, groupby
 from types import MappingProxyType
 from typing import Final, Literal, TypedDict
 
 import fastapi
 from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
-from pydantic import TypeAdapter
+from pydantic import BaseModel, ConfigDict, TypeAdapter
 from typing_extensions import ReadOnly
 
 import litellm
@@ -31,7 +33,9 @@ from litellm.proxy._types import (
     CallInfo,
     EnterpriseLicenseData,
     Litellm_EntityType,
+    LiteLLM_UserTable,
     LitellmUserRoles,
+    ModelAccessDeniedProxyException,
     ProxyException,
     SpecialModelNames,
     UserAPIKeyAuth,
@@ -39,13 +43,28 @@ from litellm.proxy._types import (
 )
 from litellm.proxy.auth.auth_checks import (
     _resolve_key_models_for_auth_check,  # pyright: ignore[reportPrivateUsage]  # the auth layer's sentinel resolution, reused so /health scopes exactly like a request
+    agent_model_grants,
+    can_agent_call_model,
+    can_key_call_resolved_model,
+    can_user_call_model,
+    get_user_object,
+    key_model_aliases_for_auth_check,
+    model_matches_any_wildcard_pattern_in_list,
+    team_model_aliases_for_auth_check,
+)
+from litellm.proxy.auth.auth_exception_handler import (
+    _as_proxy_exception,  # pyright: ignore[reportPrivateUsage]  # one auth-failure mapping, shared with user_api_key_auth
 )
 from litellm.proxy.auth.auth_utils import (
     _BANNED_REQUEST_BODY_PARAMS,  # pyright: ignore[reportPrivateUsage]  # one canonical list, shared with the request-body check
 )
-from litellm.proxy.auth.model_checks import get_key_models
 from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
 from litellm.proxy.common_utils import http_parsing_utils
+from litellm.proxy.common_utils.model_listing_utils import (
+    CallerAliases,
+    dispatched_model,
+    requestable_alias_names,
+)
 from litellm.proxy.common_utils.openai_error_payload import proxy_exception_for
 from litellm.proxy.db.db_lookup_gate import db_lookup_stall_tracker
 from litellm.proxy.db.exception_handler import PrismaDBExceptionHandler
@@ -79,6 +98,7 @@ from litellm.router_utils.clientside_credential_handler import (
     _ADMIN_CONFIG_FIELDS_TO_CLEAR_ON_BASE_OVERRIDE,  # pyright: ignore[reportPrivateUsage]  # one canonical list, shared with the router path
     clientside_credential_keys,
 )
+from litellm.router_utils.common_utils import resolve_model_group_alias
 from litellm.secret_managers.main import get_secret_bool
 from litellm.types.proxy.litellm_pre_call_utils import RedactedDict, SecretFields
 from litellm.types.router import reject_server_owned_wif_fields
@@ -253,6 +273,28 @@ def get_callback_identifier(callback):
 
 router: Final = APIRouter()
 _OBJECT_MAPPING: Final = TypeAdapter(Mapping[str, object])
+_OBJECTS: Final = TypeAdapter(tuple[object, ...])
+_DEPLOYMENTS: Final = TypeAdapter(tuple[Mapping[str, object], ...])
+
+
+class _ModelGrants(BaseModel):
+    model_config = ConfigDict(frozen=True, from_attributes=True)
+
+    models: tuple[object, ...] = ()
+
+
+class _ModelInfoAccessGroups(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    access_groups: tuple[object, ...]
+
+
+class _DeploymentAccessGroups(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    model_info: _ModelInfoAccessGroups
+
+
 services = (
     Literal[
         "slack_budget_alerts",
@@ -1045,42 +1087,339 @@ def _strip_admin_only_fields_from_health_result(result: dict) -> dict:
     return out
 
 
-def _health_accessible_model_names(
-    user_api_key_dict: UserAPIKeyAuth, llm_router: Router | None
-) -> frozenset[str] | None:
-    """Model names the caller may health-check, or None when the key is unrestricted."""
+def _key_models_unrestricted(user_api_key_dict: UserAPIKeyAuth) -> bool:
     granted_models: Final = _resolve_key_models_for_auth_check(user_api_key_dict)
-    if not granted_models or SpecialModelNames.all_proxy_models.value in granted_models:
+    return not granted_models or SpecialModelNames.all_proxy_models.value in granted_models
+
+
+def _own_team_names(deployment: object, team_id: str | None) -> tuple[str, str] | None:
+    match deployment:
+        case {
+            "model_name": str(internal_name),
+            "model_info": {"team_id": str(owner_team_id), "team_public_model_name": str(public_name)},
+        } if owner_team_id == team_id:
+            return (internal_name, public_name)
+        case _:
+            return None
+
+
+def _names_caller_may_request(deployment: object, team_id: str | None) -> frozenset[str]:
+    team_names: Final = _own_team_names(deployment, team_id)
+    if team_names is not None:
+        return frozenset(team_names)
+    match deployment:
+        case {"model_name": str(name)}:
+            return frozenset((name,))
+        case _:
+            return frozenset()
+
+
+def _public_names_by_internal_name(llm_model_list: Sequence[object], team_id: str | None) -> Mapping[str, str]:
+    team_names: Final = (_own_team_names(deployment, team_id) for deployment in llm_model_list)
+    return MappingProxyType(dict(names for names in team_names if names is not None))
+
+
+async def _key_owner(user_api_key_dict: UserAPIKeyAuth) -> LiteLLM_UserTable | None:
+    if user_api_key_dict.team_id is not None or user_api_key_dict.user_id is None:
         return None
+    from litellm.proxy.proxy_server import prisma_client, proxy_logging_obj, user_api_key_cache
+
+    try:
+        return await get_user_object(
+            user_id=user_api_key_dict.user_id,
+            prisma_client=prisma_client,
+            user_api_key_cache=user_api_key_cache,
+            user_id_upsert=False,
+            parent_otel_span=user_api_key_dict.parent_otel_span,
+            proxy_logging_obj=proxy_logging_obj,
+        )
+    except Exception:  # noqa: BLE001  # auth reads an unloadable user as no user limit, so /health does too
+        return None
+
+
+async def _key_may_call_model(
+    model_name: str,
+    user_api_key_dict: UserAPIKeyAuth,
+    owner: LiteLLM_UserTable | None,
+    llm_router: Router | None,
+) -> bool:
+    from litellm.proxy.proxy_server import prisma_client, proxy_logging_obj, user_api_key_cache
+
+    await asyncio.sleep(0)
+    try:
+        await can_key_call_resolved_model(
+            model=model_name, llm_model_list=None, valid_token=user_api_key_dict, llm_router=llm_router
+        )
+        await can_agent_call_model(
+            model=model_name,
+            valid_token=user_api_key_dict,
+            llm_router=llm_router,
+            prisma_client=prisma_client,
+            user_api_key_cache=user_api_key_cache,
+            proxy_logging_obj=proxy_logging_obj,
+        )
+        await can_user_call_model(
+            model=model_name,
+            llm_router=llm_router,
+            user_object=owner,
+            key_model_aliases=key_model_aliases_for_auth_check(user_api_key_dict),
+        )
+    except ModelAccessDeniedProxyException:
+        return False
+    except ProxyException:
+        raise
+    except Exception as failure:
+        if isinstance(failure, HTTPException) and failure.status_code == status.HTTP_403_FORBIDDEN:
+            return False
+        raise _as_proxy_exception(failure) from failure
+    return True
+
+
+async def _caller_aliases(user_api_key_dict: UserAPIKeyAuth) -> CallerAliases:
+    from litellm.proxy.proxy_server import prisma_client, proxy_config, proxy_logging_obj
+
+    router_settings: Final = await proxy_config.get_hierarchical_router_settings(
+        user_api_key_dict, prisma_client, proxy_logging_obj
+    )
+    return CallerAliases(
+        team_model_aliases_for_auth_check(user_api_key_dict),
+        key_model_aliases_for_auth_check(user_api_key_dict),
+        router_settings.get("model_group_alias") if router_settings is not None else None,
+    )
+
+
+def _model_auth_checks(model_name: str, aliases: CallerAliases) -> str:
+    return resolve_model_group_alias(aliases.router, model_name) or model_name
+
+
+def _deployment_id(deployment: object) -> str | None:
+    match deployment:
+        case {"model_info": {"id": str(model_id)}}:
+            return model_id
+        case _:
+            return None
+
+
+def _granted_names(user_api_key_dict: UserAPIKeyAuth) -> frozenset[str]:
+    grants: Final = (
+        *_ModelGrants.model_validate(user_api_key_dict).models,
+        *_OBJECTS.validate_python(user_api_key_dict.team_models),
+    )
+    return frozenset(name for name in grants if isinstance(name, str))
+
+
+async def _names_any_limit_grants(user_api_key_dict: UserAPIKeyAuth, owner: LiteLLM_UserTable | None) -> frozenset[str]:
+    owner_grants: Final = _ModelGrants.model_validate(owner).models if owner is not None else ()
+    return (
+        _granted_names(user_api_key_dict)
+        | frozenset(name for name in owner_grants if isinstance(name, str))
+        | await agent_model_grants(user_api_key_dict)
+    )
+
+
+def _alias_names_caller_may_request(aliases: CallerAliases, llm_router: Router | None) -> frozenset[str]:
+    router_aliases: Final = frozenset(llm_router.registry().aliases()) if llm_router is not None else frozenset[str]()
+    return requestable_alias_names(aliases) | router_aliases
+
+
+def _served_group(model_name: str, aliases: CallerAliases, llm_router: Router | None) -> str:
+    dispatched: Final = dispatched_model(model_name, aliases)
+    return llm_router.registry().resolve(dispatched) if llm_router is not None else dispatched
+
+
+def _name_id_pairs(deployment: object, team_id: str | None) -> tuple[tuple[str, str], ...]:
+    model_id: Final = _deployment_id(deployment)
+    if model_id is None:
+        return ()
+    return tuple((name, model_id) for name in _names_caller_may_request(deployment, team_id) | {model_id})
+
+
+def _ids_by_requested_name(llm_model_list: Sequence[object], team_id: str | None) -> Mapping[str, frozenset[str]]:
+    pairs: Final = sorted(chain.from_iterable(_name_id_pairs(deployment, team_id) for deployment in llm_model_list))
+    return MappingProxyType(
+        {name: frozenset(model_id for _, model_id in group) for name, group in groupby(pairs, key=lambda pair: pair[0])}
+    )
+
+
+def _ids_of(deployments: Iterable[object]) -> frozenset[str]:
+    return frozenset(model_id for model_id in map(_deployment_id, deployments) if model_id is not None)
+
+
+def _access_groups_of(deployment: object) -> frozenset[str]:
+    match deployment:
+        case {"model_info": {"access_groups": list()}}:
+            access_groups: Final = _DeploymentAccessGroups.model_validate(deployment).model_info.access_groups
+            return frozenset(access_group for access_group in access_groups if isinstance(access_group, str))
+        case _:
+            return frozenset()
+
+
+@dataclass(frozen=True, slots=True)
+class _AccessGroupGrants:
+    granted_names: frozenset[str]
+    ids_in_granted_groups: frozenset[str]
+
+    def requested_name(self, name: str, public_names: Mapping[str, str], admitted_names: frozenset[str]) -> str:
+        public_name: Final = public_names.get(name)
+        if public_name is None or public_name not in admitted_names or self._grants(name):
+            return name
+        return public_name
+
+    def _grants(self, name: str) -> bool:
+        return name in self.granted_names or model_matches_any_wildcard_pattern_in_list(name, tuple(self.granted_names))
+
+    def narrow(self, serving_ids: frozenset[str], served_names: frozenset[str]) -> frozenset[str]:
+        in_granted_groups: Final = serving_ids & self.ids_in_granted_groups
+        granted_directly: Final = not self.granted_names.isdisjoint(served_names)
+        return serving_ids if granted_directly or not in_granted_groups else in_granted_groups
+
+
+def _access_group_grants(llm_model_list: Sequence[object], user_api_key_dict: UserAPIKeyAuth) -> _AccessGroupGrants:
+    granted: Final = _granted_names(user_api_key_dict)
+    in_granted_groups: Final = (
+        deployment for deployment in llm_model_list if not granted.isdisjoint(_access_groups_of(deployment))
+    )
+    return _AccessGroupGrants(granted, _ids_of(in_granted_groups))
+
+
+def _ids_serving_group(
+    group: str,
+    ids_by_name: Mapping[str, frozenset[str]],
+    user_api_key_dict: UserAPIKeyAuth,
+    llm_router: Router | None,
+    access_group_grants: _AccessGroupGrants,
+) -> frozenset[str]:
+    named: Final = ids_by_name.get(group)
+    if named is not None:
+        return access_group_grants.narrow(named, frozenset((group,)))
     if llm_router is None:
-        return frozenset(granted_models)
-    registry: Final = llm_router.registry()
+        return frozenset()
+    team_id: Final = user_api_key_dict.team_id
+    wildcard_served: Final = llm_router.registry().deployments(group, source="wildcard", team_id=team_id)
+    served_names: Final = frozenset((group,)).union(
+        *(_names_caller_may_request(deployment, team_id) for deployment in wildcard_served)
+    )
+    return access_group_grants.narrow(_ids_of(wildcard_served), served_names)
+
+
+async def _names_key_may_request(
+    names: Iterable[str],
+    aliases: CallerAliases,
+    user_api_key_dict: UserAPIKeyAuth,
+    owner: LiteLLM_UserTable | None,
+    llm_router: Router | None,
+) -> frozenset[str]:
     return frozenset(
-        get_key_models(
-            user_api_key_dict=user_api_key_dict,
-            proxy_model_list=registry.names(team_id=user_api_key_dict.team_id),
-            model_access_groups=registry.access_groups(),
+        [
+            name
+            for name in names
+            if await _key_may_call_model(_model_auth_checks(name, aliases), user_api_key_dict, owner, llm_router)
+        ]
+    )
+
+
+def _ids_serving(
+    groups: Iterable[str],
+    ids_by_name: Mapping[str, frozenset[str]],
+    user_api_key_dict: UserAPIKeyAuth,
+    llm_router: Router | None,
+    access_group_grants: _AccessGroupGrants,
+) -> frozenset[str]:
+    return frozenset[str]().union(
+        *(
+            _ids_serving_group(group, ids_by_name, user_api_key_dict, llm_router, access_group_grants)
+            for group in groups
         )
     )
 
 
-def _caller_may_probe_deployment(
-    deployment: Mapping[str, object],
-    allowed_models: frozenset[str] | None,
+def _shadowed_ids(
+    llm_model_list: Sequence[object], admitted_names: frozenset[str], reached_ids: frozenset[str], team_id: str | None
+) -> frozenset[str]:
+    ids_of_admitted_names: Final = (
+        _deployment_id(deployment)
+        for deployment in llm_model_list
+        if not admitted_names.isdisjoint(_names_caller_may_request(deployment, team_id))
+    )
+    return frozenset(model_id for model_id in ids_of_admitted_names if model_id is not None) - reached_ids
+
+
+@dataclass(frozen=True, slots=True)
+class _ReachableDeployments:
+    model_ids: frozenset[str]
+    groups: frozenset[str]
+
+    def include(self, deployment: object, team_id: str | None) -> bool:
+        model_id: Final = _deployment_id(deployment)
+        if model_id is None:
+            return not self.groups.isdisjoint(_names_caller_may_request(deployment, team_id))
+        return model_id in self.model_ids
+
+
+_NOTHING_REACHABLE: Final = _ReachableDeployments(frozenset(), frozenset())
+
+
+async def _deployments_key_may_reach(
+    llm_model_list: Sequence[object],
+    aliases: CallerAliases,
+    user_api_key_dict: UserAPIKeyAuth,
+    owner: LiteLLM_UserTable | None,
     llm_router: Router | None,
+) -> _ReachableDeployments:
+    candidate_names: Final = (await _names_any_limit_grants(user_api_key_dict, owner)).union(
+        _alias_names_caller_may_request(aliases, llm_router),
+        *(_names_caller_may_request(deployment, user_api_key_dict.team_id) for deployment in llm_model_list),
+    )
+    admitted_names: Final = await _names_key_may_request(candidate_names, aliases, user_api_key_dict, owner, llm_router)
+    access_group_grants: Final = _access_group_grants(llm_model_list, user_api_key_dict)
+    public_names: Final = _public_names_by_internal_name(llm_model_list, user_api_key_dict.team_id)
+    groups: Final = frozenset(
+        _served_group(access_group_grants.requested_name(name, public_names, admitted_names), aliases, llm_router)
+        for name in admitted_names
+    )
+    ids_by_name: Final = _ids_by_requested_name(llm_model_list, user_api_key_dict.team_id)
+    reached_ids: Final = _ids_serving(groups, ids_by_name, user_api_key_dict, llm_router, access_group_grants)
+    admitted_ids: Final = await _names_key_may_request(
+        _shadowed_ids(llm_model_list, admitted_names, reached_ids, user_api_key_dict.team_id),
+        aliases,
+        user_api_key_dict,
+        owner,
+        llm_router,
+    )
+    id_groups: Final = frozenset(_served_group(model_id, aliases, llm_router) for model_id in admitted_ids)
+    return _ReachableDeployments(
+        reached_ids | _ids_serving(id_groups, ids_by_name, user_api_key_dict, llm_router, access_group_grants), groups
+    )
+
+
+def _model_param_target(
+    model: str,
+    aliases: CallerAliases,
+    llm_model_list: Sequence[Mapping[str, object]],
     team_id: str | None,
-    caller_is_admin: bool,
+    llm_router: Router | None,
+) -> str:
+    group: Final = _served_group(model, aliases, llm_router)
+    if llm_router is None or deployments_targeted_by_name(llm_model_list, group, team_id):
+        return group
+    patterns: Final = frozenset(
+        deployment.get("model_name")
+        for deployment in llm_router.registry().deployments(group, source="wildcard", team_id=team_id)
+    )
+    match tuple(patterns):
+        case (str(pattern),):
+            return pattern
+        case _:
+            return group
+
+
+def _caller_may_probe_deployment(
+    deployment: Mapping[str, object], reachable: _ReachableDeployments, team_id: str | None, caller_is_admin: bool
 ) -> bool:
     """Same deployment visibility rule as routing: another team's deployment is never in scope, team-less callers included."""
     if not caller_is_admin and not deployment_usable_by_team(deployment, team_id):
         return False
-    if allowed_models is None:
-        return True
-    if llm_router is None:
-        return deployment.get("model_name") in allowed_models
-    model: Final = dict(deployment)
-    registry: Final = llm_router.registry()
-    return any(registry.includes(model, model_name=name, team_id=team_id) for name in allowed_models)
+    return reachable.include(deployment, team_id)
 
 
 def _resolve_targeted_model_ids(
@@ -1137,6 +1476,7 @@ def _filter_health_check_results_by_model_ids(results: dict, allowed_model_ids:
 async def _perform_health_check_and_save(
     model_list,
     target_model,
+    recorded_model_name: str | None,
     cli_model,
     details,
     prisma_client,
@@ -1159,8 +1499,7 @@ async def _perform_health_check_and_save(
 
     # Optionally save health check result to database (non-blocking)
     if prisma_client is not None:
-        # For CLI model, use cli_model name; for router models, use target_model
-        model_name_for_db: Final = cli_model if cli_model is not None else target_model
+        model_name_for_db: Final = cli_model if cli_model is not None else recorded_model_name
         if model_name_for_db is not None:
             asyncio.create_task(
                 _save_health_check_to_db(
@@ -1290,6 +1629,7 @@ async def health_endpoint(
                 cli_result: Final = await _perform_health_check_and_save(
                     model_list=[],
                     target_model=None,
+                    recorded_model_name=None,
                     cli_model=user_model,
                     details=health_check_details,
                     prisma_client=prisma_client,
@@ -1304,15 +1644,39 @@ async def health_endpoint(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                 detail={"error": "Model list not initialized"},
             )
-        allowed_models: Final = _health_accessible_model_names(user_api_key_dict, llm_router)
-        restrict_to_allowed_models: Final = not is_admin or allowed_models is not None
+        restrict_to_allowed_models: Final = not is_admin or not _key_models_unrestricted(user_api_key_dict)
+        aliases: Final = await _caller_aliases(user_api_key_dict) if restrict_to_allowed_models else None
+        reachable: Final = (
+            await _deployments_key_may_reach(
+                _OBJECTS.validate_python(llm_model_list),
+                aliases,
+                user_api_key_dict,
+                await _key_owner(user_api_key_dict),
+                llm_router,
+            )
+            if aliases is not None
+            else _NOTHING_REACHABLE
+        )
+        requested_model: Final = (
+            _model_param_target(
+                model,
+                aliases,
+                _DEPLOYMENTS.validate_python(llm_model_list),
+                user_api_key_dict.team_id,
+                llm_router,
+            )
+            if model is not None and aliases is not None
+            else model
+        )
         _llm_model_list: Final = [
             m
             for m in copy.deepcopy(llm_model_list)
             if not restrict_to_allowed_models
-            or _caller_may_probe_deployment(m, allowed_models, llm_router, user_api_key_dict.team_id, is_admin)
+            or _caller_may_probe_deployment(m, reachable, user_api_key_dict.team_id, is_admin)
         ]
-        targeted_ids: Final = _resolve_targeted_model_ids(_llm_model_list, model, model_id, user_api_key_dict.team_id)
+        targeted_ids: Final = _resolve_targeted_model_ids(
+            _llm_model_list, requested_model, model_id, user_api_key_dict.team_id
+        )
         if restrict_to_allowed_models and targeted_ids is not None and not targeted_ids:
             raise HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
@@ -1370,7 +1734,8 @@ async def health_endpoint(
         else:
             router_result: Final = await _perform_health_check_and_save(
                 model_list=_llm_model_list,
-                target_model=target_model,
+                target_model=target_model if model_id else requested_model,
+                recorded_model_name=target_model,
                 cli_model=None,
                 details=health_check_details,
                 prisma_client=prisma_client,
diff --git a/litellm/proxy/hooks/proxy_track_cost_callback.py b/litellm/proxy/hooks/proxy_track_cost_callback.py
index 9c4a4bc775b..0d333d4fd08 100644
--- a/litellm/proxy/hooks/proxy_track_cost_callback.py
+++ b/litellm/proxy/hooks/proxy_track_cost_callback.py
@@ -16,6 +16,7 @@ from litellm.constants import BACKGROUND_INTERACTION_COST_POLLING_ENABLED, BILLE
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.litellm_core_utils.core_helpers import (
     budget_reservation_from_metadata,
+    finite_cost,
     get_litellm_metadata_from_kwargs,
     get_metadata_variable_name_from_kwargs,
     get_parent_otel_span_from_kwargs,
@@ -703,7 +704,7 @@ class _ProxyDBLogger(CustomLogger):
             raw_cost: Final = _str_keyed_fields(
                 sl_object if sl_object is not None else kwargs  # pyright: ignore[reportUnknownArgumentType]  # untyped success-callback payload
             ).get("response_cost")
-            priced_cost: Final = raw_cost if isinstance(raw_cost, (int, float)) else None
+            priced_cost: Final = finite_cost(raw_cost)
             response_cost: Final = (
                 await apply_search_free_tier(
                     kwargs=kwargs,  # pyright: ignore[reportUnknownArgumentType]  # untyped success-callback payload
diff --git a/litellm/proxy/management_endpoints/daily_activity_scopes.py b/litellm/proxy/management_endpoints/daily_activity_scopes.py
index ca1a96f9d84..7ff73ac6e2e 100644
--- a/litellm/proxy/management_endpoints/daily_activity_scopes.py
+++ b/litellm/proxy/management_endpoints/daily_activity_scopes.py
@@ -216,7 +216,11 @@ def _user_query(
     start_date: str | None = Query(default=None, description="Start date in YYYY-MM-DD format"),
     end_date: str | None = Query(default=None, description="End date in YYYY-MM-DD format"),
     model: str | None = Query(default=None, description="Filter by specific model"),
-    api_key: str | None = Query(default=None, description="Filter by specific API key"),
+    api_key: str | None = Query(
+        default=None,
+        description="Filter by reporting API key ID. Missing keys are reported as unattributed. "
+        "For a literal key unattributed or a key starting with raw:, add an extra raw: prefix",
+    ),
     user_id: str | None = Query(
         default=None,
         description="Filter by specific user ID. Admins can filter by any user or omit for global view. "
diff --git a/litellm/proxy/management_endpoints/internal_user_endpoints.py b/litellm/proxy/management_endpoints/internal_user_endpoints.py
index 6950cf08a25..54a2d4062d2 100644
--- a/litellm/proxy/management_endpoints/internal_user_endpoints.py
+++ b/litellm/proxy/management_endpoints/internal_user_endpoints.py
@@ -2922,7 +2922,8 @@ async def get_user_daily_activity(
     ),
     api_key: str | None = fastapi.Query(
         default=None,
-        description="Filter by specific API key",
+        description="Filter by reporting API key ID. Missing keys are reported as unattributed. "
+        "For a literal key unattributed or a key starting with raw:, add an extra raw: prefix",
     ),
     user_id: str | None = fastapi.Query(
         default=None,
diff --git a/litellm/proxy/management_endpoints/key_management_endpoints.py b/litellm/proxy/management_endpoints/key_management_endpoints.py
index a6814b593ca..3021b21de51 100644
--- a/litellm/proxy/management_endpoints/key_management_endpoints.py
+++ b/litellm/proxy/management_endpoints/key_management_endpoints.py
@@ -50,6 +50,7 @@ from litellm.proxy.auth.auth_checks import (  # noqa: F401  # legacy module expo
     _delete_cache_key_object,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]  # backwards-compatible package export
     can_team_access_model,
     delete_cache_key_object,
+    delete_cache_key_objects,
     get_jwt_key_mapping_cache_keys_for_token,
     get_key_end_user_budget_id,
     get_org_object,
@@ -78,7 +79,7 @@ from litellm.proxy.common_utils.config_sync_pubsub import (
 from litellm.proxy.common_utils.openai_error_payload import openai_error_param, proxy_exception_for
 from litellm.proxy.common_utils.rbac_utils import check_org_admin_can_generate_keys
 from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time
-from litellm.proxy.common_utils.user_api_key_cache import AUTH_OBJECTS_TARGET, UserApiKeyCache
+from litellm.proxy.common_utils.user_api_key_cache import AUTH_OBJECTS_TARGET, UserApiKeyCache, is_user_key_cache_key
 from litellm.proxy.hooks.key_management_event_hooks import KeyManagementEventHooks
 from litellm.proxy.hooks.model_max_budget_limiter import build_model_max_budget_usage
 from litellm.proxy.management.teams.authz import TEAM_ADMIN_ONLY, TEAM_OR_ORG_ADMIN, is_team_admin
@@ -5483,7 +5484,7 @@ async def delete_verification_tokens(
                 - List of keys being deleted, this contains information about the key_alias, token, and user_id being deleted,
                 this is passed down to the KeyManagementEventHooks to delete the keys from the secret manager and handle audit logs
     """
-    from litellm.proxy.proxy_server import prisma_client
+    from litellm.proxy.proxy_server import prisma_client, proxy_logging_obj
 
     failed_tokens: list = []
     try:
@@ -5567,11 +5568,11 @@ async def delete_verification_tokens(
         verbose_proxy_logger.debug(traceback.format_exc())
         raise e
 
-    for key in tokens:
-        user_api_key_cache.delete_cache(key)
-        # remove hash token from cache
-        hashed_token = hash_token(cast(str, key))
-        user_api_key_cache.delete_cache(hashed_token)
+    await delete_cache_key_objects(
+        hashed_tokens=tuple(token for token in hashed_tokens if is_user_key_cache_key(token)),
+        user_api_key_cache=user_api_key_cache,
+        proxy_logging_obj=proxy_logging_obj,
+    )
 
     # After credential invalidation, so a failure here can never keep a deleted key alive.
     for deleted_key in authorized_keys:
diff --git a/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py b/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py
index 21078dfc848..33b18c3d939 100644
--- a/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py
+++ b/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py
@@ -32,6 +32,7 @@ from typing_extensions import ReadOnly, TypedDict
 import litellm
 from litellm import get_llm_provider
 from litellm._logging import verbose_proxy_logger
+from litellm._uuid import uuid
 from litellm.constants import (
     ALLOWED_VERTEX_AI_PASSTHROUGH_HEADERS,
     AWS_ERROR_TYPE_HEADER,
@@ -72,6 +73,7 @@ from litellm.llms.openai.common_utils import is_openai_agents_api_path, openai_a
 from litellm.llms.openai.workload_identity import get_workload_identity_bearer_token_for_api_base
 from litellm.llms.oss_decision import OssDecisionProvider, oss_connection, validate_oss_request
 from litellm.llms.vertex_ai.vertex_llm_base import VertexBase
+from litellm.llms.vllm.common_utils import endpoint_under_api_base
 from litellm.passthrough.main import AsyncPassthroughStreamingResponse, is_provider_error
 from litellm.proxy._types import *
 from litellm.proxy.auth.auth_checks import enforced_model_allowlists
@@ -148,7 +150,7 @@ from litellm.types.passthrough_endpoints.tinyfish import (
 )
 from litellm.types.passthrough_endpoints.vertex_ai import VertexPassThroughCredentials
 from litellm.types.router import LiteLLMParamsTypedDict
-from litellm.types.utils import LlmProviders
+from litellm.types.utils import CallTypes, LlmProviders
 from litellm.types.vector_stores import LiteLLM_ManagedVectorStore
 from litellm.utils import ProviderConfigManager
 
@@ -600,7 +602,7 @@ async def vllm_proxy_route(
         )
 
     return await llm_passthrough_factory_proxy_route(
-        endpoint=endpoint,
+        endpoint=endpoint_under_api_base(endpoint, get_secret_str("VLLM_API_BASE")),
         request=request,
         fastapi_response=fastapi_response,
         user_api_key_dict=user_api_key_dict,
@@ -4104,7 +4106,12 @@ async def vertex_ai_live_websocket_passthrough(
             await proxy_logging_obj.post_call_failure_hook(
                 user_api_key_dict=user_api_key_dict,
                 original_exception=e,
-                request_data={},
+                request_data={
+                    "model": model or "",
+                    "custom_llm_provider": litellm.LlmProviders.VERTEX_AI.value,
+                    "call_type": CallTypes.pass_through.value,
+                    "litellm_call_id": str(uuid.uuid4()),
+                },
             )
         if websocket.client_state != WebSocketState.DISCONNECTED:
             await websocket.close(code=1011, reason=VERTEX_LIVE_UNCONFIGURED_CLOSE_REASON)
@@ -4139,6 +4146,8 @@ async def vertex_ai_live_websocket_passthrough(
         forward_headers=False,
         endpoint="/vertex_ai/live",
         accept_websocket=False,
+        builtin_provider_route=True,
+        model=model,
         setup_model_rewriter=_build_vertex_live_setup_model_rewriter(
             vertex_project=resolved_project,
             vertex_location=resolved_location,
diff --git a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/gemini_passthrough_logging_handler.py b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/gemini_passthrough_logging_handler.py
index 7a5d5a1e259..d449f62af2c 100644
--- a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/gemini_passthrough_logging_handler.py
+++ b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/gemini_passthrough_logging_handler.py
@@ -1,4 +1,3 @@
-import re
 from collections.abc import Sequence
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Final
@@ -9,6 +8,7 @@ import litellm
 from litellm._logging import verbose_proxy_logger
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.llms.gemini.videos.transformation import GeminiVideoConfig
+from litellm.llms.vertex_ai.common_utils import get_vertex_model_id_from_url
 from litellm.proxy._types import PassThroughEndpointLoggingTypedDict
 from litellm.proxy.pass_through_endpoints.llm_provider_handlers.vertex_passthrough_logging_handler import (
     GeminiSseChunkParser,
@@ -207,11 +207,7 @@ class GeminiPassthroughLoggingHandler:
 
     @staticmethod
     def extract_model_from_url(url: str) -> str:
-        pattern: Final = r"/models/([^:]+)"
-        match: Final = re.search(pattern, url)
-        if match:
-            return match.group(1)
-        return "unknown"
+        return get_vertex_model_id_from_url(url) or "unknown"
 
     @staticmethod
     def _create_gemini_response_logging_payload_for_generate_content(
diff --git a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/vertex_passthrough_logging_handler.py b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/vertex_passthrough_logging_handler.py
index b3cbad91624..d5c162296d3 100644
--- a/litellm/proxy/pass_through_endpoints/llm_provider_handlers/vertex_passthrough_logging_handler.py
+++ b/litellm/proxy/pass_through_endpoints/llm_provider_handlers/vertex_passthrough_logging_handler.py
@@ -3,7 +3,7 @@ import re
 from collections.abc import Mapping, Sequence
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Final, Literal, Protocol, cast
-from urllib.parse import urlparse
+from urllib.parse import parse_qs, urlparse
 
 import httpx
 from pydantic import ConfigDict, TypeAdapter
@@ -19,6 +19,7 @@ from litellm.litellm_core_utils.llm_cost_calc.usage_object_transformation import
 from litellm.llms.vertex_ai.common_utils import (
     get_vertex_ai_lyria_generation_cost,
     get_vertex_location_from_url,
+    get_vertex_model_id_from_url,
 )
 from litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import (
     ModelResponseIterator as VertexModelResponseIterator,
@@ -47,6 +48,19 @@ from litellm.types.utils import (
 )
 
 vertex_search_api_config: Final = VertexSearchAPIVectorStoreConfig()
+GEMINI_API_HOST_SUFFIX: Final = "generativelanguage.googleapis.com"
+GOOGLE_AI_HOST_SUFFIXES: Final = (
+    GEMINI_API_HOST_SUFFIX,
+    "aiplatform.googleapis.com",
+    "discoveryengine.googleapis.com",
+)
+_VERTEX_MULTI_REGION_HOST: Final = re.compile(r"aiplatform\.[a-z0-9-]+\.rep\.googleapis\.com")
+
+
+def _is_host_or_subdomain(hostname: str, suffix: str) -> bool:
+    return hostname == suffix or hostname.endswith((f".{suffix}", f"-{suffix}"))
+
+
 if TYPE_CHECKING:
     from litellm.types.utils import LiteLLMBatch
 
@@ -684,11 +698,18 @@ class VertexPassthroughLoggingHandler:
 
     @staticmethod
     def extract_model_from_url(url: str) -> str:
-        pattern: Final = r"/models/([^:]+)"
-        match: Final = re.search(pattern, url)
-        if match:
-            return match.group(1)
-        return "unknown"
+        return get_vertex_model_id_from_url(url) or "unknown"
+
+    @staticmethod
+    def model_from_url_route(url_route: str) -> str | None:
+        parsed_url: Final = urlparse(url_route)
+        model: Final = get_vertex_model_id_from_url(parsed_url.path)
+        if model is None:
+            return "vertex_ai/search_api" if ":search" in parsed_url.path else None
+        streamed: Final = "sse" in parse_qs(parsed_url.query).get("alt", ())
+        if parsed_url.path.endswith((":rawPredict", ":streamRawPredict")) and not streamed:
+            return f"vertex_ai/{model}"
+        return model
 
     @staticmethod
     def extract_model_name_from_vertex_path(vertex_model_path: str) -> str:
@@ -734,18 +755,32 @@ class VertexPassthroughLoggingHandler:
         return None
 
     @staticmethod
-    def _get_custom_llm_provider(url: str, logging_obj: LiteLLMLoggingObj) -> str:
+    def is_google_ai_url(url: str) -> bool:
         hostname: Final = urlparse(url).hostname
-        if logging_obj.model_call_details.get("custom_llm_provider") == litellm.LlmProviders.GEMINI.value or (
-            hostname is not None
-            and (
-                hostname == "generativelanguage.googleapis.com"
-                or hostname.endswith(".generativelanguage.googleapis.com")
-            )
-        ):
+        return hostname is not None and (
+            any(_is_host_or_subdomain(hostname, suffix) for suffix in GOOGLE_AI_HOST_SUFFIXES)
+            or _VERTEX_MULTI_REGION_HOST.fullmatch(hostname) is not None
+        )
+
+    @staticmethod
+    def is_gemini_api_host(url: str) -> bool:
+        hostname: Final = urlparse(url).hostname
+        return hostname is not None and (
+            hostname == GEMINI_API_HOST_SUFFIX or hostname.endswith(f".{GEMINI_API_HOST_SUFFIX}")
+        )
+
+    @staticmethod
+    def custom_llm_provider_from_url(url: str) -> str:
+        if VertexPassthroughLoggingHandler.is_gemini_api_host(url):
             return litellm.LlmProviders.GEMINI.value
         return litellm.LlmProviders.VERTEX_AI.value
 
+    @staticmethod
+    def _get_custom_llm_provider(url: str, logging_obj: LiteLLMLoggingObj) -> str:
+        if logging_obj.model_call_details.get("custom_llm_provider") == litellm.LlmProviders.GEMINI.value:
+            return litellm.LlmProviders.GEMINI.value
+        return VertexPassthroughLoggingHandler.custom_llm_provider_from_url(url)
+
     @staticmethod
     def _is_multimodal_embedding_response(json_response: dict) -> bool:
         """
diff --git a/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py b/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
index bda2bfb9e04..cfac28db1a9 100644
--- a/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
+++ b/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
@@ -3,6 +3,7 @@ import asyncio
 import copy
 import json
 import posixpath
+import re
 import traceback
 from base64 import b64encode
 from collections.abc import AsyncGenerator, AsyncIterator, Callable, Iterable, Mapping, Sequence
@@ -77,6 +78,7 @@ from litellm.llms.base_llm.managed_resources.utils import (
 from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
 from litellm.llms.eu_jev.common_utils import eu_jev_scoped_model, eu_jev_upstream_body
 from litellm.llms.oss_decision import validate_oss_request
+from litellm.llms.vertex_ai.common_utils import get_vertex_model_id_from_url
 from litellm.passthrough import BasePassthroughUtils
 from litellm.proxy._lazy_features import lazy_owned_routes
 from litellm.proxy._types import (
@@ -147,11 +149,12 @@ from litellm.types.passthrough_endpoints.pass_through_endpoints import (
     EndpointType,
     PassthroughStandardLoggingPayload,
 )
-from litellm.types.utils import TRUSTED_CALLBACK_VARS_FIELD, Usage
+from litellm.types.utils import TRUSTED_CALLBACK_VARS_FIELD, CallTypes, Usage
 
 from .llm_provider_handlers.tinyfish_passthrough_logging_handler import (
     is_tinyfish_agent_url,
 )
+from .llm_provider_handlers.vertex_passthrough_logging_handler import VertexPassthroughLoggingHandler
 from .streaming_handler import PassThroughStreamingHandler
 from .success_handler import PassThroughEndpointLogging
 from .upstream_usage_headers import (
@@ -874,13 +877,45 @@ def _carry_guardrail_logging_info(request_data: dict, guardrail_data: dict | Non
     metadata.setdefault("standard_logging_guardrail_information", list(entries))
 
 
+_GOOGLE_PASSTHROUGH_PROVIDERS: Final = frozenset(
+    (litellm.LlmProviders.GEMINI.value, litellm.LlmProviders.VERTEX_AI.value)
+)
+
+
+def _passthrough_google_provider(url_route: str, custom_llm_provider: str | None) -> str | None:
+    if custom_llm_provider is not None:
+        return custom_llm_provider if custom_llm_provider in _GOOGLE_PASSTHROUGH_PROVIDERS else None
+    if VertexPassthroughLoggingHandler.is_google_ai_url(url_route):
+        return VertexPassthroughLoggingHandler.custom_llm_provider_from_url(url_route)
+    return None
+
+
+_OPERATION_POLL_SUFFIX: Final = re.compile(r"/operations/[^/]+$")
+
+
+def _without_operation_poll_suffix(model: str | None) -> str | None:
+    return _OPERATION_POLL_SUFFIX.sub("", model) if model else model
+
+
+def _passthrough_google_model(url_route: str, google_provider: str | None) -> str | None:
+    match google_provider:
+        case "gemini":
+            return _without_operation_poll_suffix(get_vertex_model_id_from_url(urlparse(url_route).path))
+        case "vertex_ai":
+            return _without_operation_poll_suffix(VertexPassthroughLoggingHandler.model_from_url_route(url_route))
+        case _:
+            return None
+
+
 def _build_passthrough_failure_request_payload(
     parsed_body: dict | None,
     kwargs: dict | None,
     logging_obj: LiteLLMLoggingObj | None,
     custom_llm_provider: str | None,
     upstream_usage: UpstreamReportedUsage | None = None,
+    url: httpx.URL | None = None,
     upstream_model: str | None = None,
+    builtin_provider_route: bool = False,
 ) -> dict:
     """Build the ``request_data`` dict passed to ``post_call_failure_hook``.
 
@@ -893,16 +928,25 @@ def _build_passthrough_failure_request_payload(
     comes paired with a usage object, so both keys are written together.
     ``upstream_model`` is the model name the upstream reported, which replaces
     the body's ``model`` on the failure row just as it does on a success row.
+    ``builtin_provider_route`` lets a Gemini or Vertex URL name the failure's
+    model and provider. A user-defined route never gets that, since its URL
+    names an upstream model rather than a LiteLLM-managed one.
     """
     request_payload: Final[dict] = dict(cast(Mapping[str, object], parsed_body or {}))  # cast-ok: json body
     if kwargs:
         request_payload.update(kwargs)
     if logging_obj is not None:
         request_payload["litellm_logging_obj"] = logging_obj
-    if "model" not in request_payload and parsed_body and isinstance(parsed_body, dict):
-        request_payload["model"] = parsed_body.get("model", "")
-    if "custom_llm_provider" not in request_payload and custom_llm_provider:
-        request_payload["custom_llm_provider"] = custom_llm_provider
+    url_route: Final = str(url) if url is not None else ""
+    google_provider: Final = (
+        _passthrough_google_provider(url_route, custom_llm_provider) if builtin_provider_route else None
+    )
+    if "model" not in request_payload:
+        request_payload["model"] = _passthrough_google_model(url_route, google_provider) or ""
+    resolved_provider: Final = custom_llm_provider or google_provider
+    request_payload.pop("custom_llm_provider", None)
+    if resolved_provider:
+        request_payload["custom_llm_provider"] = resolved_provider
     if upstream_usage is not None:
         request_payload["response_cost"] = upstream_usage.response_cost or 0.0
         request_payload["combined_usage_object"] = Usage(total_tokens=upstream_usage.total_tokens or 0)
@@ -1203,6 +1247,7 @@ async def pass_through_request(
     # Initialize variables
     #########################################################
     litellm_call_id: Final = str(uuid.uuid4())
+    builtin_provider_route: Final = not request_dispatched_to_pass_through_endpoint(request)
     url: httpx.URL | None = None
 
     # parsed request body
@@ -1612,6 +1657,8 @@ async def pass_through_request(
                     logging_obj=logging_obj,
                     custom_llm_provider=custom_llm_provider,
                     upstream_usage=upstream_usage,
+                    url=url,
+                    builtin_provider_route=builtin_provider_route,
                     upstream_model=upstream_model,
                 ),
                 logging_obj=logging_obj,
@@ -1651,6 +1698,8 @@ async def pass_through_request(
                                 kwargs=kwargs,
                                 logging_obj=logging_obj,
                                 custom_llm_provider=custom_llm_provider,
+                                url=url,
+                                builtin_provider_route=builtin_provider_route,
                             ),
                         ),
                         managed_id_provider=_managed_id_provider,
@@ -1710,6 +1759,8 @@ async def pass_through_request(
                     logging_obj=logging_obj,
                     custom_llm_provider=custom_llm_provider,
                     upstream_usage=upstream_usage,
+                    url=url,
+                    builtin_provider_route=builtin_provider_route,
                     upstream_model=upstream_model,
                 ),
                 logging_obj=logging_obj,
@@ -1749,6 +1800,8 @@ async def pass_through_request(
                                 kwargs=kwargs,
                                 logging_obj=logging_obj,
                                 custom_llm_provider=custom_llm_provider,
+                                url=url,
+                                builtin_provider_route=builtin_provider_route,
                             ),
                         ),
                         managed_id_provider=_managed_id_provider,
@@ -1811,6 +1864,8 @@ async def pass_through_request(
             logging_obj=logging_obj,
             custom_llm_provider=custom_llm_provider,
             upstream_usage=upstream_usage,
+            url=url,
+            builtin_provider_route=builtin_provider_route,
             upstream_model=upstream_model,
         )
         failure_request_payload["response_body"] = response_body
@@ -1991,7 +2046,14 @@ async def pass_through_request(
             await proxy_logging_obj.post_call_failure_hook(
                 user_api_key_dict=user_api_key_dict,
                 original_exception=e,
-                request_data=e.request_data,
+                request_data=_build_passthrough_failure_request_payload(
+                    parsed_body=e.request_data,
+                    kwargs={"call_type": CallTypes.pass_through.value, "litellm_call_id": litellm_call_id},
+                    logging_obj=None,
+                    custom_llm_provider=custom_llm_provider,
+                    url=url,
+                    builtin_provider_route=builtin_provider_route,
+                ),
             )
         except Exception:
             verbose_proxy_logger.warning(
@@ -2010,6 +2072,7 @@ async def pass_through_request(
             content=json.dumps(error_body),
             status_code=200,
             media_type="application/json",
+            headers={"x-litellm-call-id": litellm_call_id},
         )
     except Exception as e:
         custom_headers = ProxyBaseLLMRequestProcessing.get_custom_headers(
@@ -2033,19 +2096,14 @@ async def pass_through_request(
         # Monitoring: Trigger post_call_failure_hook
         # for pass through endpoint failure
         #########################################################
-        request_payload: Final[dict] = _parsed_body or {}
-        # add user_api_key_dict, litellm_call_id, passthrough_logging_payloa for logging
-        if kwargs:
-            for key, value in kwargs.items():
-                request_payload[key] = value
-        if logging_obj is not None:
-            request_payload["litellm_logging_obj"] = logging_obj
-
-        if "model" not in request_payload and _parsed_body and isinstance(_parsed_body, dict):
-            request_payload["model"] = _parsed_body.get("model", "")
-        if "custom_llm_provider" not in request_payload and custom_llm_provider:
-            request_payload["custom_llm_provider"] = custom_llm_provider
-
+        request_payload: Final = _build_passthrough_failure_request_payload(
+            parsed_body=_parsed_body,
+            kwargs=kwargs,
+            logging_obj=logging_obj,
+            custom_llm_provider=custom_llm_provider,
+            url=url,
+            builtin_provider_route=builtin_provider_route,
+        )
         _carry_guardrail_logging_info(request_payload, post_call_guardrail_data)
 
         await proxy_logging_obj.post_call_failure_hook(
@@ -2547,6 +2605,8 @@ async def websocket_passthrough_request(
     cost_per_request: float | None = None,
     accept_websocket: bool = True,
     setup_model_rewriter: Callable[[str], str] | None = None,
+    builtin_provider_route: bool = False,
+    model: str | None = None,
 ):
     """
     WebSocket passthrough request handler.
@@ -2560,6 +2620,8 @@ async def websocket_passthrough_request(
         endpoint: The endpoint path (for logging purposes)
         cost_per_request: Optional field - cost per request to the target endpoint
         setup_model_rewriter: Optional rewrite of the setup frame's model before it reaches the upstream
+        builtin_provider_route: Whether a built-in provider route serves the connection, so its URL names the provider
+        model: The model the caller named before connecting, logged on a failure before the setup frame arrives
     """
     from litellm.litellm_core_utils.litellm_logging import Logging
     from litellm.proxy.proxy_server import proxy_config, proxy_logging_obj
@@ -2912,19 +2974,17 @@ async def websocket_passthrough_request(
     except InvalidStatus as exc:
         verbose_proxy_logger.exception("WebSocket passthrough (%s): upstream rejected WebSocket connection", endpoint)
 
-        # Prepare request payload for logging
-        request_payload = {}
-        if kwargs:
-            for key, value in kwargs.items():
-                request_payload[key] = value
-        if logging_obj is not None:
-            request_payload["litellm_logging_obj"] = logging_obj
-
-        # Log the connection failure using the same pattern as HTTP
         await proxy_logging_obj.post_call_failure_hook(
             user_api_key_dict=user_api_key_dict,
             original_exception=exc,
-            request_data=request_payload,
+            request_data=_build_passthrough_failure_request_payload(
+                parsed_body=None if model is None else {"model": model},
+                kwargs=kwargs,
+                logging_obj=logging_obj,
+                custom_llm_provider=None,
+                url=httpx.URL(target),
+                builtin_provider_route=builtin_provider_route,
+            ),
             traceback_str=traceback.format_exc(
                 limit=MAXIMUM_TRACEBACK_LINES_TO_LOG,
             ),
@@ -2940,19 +3000,17 @@ async def websocket_passthrough_request(
             "WebSocket passthrough (%s): unexpected error while proxying WebSocket", endpoint
         )
 
-        # Prepare request payload for logging
-        request_payload = {}
-        if kwargs:
-            for key, value in kwargs.items():
-                request_payload[key] = value
-        if logging_obj is not None:
-            request_payload["litellm_logging_obj"] = logging_obj
-
-        # Log the unexpected error using the same pattern as HTTP
         await proxy_logging_obj.post_call_failure_hook(
             user_api_key_dict=user_api_key_dict,
             original_exception=e,
-            request_data=request_payload,
+            request_data=_build_passthrough_failure_request_payload(
+                parsed_body=None if model is None else {"model": model},
+                kwargs=kwargs,
+                logging_obj=logging_obj,
+                custom_llm_provider=None,
+                url=httpx.URL(target),
+                builtin_provider_route=builtin_provider_route,
+            ),
             traceback_str=traceback.format_exc(
                 limit=MAXIMUM_TRACEBACK_LINES_TO_LOG,
             ),
diff --git a/litellm/proxy/spend_tracking/savings.py b/litellm/proxy/spend_tracking/savings.py
index 28602fbbefc..8e79ea5255f 100644
--- a/litellm/proxy/spend_tracking/savings.py
+++ b/litellm/proxy/spend_tracking/savings.py
@@ -689,9 +689,13 @@ def compute_savings_spend(
             cost_breakdown=cost_breakdown,
         )
     )
-    return SavingsSpend(
+    savings: Final = SavingsSpend(
         compression=compression,
         prompt_caching=prompt_caching,
         autorouter=0.0 if autorouter is None else autorouter,
         gateway_injected_caching=gateway_injected_caching,
     )
+    if all(isfinite(value) for value in savings):
+        return savings
+    verbose_proxy_logger.warning("Spend tracking - recording non-finite savings %s as 0 for model=%s", savings, model)
+    return SavingsSpend(*(value if isfinite(value) else 0.0 for value in savings))
diff --git a/litellm/proxy/spend_tracking/spend_tracking_utils.py b/litellm/proxy/spend_tracking/spend_tracking_utils.py
index 09b7ce7ee9a..f8d5cba4229 100644
--- a/litellm/proxy/spend_tracking/spend_tracking_utils.py
+++ b/litellm/proxy/spend_tracking/spend_tracking_utils.py
@@ -912,7 +912,7 @@ def get_logging_payload(
             user=metadata.get("user_api_key_user_id", "") or "",
             team_id=metadata.get("user_api_key_team_id", "") or "",
             organization_id=metadata.get("user_api_key_org_id") or "",
-            metadata=safe_dumps(clean_metadata),
+            metadata=safe_dumps(clean_metadata, non_finite_as_null=True),
             cache_key=cache_key,
             spend=kwargs.get("response_cost", 0),
             total_tokens=usage.get("total_tokens", standard_logging_total_tokens),
@@ -1224,7 +1224,7 @@ def _get_messages_for_spend_logs_payload(
                 messages: Final = standard_logging_payload.get("messages")
                 if messages is not None:
                     try:
-                        return safe_dumps(messages)
+                        return safe_dumps(messages, non_finite_as_null=True)
                     except Exception:
                         return "{}"
     return "{}"
@@ -1919,7 +1919,8 @@ def _get_proxy_server_request_for_spend_logs_payload(
             _request_body_json_str: Final = safe_dumps(
                 _stored_request_without_requester_ip_address(stored_request_body)
                 if drop_requester_ip_address
-                else stored_request_body
+                else stored_request_body,
+                non_finite_as_null=True,
             )
             if LITELLM_TRUNCATED_PAYLOAD_FIELD in _request_body_json_str:
                 verbose_proxy_logger.info(
@@ -2000,7 +2001,7 @@ def _get_response_for_spend_logs_payload(
         if isinstance(sanitized_response, str):
             result_str = strip_null_bytes(sanitized_response)
         else:
-            result_str = safe_dumps(sanitized_response)
+            result_str = safe_dumps(sanitized_response, non_finite_as_null=True)
         if LITELLM_TRUNCATED_PAYLOAD_FIELD in result_str:
             verbose_proxy_logger.info(
                 "Spend Log: response was truncated before storing in DB. %s",
@@ -2071,7 +2072,7 @@ def spend_log_row_with_retained_metadata(
         return row
     metadata: Final = _SPEND_LOGS_METADATA_ADAPTER.validate_json(metadata_json)
     retained: Final = {name: value for name, value in metadata.items() if fields.keeps(name)}
-    return {**row, "metadata": safe_dumps(retained)}
+    return {**row, "metadata": safe_dumps(retained, non_finite_as_null=True)}
 
 
 def _get_status_for_spend_log(
diff --git a/litellm/proxy/utils.py b/litellm/proxy/utils.py
index 18b95c2058a..4dbcf653d96 100644
--- a/litellm/proxy/utils.py
+++ b/litellm/proxy/utils.py
@@ -86,12 +86,13 @@ from litellm.proxy._types import (
 from litellm.proxy.bug_report_config import build_proxy_bug_report
 from litellm.proxy.common_utils.openai_error_payload import (
     attribute_of,
-    litellm_call_id_headers,
-    openai_error_param,
+    error_status_code,
+    openai_shaped_proxy_exception,
     with_litellm_call_id,
 )
 from litellm.proxy.spend_tracking.spend_log_error_logger import spend_log_error
 from litellm.responses.litellm_completion_transformation.compaction_items import messages_since_newest_compaction
+from litellm.responses.mcp.parked_stream_dispatch import held_round_spend
 from litellm.types.guardrails import GuardrailEventHooks
 from litellm.types.proxy.model_listing import ModelInfoResponse
 from litellm.types.utils import MCP_GUARDRAIL_CALL_TYPES, CallTypes, CallTypesLiteral, ModelInfo, Usage
@@ -4988,6 +4989,8 @@ class ProxyLogging:
         if not isinstance(error, _PROXY_ONLY_LLM_API_ERRORS):
             return False
         match _args:
+            case (ModelResponse(), *_) if (held := held_round_spend(logging_obj)) is not None:
+                logging_obj.record_billed_rounds_for_failure(held)
             case (ModelResponse() as assembled, *_):
                 logging_obj.record_assembled_response_for_failure(assembled)
             case (BilledRoundsDispatch() as billed,):
@@ -9231,39 +9234,30 @@ def _recreate_writer_on_read_only_transaction(prisma_client: "PrismaClient | Non
     asyncio.create_task(prisma_client.recreate_read_only_writer(reason="postgres_read_only_transaction"))
 
 
+def _client_message(e: Exception) -> str:
+    status_is_none: Final = hasattr(e, "status_code") and attribute_of(e, "status_code") is None
+    return "Internal server error" if status_is_none else strip_bug_report_notice(str(e))
+
+
 def handle_exception_on_proxy(e: Exception, litellm_call_id: str | None = None) -> ProxyException:
     """
     Returns an Exception as ProxyException, this ensures all exceptions are OpenAI API compatible
     """
-    from fastapi import status
-
     verbose_proxy_logger.exception("Exception: %s", e)
     if PrismaDBExceptionHandler.is_read_only_transaction_error(e):
         from litellm.proxy.proxy_server import prisma_client
 
         _recreate_writer_on_read_only_transaction(prisma_client)
 
-    headers: Final = litellm_call_id_headers(litellm_call_id)
-    if isinstance(e, HTTPException):
-        return ProxyException(
-            message=getattr(e, "detail", f"error({e})"),
-            type=ProxyErrorTypes.internal_server_error,
-            param=openai_error_param(e),
-            headers=headers,
-            code=getattr(e, "status_code", status.HTTP_500_INTERNAL_SERVER_ERROR),
-        )
-    elif isinstance(e, ProxyException):
+    if isinstance(e, ProxyException):
         return with_litellm_call_id(e, litellm_call_id)
-    _status_code: Final = getattr(e, "status_code", status.HTTP_500_INTERNAL_SERVER_ERROR)
+    if isinstance(e, HTTPException):
+        return with_litellm_call_id(openai_shaped_proxy_exception(e, str(e.detail), e.status_code), litellm_call_id)
     if should_report_bug(e):
         verbose_proxy_logger.error(bug_report_notice(build_proxy_bug_report(e)))
-    return ProxyException(
-        message=strip_bug_report_notice(str(e)),
-        type=ProxyErrorTypes.internal_server_error,
-        param=openai_error_param(e),
-        headers=headers,
-        code=_status_code,
-    )
+    message: Final = _client_message(e)
+    status_code: Final = error_status_code(e, status.HTTP_500_INTERNAL_SERVER_ERROR)
+    return with_litellm_call_id(openai_shaped_proxy_exception(e, message, status_code), litellm_call_id)
 
 
 def require_enterprise_license(feature: str | None = None) -> None:
diff --git a/litellm/responses/litellm_completion_transformation/transformation.py b/litellm/responses/litellm_completion_transformation/transformation.py
index ce8841c9190..8f0a85d67de 100644
--- a/litellm/responses/litellm_completion_transformation/transformation.py
+++ b/litellm/responses/litellm_completion_transformation/transformation.py
@@ -398,23 +398,25 @@ def tool_output_to_chat_content(
     if single_media is not None:
         return [single_media]
     if isinstance(output, list):
+        parts: Final = cast(Sequence[object], output)  # cast-ok: checked list shape, elements remain unvalidated
         normalized_blocks: Final[list[ToolMessageContentPart]] = []
         text_acc: Final[list[str]] = []
-        for part in output:
+        for part in parts:
             if not isinstance(part, dict):
                 continue
             part_type = part.get("type")
             if part_type in ("input_text", "output_text", "text"):
                 txt = part.get("text")
-                if isinstance(txt, str) and txt:
+                if isinstance(txt, str):
                     text_acc.append(txt)
-                    normalized_blocks.append({"type": "text", "text": txt})
+                    if txt:
+                        normalized_blocks.append({"type": "text", "text": txt})
             elif (media := decode_responses_media(part)) is not None:
                 normalized_blocks.append(media)
 
         if any(b.get("type") != "text" for b in normalized_blocks):
             return normalized_blocks
-        if text_acc:
+        if any(text_acc) or len(text_acc) == len(parts):
             return "".join(text_acc)
         try:
             return json.dumps(output)
diff --git a/litellm/responses/main.py b/litellm/responses/main.py
index 5c8350589b8..9259103cb5c 100644
--- a/litellm/responses/main.py
+++ b/litellm/responses/main.py
@@ -1,7 +1,7 @@
 import asyncio
 import contextvars
 import json
-from collections.abc import Awaitable, Callable, Coroutine, Generator, Iterable, Mapping, Sequence
+from collections.abc import Coroutine, Generator, Iterable, Mapping, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import partial
@@ -81,7 +81,7 @@ from litellm.types.llms.openai import (
 
 # Handle ResponseText import with fallback
 if TYPE_CHECKING:
-    from litellm.responses.streaming_iterator import ResponsesWsFrameGuard
+    from litellm.responses.streaming_iterator import ResponsesWsFrameGuard, ResponsesWsTurnAdmission
     from litellm.types.llms.openai import ResponseText
 else:
     ResponseText = str  # Fallback for ResponseText import
@@ -2867,7 +2867,7 @@ async def _aresponses_websocket(
     api_base: str | None = None,
     api_key: str | None = None,
     timeout: float | None = None,
-    turn_admission: Callable[[], Awaitable[None]] | None = None,
+    turn_admission: "ResponsesWsTurnAdmission | None" = None,
     responses_ws_frame_guard: "ResponsesWsFrameGuard | None" = None,
     **kwargs,
 ) -> Exception | None:
diff --git a/litellm/responses/mcp/chat_completions_handler.py b/litellm/responses/mcp/chat_completions_handler.py
index cd072825ef5..1e07b768f62 100644
--- a/litellm/responses/mcp/chat_completions_handler.py
+++ b/litellm/responses/mcp/chat_completions_handler.py
@@ -1,15 +1,18 @@
 """Helpers for handling MCP-aware `/chat/completions` requests."""
 
+import asyncio
 import logging
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Final, cast
 
+import anyio
 from pydantic import TypeAdapter
 from typing_extensions import TypedDict, Unpack
 
 from litellm._internal_context import internal_sub_call
 from litellm.litellm_core_utils.hidden_params import HIDDEN_PARAMS_ATTR, set_hidden_params
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.responses.mcp.chat_stream_round_billing import ChatStreamRoundBilling, engaged_round_billing
 from litellm.responses.mcp.litellm_proxy_mcp_handler import (
     LiteLLM_Proxy_MCP_Handler,
 )
@@ -19,7 +22,7 @@ from litellm.responses.mcp.round_billing import (
     first_round_billed_on_failure,
     summed_cost_breakdown,
 )
-from litellm.types.utils import Message, ModelResponse
+from litellm.types.utils import Message, ModelResponse, Usage
 from litellm.utils import CustomStreamWrapper
 
 if TYPE_CHECKING:
@@ -258,10 +261,20 @@ async def acompletion_with_mcp(
                 self.follow_up_stream = None
                 self.follow_up_iterator = None
                 self.follow_up_exhausted = False
+                self._round_billing: ChatStreamRoundBilling | None = engaged_round_billing(initial_stream.logging_obj)
+                self._unsent_usage_chunk: ModelResponseStream | None = None
 
             def __aiter__(self):
                 return self
 
+            def __del__(self) -> None:
+                self.release_abandoned()
+
+            def release_abandoned(self) -> None:
+                round_billing: Final[object] = getattr(self, "_round_billing", None)
+                if isinstance(round_billing, ChatStreamRoundBilling):
+                    round_billing.release_abandoned()
+
             def _add_mcp_list_tools_to_chunk(self, chunk: ModelResponseStream) -> ModelResponseStream:
                 """Add mcp_list_tools to the first chunk."""
                 from litellm.types.utils import (
@@ -321,18 +334,54 @@ async def acompletion_with_mcp(
 
                 return chunk
 
-            async def _drain_inner_stream(self):
+            async def _drain_inner_stream(self) -> tuple[ModelResponseStream, ...]:
                 try:
-                    while True:
-                        await self._stream_iterator.__anext__()
-                except StopAsyncIteration:
-                    pass
+                    return tuple([chunk async for chunk in initial_stream])
                 except Exception:
                     logging.getLogger("LiteLLM").exception(
                         "Error draining inner MCP stream after final chunk; spend logging may be incomplete"
                     )
+                    return ()
 
-            async def __anext__(self):
+            async def _complete_first_round(self) -> ModelResponseStream | None:
+                drained: Final = await self._drain_inner_stream()
+                if self._round_billing is not None:
+                    self._round_billing.complete_first_round()
+                usage_chunks: Final = tuple(
+                    chunk for chunk in drained if isinstance(getattr(chunk, "usage", None), Usage)
+                )
+                return usage_chunks[-1] if usage_chunks else None
+
+            async def _follow_up_or_release_first_round(self, usage_chunk: ModelResponseStream | None) -> None:
+                if self.tool_results and self.complete_response:
+                    await self._prepare_follow_up_call()
+                if self.follow_up_stream is not None:
+                    return
+                self._unsent_usage_chunk = usage_chunk
+                if self._round_billing is not None:
+                    self._round_billing.finish()
+
+            async def __anext__(self) -> ModelResponseStream:
+                round_billing: Final = self._round_billing
+                if round_billing is None:
+                    return await self._next_chunk()
+                with round_billing.armed_while_reading():
+                    try:
+                        return await self._next_chunk()
+                    except StopAsyncIteration:
+                        usage_chunk: Final = round_billing.finish()
+                        if usage_chunk is None:
+                            raise
+                        return usage_chunk
+                    except asyncio.CancelledError:
+                        with anyio.CancelScope(shield=True):
+                            await round_billing.bill_in_flight_round()
+                        raise
+                    except Exception:
+                        round_billing.fail()
+                        raise
+
+            async def _next_chunk(self) -> ModelResponseStream:
                 # Phase 1: Collect and yield initial stream chunks
                 if not self.stream_exhausted:
                     # Get the iterator from the stream wrapper
@@ -362,29 +411,22 @@ async def acompletion_with_mcp(
 
                         if is_final:
                             self.stream_exhausted = True
+                            usage_chunk: Final = await self._complete_first_round()
                             await self._process_tool_calls()
                             chunk = self._add_mcp_tool_metadata_to_final_chunk(chunk)
-                            if self.tool_results and self.complete_response:
-                                await self._prepare_follow_up_call()
-                            # Drain inner stream so CustomStreamWrapper fires its
-                            # end-of-stream handler (dispatch_success_handlers →
-                            # _ProxyDBLogger → LiteLLM_SpendLogs).  The CSW may
-                            # yield one usage chunk before raising StopAsyncIteration.
-                            await self._drain_inner_stream()
+                            await self._follow_up_or_release_first_round(usage_chunk)
 
                         return chunk
                     except StopAsyncIteration:
                         self.stream_exhausted = True
+                        drained_usage_chunk: Final = await self._complete_first_round()
                         # Process tool calls after stream is exhausted
                         await self._process_tool_calls()
                         # If we have chunks, yield the final one with metadata
                         if self.collected_chunks:
                             final_chunk = self.collected_chunks[-1]
                             final_chunk = self._add_mcp_tool_metadata_to_final_chunk(final_chunk)
-                            # If we have tool results, prepare follow-up call
-                            if self.tool_results and self.complete_response:
-                                await self._prepare_follow_up_call()
-                            await self._drain_inner_stream()
+                            await self._follow_up_or_release_first_round(drained_usage_chunk)
                             return final_chunk
 
                 # Phase 2: Yield follow-up stream chunks if available
@@ -400,7 +442,6 @@ async def acompletion_with_mcp(
                         from litellm._logging import verbose_logger
 
                         verbose_logger.debug("Follow-up chunk yielded: %s", chunk)
-                        return chunk
                     except StopAsyncIteration:
                         self.follow_up_exhausted = True
                         from litellm._logging import verbose_logger
@@ -408,6 +449,10 @@ async def acompletion_with_mcp(
                         verbose_logger.debug("Follow-up stream exhausted")
                         # After follow-up stream is exhausted, check if we need to raise StopAsyncIteration
                         raise StopAsyncIteration
+                    client_chunk: Final = (
+                        chunk if self._round_billing is None else self._round_billing.client_chunk(chunk)
+                    )
+                    return await self._next_chunk() if client_chunk is None else client_chunk
 
                 # If we're here and follow_up_stream is None but we expected it, log a warning
                 if (
@@ -420,7 +465,11 @@ async def acompletion_with_mcp(
 
                     verbose_logger.warning("Follow-up stream was not created despite having tool results")
 
-                raise StopAsyncIteration
+                unsent_usage_chunk: Final = self._unsent_usage_chunk
+                if unsent_usage_chunk is None:
+                    raise StopAsyncIteration
+                self._unsent_usage_chunk = None
+                return unsent_usage_chunk
 
             async def _process_tool_calls(self):
                 """Process tool calls after streaming completes."""
@@ -488,10 +537,16 @@ async def acompletion_with_mcp(
                 # This ensures the patch works correctly in tests
                 import litellm
 
+                earlier_rounds: Final = None if self._round_billing is None else self._round_billing.bank_first_round()
                 follow_up_response: Final = await litellm.acompletion(**follow_up_call_args)
 
                 # Ensure follow-up response is a CustomStreamWrapper
                 if isinstance(follow_up_response, CustomStreamWrapper):
+                    if earlier_rounds is not None:
+                        follow_up_response.bill_failure_after_earlier_rounds(earlier_rounds)
+                    follow_up_response.messages = follow_up_messages
+                    if self._round_billing is not None:
+                        self._round_billing.follow_up_started(follow_up_response.partial_response)
                     self.follow_up_stream = follow_up_response
                     from litellm._logging import verbose_logger
 
@@ -548,11 +603,13 @@ async def acompletion_with_mcp(
             def __aiter__(self):
                 return self._custom_iterator
 
+            async def aclose(self) -> None:
+                self._custom_iterator.release_abandoned()
+                await super().aclose()
+
             def __iter__(self):
                 # For synchronous iteration, create a sync wrapper
                 if self._sync_iterator is None:
-                    import asyncio
-
                     try:
                         self._sync_loop = asyncio.get_event_loop()
                     except RuntimeError:
diff --git a/litellm/responses/mcp/chat_stream_round_billing.py b/litellm/responses/mcp/chat_stream_round_billing.py
new file mode 100644
index 00000000000..370de663606
--- /dev/null
+++ b/litellm/responses/mcp/chat_stream_round_billing.py
@@ -0,0 +1,281 @@
+import asyncio
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
+from dataclasses import dataclass, replace
+from types import MappingProxyType
+from typing import Final, TypeAlias
+
+from litellm.litellm_core_utils.asyncify import asyncify, is_event_loop_running
+from litellm.litellm_core_utils.hidden_params import get_hidden_params, served_from_cache, set_hidden_params
+from litellm.litellm_core_utils.litellm_logging import BilledRoundsSpend, UncachedPrice
+from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.responses.mcp.parked_stream_dispatch import (
+    DISPATCH_RELEASE,
+    HELD_ROUND_SPEND,
+    IN_FLIGHT_ROUND,
+    PARKED_DISPATCH,
+    SERVED_FROM_CACHE,
+    DeferredStreamRelease,
+    parked_success,
+)
+from litellm.responses.mcp.round_billing import billed_for_every_round, merged_chat_usage, summed_cost_breakdown
+from litellm.responses.streaming_iterator import spawn_logging_task
+from litellm.types.utils import ModelResponse, ModelResponseStream, Usage
+
+Parked: TypeAlias = tuple[object, ...]
+PartialAnswer: TypeAlias = Callable[[], object]
+
+
+@dataclass(frozen=True, slots=True)
+class _AssembledRound:
+    response: ModelResponse
+    usage: Usage
+    cache_hit: bool
+    parked: Parked
+
+
+@dataclass(frozen=True, slots=True)
+class _PricedRound:
+    response: ModelResponse
+    usage: Usage
+    price: UncachedPrice
+    cache_hit: bool
+
+    @property
+    def spend(self) -> BilledRoundsSpend:
+        return BilledRoundsSpend(self.usage, self.price.cost or 0.0, self.price.cost_breakdown)
+
+
+@dataclass(frozen=True, slots=True)
+class _HeldUsageChunk:
+    chunk: ModelResponseStream
+    usage: Usage
+
+
+@dataclass(frozen=True, slots=True)
+class _FirstRound:
+    priced: _PricedRound
+    parked: Parked
+    logged_alone: Parked
+    banked: LiteLLMLoggingObj | None = None
+    usage_chunk: _HeldUsageChunk | None = None
+
+    def client_usage_chunk(self, billed: ModelResponse | None) -> ModelResponseStream | None:
+        if self.usage_chunk is None:
+            return None
+        usage: Final = (
+            self.priced.usage.model_copy(update=MappingProxyType({"cost": self.priced.price.cost}))
+            if billed is None
+            else merged_chat_usage(self.priced.usage, self.usage_chunk.usage).model_copy(
+                update=MappingProxyType({"cost": _cost(billed)})
+            )
+        )
+        return self.usage_chunk.chunk.model_copy(
+            update=MappingProxyType({"id": self.priced.response.id, "usage": usage})
+        )
+
+
+def _cost(response: ModelResponse) -> object:
+    hidden_params: Final = get_hidden_params(response)
+    return None if hidden_params is None else hidden_params.get("response_cost")
+
+
+def _assembled_round(parked: Parked | None) -> _AssembledRound | None:
+    match parked:
+        case (ModelResponse() as response, cache_hit) if isinstance(usage := getattr(response, "usage", None), Usage):
+            return _AssembledRound(response, usage, cache_hit is True, parked)
+        case _:
+            return None
+
+
+def engaged_round_billing(logging_obj: object) -> "ChatStreamRoundBilling | None":
+    return ChatStreamRoundBilling(logging_obj) if isinstance(logging_obj, LiteLLMLoggingObj) else None
+
+
+class ChatStreamRoundBilling:
+    def __init__(self, logging_obj: LiteLLMLoggingObj) -> None:
+        self._logging_obj: Final = logging_obj
+        self._first: _FirstRound | None = None
+        self._partial_follow_up: PartialAnswer | None = None
+        self._reading_loop: asyncio.AbstractEventLoop | None = None
+
+    @contextmanager
+    def armed_while_reading(self) -> Generator[None]:
+        armed: Final = getattr(self._logging_obj, DISPATCH_RELEASE, None) is None
+        if armed:
+            setattr(self._logging_obj, DISPATCH_RELEASE, self._log_success)
+        self._reading_loop = asyncio.get_running_loop()
+        try:
+            yield
+        finally:
+            if armed and self._peek_parked() is None:
+                self._disarm()
+
+    def complete_first_round(self) -> None:
+        assembled: Final = _assembled_round(self._peek_parked())
+        if assembled is not None:
+            self._first = _FirstRound(self._priced(assembled), assembled.parked, assembled.parked)
+            setattr(self._logging_obj, HELD_ROUND_SPEND, self._held_round_one_spend)
+
+    def bank_first_round(self) -> BilledRoundsSpend | None:
+        self._bank_apart_from_the_follow_up()
+        return None if self._first is None else self._first.priced.spend
+
+    def client_chunk(self, chunk: ModelResponseStream) -> ModelResponseStream | None:
+        usage: Final[object] = getattr(chunk, "usage", None)
+        if self._first is None or not isinstance(usage, Usage):
+            return chunk
+        self._first = replace(self._first, usage_chunk=_HeldUsageChunk(chunk, usage))
+        return None
+
+    def finish(self) -> ModelResponseStream | None:
+        first: Final = self._first
+        billed: Final = self._release_rounds()
+        return None if first is None else first.client_usage_chunk(billed)
+
+    def fail(self) -> None:
+        self._bank_apart_from_the_follow_up()
+        first: Final = self._first
+        if first is None or first.banked is None or not self._holds_round_one_alone(first):
+            self.finish()
+            return
+        self._first = None
+        setattr(self._logging_obj, PARKED_DISPATCH, None)
+        self._log_through_the_release((*first.parked, first.banked.guardrail_scoped_copy()))
+
+    def follow_up_started(self, partial_follow_up: PartialAnswer) -> None:
+        self._partial_follow_up = partial_follow_up
+        setattr(self._logging_obj, IN_FLIGHT_ROUND, self.bill_in_flight_round)
+
+    async def bill_in_flight_round(self) -> None:
+        partial_follow_up: Final = self._partial_follow_up
+        if partial_follow_up is None or self._first_round_held_alone() is None:
+            return
+        final_round: Final = _assembled_round((await asyncify(partial_follow_up)(), False))
+        first: Final = self._first_round_held_alone()
+        if final_round is None or first is None:
+            return
+        self._first = None
+        setattr(
+            self._logging_obj, PARKED_DISPATCH, self._billed_for_both_rounds(first.priced, self._priced(final_round))
+        )
+
+    def release_abandoned(self) -> None:
+        if not self._owns_release():
+            return
+        if is_event_loop_running() or self._idle_reading_loop() is not None:
+            self.finish()
+            return
+        setattr(self._logging_obj, PARKED_DISPATCH, None)
+        self._first = None
+        self._disarm()
+
+    def _bank_apart_from_the_follow_up(self) -> None:
+        first: Final = self._first
+        if first is None or first.banked is not None or self._peek_parked() is not first.parked:
+            return
+        banked: Final = self._logging_obj.attempt_scoped_copy()
+        if not self._owns_release():
+            self._first = replace(first, banked=banked)
+            return
+        logged_alone: Final = (*first.parked, banked)
+        self._first = replace(first, logged_alone=logged_alone, banked=banked)
+        setattr(self._logging_obj, PARKED_DISPATCH, logged_alone)
+
+    def _release_rounds(self) -> ModelResponse | None:
+        parked: Final = self._take_parked()
+        first: Final = self._first
+        self._first = None
+        if parked is None:
+            self._disarm()
+            return None
+        if first is None or parked is first.logged_alone:
+            self._release(parked)
+            return None
+        final_round: Final = _assembled_round(parked)
+        if final_round is None:
+            self._release(first.logged_alone)
+            return None
+        billed, cache_hit = self._billed_for_both_rounds(first.priced, self._priced(final_round))
+        self._release((billed, cache_hit))
+        return billed
+
+    def _billed_for_both_rounds(self, first: _PricedRound, final: _PricedRound) -> tuple[ModelResponse, bool]:
+        first_breakdown: Final = first.price.cost_breakdown
+        final_breakdown: Final = final.price.cost_breakdown
+        rounds: Final = billed_for_every_round(first.response, first_breakdown, final.response, final_breakdown)
+        usage: Final[object] = getattr(rounds, "usage", None)
+        charged_usage: Final = (
+            usage.model_copy(update=MappingProxyType({"cost": _cost(rounds)})) if isinstance(usage, Usage) else usage
+        )
+        billed: Final = rounds.model_copy(update=MappingProxyType({"id": first.response.id, "usage": charged_usage}))
+        cache_hit: Final = first.cache_hit and final.cache_hit
+        set_hidden_params(billed, {**(get_hidden_params(rounds) or {}), "cache_hit": cache_hit})
+        self._logging_obj.cost_breakdown = summed_cost_breakdown(
+            first.response, first_breakdown, final.response, final_breakdown
+        )
+        return billed, cache_hit
+
+    def _priced(self, assembled: _AssembledRound) -> _PricedRound:
+        served: Final = assembled.cache_hit or served_from_cache(assembled.response)
+        price: Final = SERVED_FROM_CACHE if served else self._logging_obj.uncached_price(assembled.response)
+        priced: Final = assembled.response.model_copy()
+        set_hidden_params(
+            priced,
+            {**(get_hidden_params(assembled.response) or {}), "response_cost": price.cost, "cache_hit": served},
+        )
+        return _PricedRound(priced, assembled.usage, price, served)
+
+    def _peek_parked(self) -> Parked | None:
+        parked: Final[Parked | None] = getattr(self._logging_obj, PARKED_DISPATCH, None)
+        return parked if isinstance(parked, tuple) else None
+
+    def _take_parked(self) -> Parked | None:
+        parked: Final = self._peek_parked()
+        setattr(self._logging_obj, PARKED_DISPATCH, None)
+        return parked
+
+    def _first_round_held_alone(self) -> _FirstRound | None:
+        first: Final = self._first
+        return first if first is not None and self._holds_round_one_alone(first) else None
+
+    def _held_round_one_spend(self) -> BilledRoundsSpend | None:
+        first: Final = self._first_round_held_alone()
+        return None if first is None else first.priced.spend
+
+    def _holds_round_one_alone(self, first: _FirstRound) -> bool:
+        parked: Final = self._peek_parked()
+        return parked is first.parked or parked is first.logged_alone
+
+    def _owns_release(self) -> bool:
+        release: Final[object] = getattr(self._logging_obj, DISPATCH_RELEASE, None)
+        return release == self._log_success
+
+    def _release(self, parked: Parked) -> None:
+        if getattr(self._logging_obj, DISPATCH_RELEASE, None) is not None and not self._owns_release():
+            setattr(self._logging_obj, PARKED_DISPATCH, parked)
+            return
+        self._log_through_the_release(parked)
+
+    def _log_through_the_release(self, parked: Parked) -> None:
+        armed: Final[DeferredStreamRelease | None] = getattr(self._logging_obj, DISPATCH_RELEASE, None)
+        setattr(self._logging_obj, DISPATCH_RELEASE, None)
+        logged: Final = (self._log_success if armed is None else armed)(*parked)
+        idle_reading_loop: Final = None if is_event_loop_running() else self._idle_reading_loop()
+        if idle_reading_loop is not None:
+            idle_reading_loop.run_until_complete(logged)
+            return
+        spawn_logging_task(asyncio.get_running_loop(), logged, task_name="Chat completions MCP stream success log")
+
+    def _idle_reading_loop(self) -> asyncio.AbstractEventLoop | None:
+        loop: Final = self._reading_loop
+        return loop if loop is not None and not loop.is_closed() and not loop.is_running() else None
+
+    def _disarm(self) -> None:
+        if self._owns_release():
+            setattr(self._logging_obj, DISPATCH_RELEASE, None)
+
+    async def _log_success(self, *parked: object) -> None:
+        success: Final = parked_success(parked)
+        if success is not None:
+            await success.dispatch(self._logging_obj)
diff --git a/litellm/responses/mcp/parked_stream_dispatch.py b/litellm/responses/mcp/parked_stream_dispatch.py
new file mode 100644
index 00000000000..792363f0bab
--- /dev/null
+++ b/litellm/responses/mcp/parked_stream_dispatch.py
@@ -0,0 +1,72 @@
+from collections.abc import Coroutine
+from dataclasses import dataclass
+from typing import Final, Protocol
+
+from litellm.litellm_core_utils.litellm_logging import BilledRoundsSpend, UncachedPrice
+from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+
+PARKED_DISPATCH: Final = "_deferred_stream_complete_args"
+DISPATCH_RELEASE: Final = "_on_deferred_stream_complete"
+IN_FLIGHT_ROUND: Final = "_bill_in_flight_round_on_disconnect"
+HELD_ROUND_SPEND: Final = "_held_round_spend_for_failure"
+SERVED_FROM_CACHE: Final = UncachedPrice(cost=0.0, cost_breakdown=None)
+
+
+class DispatchesSuccessHandlers(Protocol):
+    async def dispatch_success_handlers(
+        self,
+        result: object = None,
+        start_time: object = None,
+        end_time: object = None,
+        cache_hit: object = None,
+        prefer_async_handlers: bool = False,
+    ) -> None: ...
+
+
+class DeferredStreamRelease(Protocol):
+    def __call__(self, *parked: object) -> Coroutine[object, object, None]: ...
+
+
+class InFlightRoundBiller(Protocol):
+    def __call__(self) -> Coroutine[object, object, None]: ...
+
+
+class HeldRoundSpend(Protocol):
+    def __call__(self) -> BilledRoundsSpend | None: ...
+
+
+def success_dispatcher(logger: LiteLLMLoggingObj) -> DispatchesSuccessHandlers:
+    return logger
+
+
+@dataclass(frozen=True, slots=True)
+class ParkedSuccess:
+    assembled: object
+    cache_hit: object
+    logged_on: LiteLLMLoggingObj | None = None
+
+    async def dispatch(self, request_logger: LiteLLMLoggingObj) -> None:
+        logger: Final = request_logger if self.logged_on is None else self.logged_on
+        await success_dispatcher(logger).dispatch_success_handlers(
+            self.assembled, cache_hit=self.cache_hit, start_time=None, end_time=None, prefer_async_handlers=True
+        )
+
+
+def in_flight_round_biller(logging_obj: object) -> InFlightRoundBiller | None:
+    biller: Final[InFlightRoundBiller | None] = getattr(logging_obj, IN_FLIGHT_ROUND, None)
+    return biller if isinstance(logging_obj, LiteLLMLoggingObj) and callable(biller) else None
+
+
+def held_round_spend(logging_obj: object) -> BilledRoundsSpend | None:
+    held: Final[HeldRoundSpend | None] = getattr(logging_obj, HELD_ROUND_SPEND, None)
+    return held() if isinstance(logging_obj, LiteLLMLoggingObj) and callable(held) else None
+
+
+def parked_success(parked: tuple[object, ...]) -> ParkedSuccess | None:
+    match parked:
+        case (assembled, cache_hit):
+            return ParkedSuccess(assembled, cache_hit)
+        case (assembled, cache_hit, LiteLLMLoggingObj() as logged_on):
+            return ParkedSuccess(assembled, cache_hit, logged_on)
+        case _:
+            return None
diff --git a/litellm/responses/mcp/stream_round_billing.py b/litellm/responses/mcp/stream_round_billing.py
index 443147230bf..5cb256a8ac0 100644
--- a/litellm/responses/mcp/stream_round_billing.py
+++ b/litellm/responses/mcp/stream_round_billing.py
@@ -2,11 +2,18 @@ import asyncio
 from collections.abc import Callable, Coroutine, Sequence
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Final, Protocol, TypeAlias
+from typing import Final, TypeAlias
 
 from litellm.litellm_core_utils.hidden_params import get_hidden_params, served_from_cache
 from litellm.litellm_core_utils.litellm_logging import BilledRoundsDispatch, BilledRoundsSpend, UncachedPrice
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.responses.mcp.parked_stream_dispatch import (
+    DISPATCH_RELEASE,
+    PARKED_DISPATCH,
+    SERVED_FROM_CACHE,
+    parked_success,
+    success_dispatcher,
+)
 from litellm.responses.mcp.round_billing import billed_for_every_round, merged_chat_usage, summed_cost_breakdown
 from litellm.responses.streaming_iterator import BaseResponsesAPIStreamingIterator, spawn_logging_task
 from litellm.responses.utils import ResponseAPILoggingUtils
@@ -16,25 +23,6 @@ from litellm.types.utils import CostBreakdown, ModelResponse, Usage
 Parked: TypeAlias = tuple[object, ...]
 RestoresHeaders: TypeAlias = Callable[[ResponsesAPIStreamingResponse], None]
 
-_PARKED_DISPATCH: Final = "_deferred_stream_complete_args"
-_DISPATCH_RELEASE: Final = "_on_deferred_stream_complete"
-_SERVED_FROM_CACHE: Final = UncachedPrice(cost=0.0, cost_breakdown=None)
-
-
-class _DispatchesSuccessHandlers(Protocol):
-    async def dispatch_success_handlers(
-        self,
-        result: object = None,
-        start_time: object = None,
-        end_time: object = None,
-        cache_hit: object = None,
-        prefer_async_handlers: bool = False,
-    ) -> None: ...
-
-
-def _success_dispatcher(logger: LiteLLMLoggingObj) -> _DispatchesSuccessHandlers:
-    return logger
-
 
 def _event_loop_running() -> bool:
     try:
@@ -198,8 +186,8 @@ class StreamedRoundBilling:
         self._billed: _BilledRounds | None = None
         self._banked: Parked | None = None
         self._banked_row: _RoundRow | None = None
-        if getattr(logging_obj, _DISPATCH_RELEASE, None) is None:
-            setattr(logging_obj, _DISPATCH_RELEASE, self._run_parked)
+        if getattr(logging_obj, DISPATCH_RELEASE, None) is None:
+            setattr(logging_obj, DISPATCH_RELEASE, self._run_parked)
 
     def complete_round(
         self,
@@ -286,7 +274,7 @@ class StreamedRoundBilling:
 
     def _price(self, response: ResponsesAPIResponse, round_parked: Parked | None) -> UncachedPrice:
         if served_from_cache(response):
-            return _SERVED_FROM_CACHE
+            return SERVED_FROM_CACHE
         match round_parked:
             case (ModelResponse() as assembled, bool()):
                 return self._logging_obj.uncached_price(assembled)
@@ -297,7 +285,7 @@ class StreamedRoundBilling:
         self._banked = parked
         self._banked_row = row
         if parked is not None:
-            setattr(self._logging_obj, _PARKED_DISPATCH, parked)
+            setattr(self._logging_obj, PARKED_DISPATCH, parked)
 
     def _bank_apart_from_later_rounds(self, billed: _BilledRounds) -> None:
         row: Final = self._banked_row
@@ -320,7 +308,7 @@ class StreamedRoundBilling:
     @staticmethod
     async def _log_success(success: _SuccessLog) -> None:
         success.carry_bridged_usage()
-        await _success_dispatcher(success.logger).dispatch_success_handlers(
+        await success_dispatcher(success.logger).dispatch_success_handlers(
             success.row.logged,
             start_time=success.logger.start_time,
             end_time=success.row.end_time,
@@ -329,10 +317,10 @@ class StreamedRoundBilling:
         )
 
     def _take_parked(self) -> Parked | None:
-        parked: Final[Parked | None] = getattr(self._logging_obj, _PARKED_DISPATCH, None)
+        parked: Final[Parked | None] = getattr(self._logging_obj, PARKED_DISPATCH, None)
         if not isinstance(parked, tuple):
             return None
-        setattr(self._logging_obj, _PARKED_DISPATCH, None)
+        setattr(self._logging_obj, PARKED_DISPATCH, None)
         return parked
 
     async def _run_parked(self, *parked: object) -> None:
@@ -341,29 +329,27 @@ class StreamedRoundBilling:
                 await dispatch
             case (dispatch,) if asyncio.iscoroutine(dispatch):
                 await dispatch
-            case (assembled, cache_hit):
-                await _success_dispatcher(self._logging_obj).dispatch_success_handlers(
-                    assembled, cache_hit=cache_hit, start_time=None, end_time=None, prefer_async_handlers=True
-                )
+            case _ if (success := parked_success(parked)) is not None:
+                await success.dispatch(self._logging_obj)
             case _:
                 return
 
     def _owns_release(self) -> bool:
-        release: Final[object] = getattr(self._logging_obj, _DISPATCH_RELEASE, None)
+        release: Final[object] = getattr(self._logging_obj, DISPATCH_RELEASE, None)
         return release == self._run_parked
 
     def _release(self, parked: Parked) -> None:
-        if getattr(self._logging_obj, _DISPATCH_RELEASE, None) is not None and not self._owns_release():
-            setattr(self._logging_obj, _PARKED_DISPATCH, parked)
+        if getattr(self._logging_obj, DISPATCH_RELEASE, None) is not None and not self._owns_release():
+            setattr(self._logging_obj, PARKED_DISPATCH, parked)
             return
-        setattr(self._logging_obj, _DISPATCH_RELEASE, None)
+        setattr(self._logging_obj, DISPATCH_RELEASE, None)
         spawn_logging_task(
             asyncio.get_running_loop(), self._run_parked(*parked), task_name="Responses MCP stream success logging"
         )
 
     def _disarm(self) -> None:
         if self._owns_release():
-            setattr(self._logging_obj, _DISPATCH_RELEASE, None)
+            setattr(self._logging_obj, DISPATCH_RELEASE, None)
 
     @staticmethod
     def _close(parked: Parked | None) -> None:
diff --git a/litellm/responses/streaming_iterator.py b/litellm/responses/streaming_iterator.py
index f0bb2201162..fb91ba6a618 100644
--- a/litellm/responses/streaming_iterator.py
+++ b/litellm/responses/streaming_iterator.py
@@ -2145,18 +2145,32 @@ async def _enforce_frame_project_quota(
         )
 
 
-async def _admit_frame_turn(turn_admission: Callable[[], Awaitable[None]] | None, raw_message: str) -> Exception | None:
+@dataclass(frozen=True, slots=True)
+class _AdmittedTurn:
+    reservation: Mapping[str, object] = field(default_factory=lambda: MappingProxyType({}))
+
+
+@dataclass(frozen=True, slots=True)
+class _RefusedTurn:
+    rejection: Exception
+
+
+ResponsesWsTurnAdmission: TypeAlias = Callable[[], Awaitable[Mapping[str, object]]]
+
+
+async def _admit_frame_turn(
+    turn_admission: ResponsesWsTurnAdmission | None, raw_message: str
+) -> _AdmittedTurn | _RefusedTurn:
     frame: Final = _json_object_or_none(raw_message)
     if turn_admission is None or frame is None or frame.get("type") != "response.create":
-        return None
+        return _AdmittedTurn()
     try:
-        await turn_admission()
+        return _AdmittedTurn(await turn_admission())
     except RateLimitError as refusal:
-        return refusal
+        return _RefusedTurn(refusal)
     except Exception as e:
         verbose_logger.exception("Responses WS turn admission failed: %s", e)
-        return e
-    return None
+        return _RefusedTurn(e)
 
 
 def _turn_refusal_frame(refusal: RateLimitError) -> str:
@@ -2191,6 +2205,7 @@ RESPONSES_WS_MASKABLE_TEXT_BLOCK_TYPES: Final = frozenset({"input_text", "output
 
 _RESPONSES_WS_FAILURE_EVENT_TYPES: Final = frozenset({"error", "response.failed"})
 _PER_TURN_METADATA_KEYS: Final = frozenset({"metadata", "litellm_metadata"})
+_NO_IO_TOKEN_RESERVATION: Final[Mapping[str, object]] = MappingProxyType({})
 _GUARDRAIL_INFORMATION_KEY: Final = "standard_logging_guardrail_information"
 
 
@@ -2318,6 +2333,17 @@ def _set_turn_guardrail_information(
         _replace_guardrail_information(litellm_params.get(key), guardrail_information)
 
 
+def _set_turn_io_token_reservation(turn_logging_obj: LiteLLMLoggingObj, reservation: Mapping[str, object]) -> None:
+    litellm_params: Final = _json_object_or_none(
+        turn_logging_obj.litellm_params  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]  # Logging.litellm_params is untyped
+    )
+    if litellm_params is None or not reservation:
+        return
+    for bucket in (litellm_params.get(key) for key in _PER_TURN_METADATA_KEYS):
+        if _is_json_object(bucket):
+            bucket.update(reservation)
+
+
 def _replace_guardrail_information(bucket: object, guardrail_information: tuple[Mapping[str, object], ...]) -> None:
     if not _is_json_object(bucket):
         return
@@ -2458,7 +2484,7 @@ class ResponsesWebSocketStreaming:
         authorized_model: str | None = None,
         custom_llm_provider: str | None = None,
         request_defaults: ResponsesWebSocketRequestDefaults | None = None,
-        turn_admission: Callable[[], Awaitable[None]] | None = None,
+        turn_admission: ResponsesWsTurnAdmission | None = None,
         frame_guard: ResponsesWsFrameGuard | None = None,
     ):
         self.websocket = websocket
@@ -2480,10 +2506,13 @@ class ResponsesWebSocketStreaming:
         # response.create frame to prevent deployment-substitution attacks.
         self.authorized_model: str | None = authorized_model
         self.request_defaults: ResponsesWebSocketRequestDefaults | None = request_defaults
-        self.turn_admission: Callable[[], Awaitable[None]] | None = turn_admission
+        self.turn_admission: ResponsesWsTurnAdmission | None = turn_admission
 
     def _start_turn(
-        self, client_frame: str | None, guardrail_information: tuple[Mapping[str, object], ...] = ()
+        self,
+        client_frame: str | None,
+        guardrail_information: tuple[Mapping[str, object], ...] = (),
+        io_token_reservation: Mapping[str, object] = _NO_IO_TOKEN_RESERVATION,
     ) -> None:
         start_time: Final = datetime.now()  # noqa: DTZ005  # naive to match the logging pipeline start_time
         turn_logging_obj: Final = self.logging_obj.copy_for_new_call(
@@ -2491,6 +2520,7 @@ class ResponsesWebSocketStreaming:
         )
         self._detach_budget_reservation()
         _set_turn_guardrail_information(turn_logging_obj, guardrail_information)
+        _set_turn_io_token_reservation(turn_logging_obj, io_token_reservation)
         turn_logging_obj.model_call_details["messages"] = list(_logged_user_messages(client_frame))
         turn_logging_obj.pre_call(input=client_frame, api_key="")
         self._open_turns = (*self._open_turns, _ResponsesWsTurn(logging_obj=turn_logging_obj))
@@ -2510,11 +2540,14 @@ class ResponsesWebSocketStreaming:
         }
 
     def _record_client_frame(
-        self, client_frame: str, guardrail_information: tuple[Mapping[str, object], ...] = ()
+        self,
+        client_frame: str,
+        guardrail_information: tuple[Mapping[str, object], ...] = (),
+        io_token_reservation: Mapping[str, object] = _NO_IO_TOKEN_RESERVATION,
     ) -> None:
         frame: Final = _json_object_or_none(client_frame)
         if frame is not None and frame.get("type") == "response.create":
-            self._start_turn(client_frame, guardrail_information)
+            self._start_turn(client_frame, guardrail_information, io_token_reservation)
 
     async def _guard_frame(self, message: str) -> GuardedResponsesWsFrame | None:
         """Run the proxy's pre_call guardrails on one ``response.create`` frame.
@@ -2533,15 +2566,18 @@ class ResponsesWebSocketStreaming:
             return None
 
     async def _forward_guarded_frame(
-        self, message: str, turn_admission: Callable[[], Awaitable[None]] | None = None
+        self, message: str, turn_admission: ResponsesWsTurnAdmission | None = None
     ) -> None:
         guarded: Final = await self._guard_frame(message)
-        if guarded is None or not await self._admit_or_reject_turn(guarded, message, turn_admission):
+        if guarded is None:
+            return
+        admitted: Final = await self._admit_or_reject_turn(guarded, message, turn_admission)
+        if admitted is None:
             return
         if guarded.pii_tokens:
             self._remember_pii_tokens(guarded.pii_tokens)
         masked: Final = await self._mask_response_create(guarded.frame)
-        self._record_client_frame(masked, guarded.guardrail_information)
+        self._record_client_frame(masked, guarded.guardrail_information, admitted.reservation)
         await self.backend_ws.send(masked)
 
     def _remember_pii_tokens(self, pii_tokens: Mapping[str, str]) -> None:
@@ -2941,15 +2977,17 @@ class ResponsesWebSocketStreaming:
         return True
 
     async def _admit_or_reject_turn(
-        self, guarded: GuardedResponsesWsFrame, message: str, turn_admission: Callable[[], Awaitable[None]] | None
-    ) -> bool:
-        rejection: Final = await _admit_frame_turn(turn_admission, message)
-        if rejection is None:
-            return True
-        if self._failure is None:
-            self._failure = rejection
-        await _reject_guarded_turn(self.websocket, guarded, rejection)
-        return False
+        self, guarded: GuardedResponsesWsFrame, message: str, turn_admission: ResponsesWsTurnAdmission | None
+    ) -> _AdmittedTurn | None:
+        verdict: Final = await _admit_frame_turn(turn_admission, message)
+        match verdict:
+            case _AdmittedTurn():
+                return verdict
+            case _RefusedTurn(rejection=rejection):
+                if self._failure is None:
+                    self._failure = rejection
+                await _reject_guarded_turn(self.websocket, guarded, rejection)
+                return None
 
     async def _send_turn_refusal(self, refusal: RateLimitError) -> None:
         try:
@@ -3052,7 +3090,7 @@ class ManagedResponsesWebSocketHandler:
         custom_llm_provider: str | None = None,
         first_message: str | None = None,
         quota_callbacks: Sequence[ProjectQuotaCallback] | None = None,
-        turn_admission: Callable[[], Awaitable[None]] | None = None,
+        turn_admission: ResponsesWsTurnAdmission | None = None,
         frame_guard: ResponsesWsFrameGuard | None = None,
         guardrail_callbacks: Sequence[PresidioGuardrailCallback] | None = None,
         **kwargs: object,
@@ -3076,7 +3114,7 @@ class ManagedResponsesWebSocketHandler:
         self._connection_provider = self._resolve_provider(model) or custom_llm_provider
         self.first_message = first_message
         self.quota_callbacks: tuple[ProjectQuotaCallback, ...] = tuple(quota_callbacks) if quota_callbacks else ()
-        self.turn_admission: Callable[[], Awaitable[None]] | None = turn_admission
+        self.turn_admission: ResponsesWsTurnAdmission | None = turn_admission
         self._failure: Exception | None = None
         # Carry through safe pass-through kwargs (e.g. extra_headers)
         self.extra_kwargs: dict[str, object] = {k: v for k, v in kwargs.items() if k not in _MANAGED_WS_SKIP_KWARGS}
@@ -3473,7 +3511,7 @@ class ManagedResponsesWebSocketHandler:
     # ------------------------------------------------------------------
 
     async def _process_response_create(
-        self, raw_message: str, turn_admission: Callable[[], Awaitable[None]] | None = None
+        self, raw_message: str, turn_admission: ResponsesWsTurnAdmission | None = None
     ) -> None:
         """
         Parse one ``response.create`` event, call ``litellm.aresponses(stream=True)``,
@@ -3520,11 +3558,11 @@ class ManagedResponsesWebSocketHandler:
         guarded: Final = await self._guard_frame(raw_message)
         if guarded is None:
             return
-        rejection: Final = await _admit_frame_turn(turn_admission, raw_message)
-        if rejection is not None:
+        verdict: Final = await _admit_frame_turn(turn_admission, raw_message)
+        if isinstance(verdict, _RefusedTurn):
             if self._failure is None:
-                self._failure = rejection
-            await _reject_guarded_turn(self.websocket, guarded, rejection)
+                self._failure = verdict.rejection
+            await _reject_guarded_turn(self.websocket, guarded, verdict.rejection)
             return
         if guarded.pii_tokens:
             self._pii_tokens = {**self._pii_tokens, **guarded.pii_tokens}
@@ -3555,6 +3593,11 @@ class ManagedResponsesWebSocketHandler:
             )
         self._update_proxy_request(call_kwargs, requested_model or self.model_group or model)
         call_kwargs.update(self.extra_kwargs)
+        turn_litellm_metadata: Final = call_kwargs.get("litellm_metadata")
+        call_kwargs["litellm_metadata"] = {
+            **(turn_litellm_metadata if _is_json_object(turn_litellm_metadata) else {}),
+            **verdict.reservation,
+        }
 
         try:
             terminal_event: Final = await self._stream_and_forward(model, call_kwargs)
diff --git a/litellm/router.py b/litellm/router.py
index af2181cedb5..233e7581a40 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -378,6 +378,7 @@ from litellm.router_utils.pre_call_checks.encrypted_content_affinity_check impor
     EncryptedContentAffinityCheck,
 )
 from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import (
+    async_admit_io_token_turn,
     async_io_token_refund_failure,
     build_io_token_rate_limit_headers,
     deployment_has_io_token_limits,
@@ -5113,6 +5114,7 @@ class Router(DeprecatedRouterMembers):
         kwargs: dict,
         function_name: str | None = None,
         splits_stream_timeout: bool = False,
+        opens_responses_socket: bool = False,
     ) -> None:
         """
         5 jobs:
@@ -5202,7 +5204,12 @@ class Router(DeprecatedRouterMembers):
         # here before it's wiped below, instead of relying on that attempt's
         # (possibly still-pending) failure event to do it.
         refund_stale_reservation_before_retry(self._core_cache, kwargs)
-        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=deployment_has_io_token_limits(deployment))
+        set_io_token_rate_limit_request_kwargs(
+            kwargs,
+            store_in_context=deployment_has_io_token_limits(deployment),
+            opens_responses_socket=opens_responses_socket,
+            metadata_channel=metadata_variable_name,
+        )
 
         kwargs[metadata_variable_name].setdefault(
             ROUTING_REQUEST_TAGS_METADATA_KEY,
@@ -6615,6 +6622,7 @@ class Router(DeprecatedRouterMembers):
                 kwargs=kwargs,
                 function_name=function_name,
                 splits_stream_timeout=handler_name in _STREAM_TIMEOUT_AWARE_GENERIC_HANDLERS,
+                opens_responses_socket=handler_name == "_aresponses_websocket",
             )
 
             data: Final = deployment["litellm_params"].copy()
@@ -10465,9 +10473,20 @@ class Router(DeprecatedRouterMembers):
         return deployment if current is None else current.model_dump(exclude_none=True)
 
     async def async_admit_deployment_turn(
-        self, model_group: str, opened_on: Mapping[str, object], request_kwargs: Mapping[str, object]
-    ) -> None:
+        self,
+        model_group: str,
+        opened_on: Mapping[str, object],
+        request_kwargs: Mapping[str, object],
+    ) -> Mapping[str, object]:
         deployment: Final = self._deployment_as_configured_now(opened_on)
+        rate_limit_check: Final = next(
+            (callback for callback in self._routing_callbacks() if isinstance(callback, ModelRateLimitingCheck)), None
+        )
+        io_token_admission: Final[Mapping[str, object]] = (
+            MappingProxyType({})
+            if rate_limit_check is None
+            else await async_admit_io_token_turn(rate_limit_check.dual_cache, deployment, get_utc_datetime())
+        )
         budget_limiter: Final = self._core_get_router_deployment_budget_limiter()
         if budget_limiter is not None:
             try:
@@ -10488,6 +10507,7 @@ class Router(DeprecatedRouterMembers):
         await self.async_routing_strategy_pre_call_checks(  # pyright: ignore[reportUnknownMemberType]  # legacy signature takes an untyped deployment dict
             deployment=dict(without_io_token_limits(deployment)), parent_otel_span=None
         )
+        return io_token_admission
 
     async def _admit_turn_through_routing_strategy(
         self, model_group: str, deployment: Mapping[str, object], request_kwargs: Mapping[str, object]
diff --git a/litellm/router_utils/pre_call_checks/io_token_rate_limit_check.py b/litellm/router_utils/pre_call_checks/io_token_rate_limit_check.py
index 7580c7dadd3..80e1f3fe29c 100644
--- a/litellm/router_utils/pre_call_checks/io_token_rate_limit_check.py
+++ b/litellm/router_utils/pre_call_checks/io_token_rate_limit_check.py
@@ -14,6 +14,9 @@ from __future__ import annotations
 import contextlib
 import contextvars
 from collections.abc import Mapping, MutableMapping
+from dataclasses import dataclass
+from datetime import datetime
+from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, Final
 
 import httpx
@@ -23,7 +26,15 @@ from litellm import token_counter
 from litellm._internal_context import with_service_target
 from litellm._logging import verbose_router_logger
 from litellm.caching.dual_cache import DualCache
+from litellm.caching.redis_cache import RedisCache, RedisCircuitBreakerOpenError
 from litellm.constants import NO_MAX_TOKENS_TPM_RESERVATION_FRACTION
+from litellm.litellm_core_utils.internal_call_metadata import (
+    IO_TOKEN_RESERVATION_KEYS,
+    ITPM_CACHE_KEY,
+    ITPM_RESERVED_KEY,
+    OTPM_CACHE_KEY,
+    OTPM_RESERVED_KEY,
+)
 from litellm.litellm_core_utils.token_counter import deployment_openai_model, offload_token_count
 from litellm.llms.azure.ptu_capacity import is_str_keyed_mapping
 from litellm.router_utils.routing_read_batch import ROUTER_USAGE_TARGET
@@ -39,18 +50,27 @@ else:
 
 RoutingArgsTTL: Final = 60
 
-_io_token_rate_limit_request_kwargs: Final[contextvars.ContextVar[dict[str, object] | None]] = contextvars.ContextVar(
-    "io_token_rate_limit_request_kwargs",
+
+@dataclass(frozen=True, slots=True)
+class _IoTokenRateLimitRequest:
+    kwargs: dict[str, object] | None
+    opens_responses_socket: bool
+    metadata_channel: str
+
+
+_io_token_rate_limit_request: Final[contextvars.ContextVar[_IoTokenRateLimitRequest | None]] = contextvars.ContextVar(
+    "io_token_rate_limit_request",
     default=None,
 )
 
-ITPM_RESERVED_KEY: Final = "_litellm_itpm_reserved"
-OTPM_RESERVED_KEY: Final = "_litellm_otpm_reserved"
-ITPM_CACHE_KEY: Final = "_litellm_itpm_cache_key"
-OTPM_CACHE_KEY: Final = "_litellm_otpm_cache_key"
 
-
-def set_io_token_rate_limit_request_kwargs(kwargs: dict[str, object] | None, store_in_context: bool = True) -> None:
+def set_io_token_rate_limit_request_kwargs(
+    kwargs: dict[str, object] | None,
+    store_in_context: bool = True,
+    *,
+    opens_responses_socket: bool = False,
+    metadata_channel: str,
+) -> None:
     # The reservation sentinels are server-only, but `metadata` is caller
     # controlled on proxy requests. Strip any client-supplied copies here (this
     # runs before the router stashes its own reservation) so a forged
@@ -64,11 +84,14 @@ def set_io_token_rate_limit_request_kwargs(kwargs: dict[str, object] | None, sto
     # every other deployment overwrite the slot with None instead of the
     # kwargs; overwriting (rather than skipping) also releases a previous
     # request's kwargs when a context is reused.
-    _io_token_rate_limit_request_kwargs.set(kwargs if store_in_context else None)
+    _io_token_rate_limit_request.set(
+        _IoTokenRateLimitRequest(kwargs, opens_responses_socket, metadata_channel) if store_in_context else None
+    )
 
 
 def get_io_token_rate_limit_request_kwargs() -> dict[str, object] | None:
-    return _io_token_rate_limit_request_kwargs.get()
+    request: Final = _io_token_rate_limit_request.get()
+    return None if request is None else request.kwargs
 
 
 def seconds_until_minute_reset() -> int:
@@ -224,27 +247,32 @@ def _otpm_reservation(
     return default if from_deployment is None else min(from_deployment, default)
 
 
+def _usage_field(container: object, name: str) -> object:
+    if is_str_keyed_mapping(container):
+        return container.get(name)
+    return getattr(container, name, None)
+
+
+def _cached_prompt_tokens(usage: object) -> int:
+    reported: Final = (
+        _usage_field(_usage_field(usage, "prompt_tokens_details"), "cached_tokens"),
+        _usage_field(_usage_field(usage, "input_tokens_details"), "cached_tokens"),
+        _usage_field(usage, "cache_read_input_tokens"),
+    )
+    return next((int(tokens) for tokens in reported if isinstance(tokens, int | float) and tokens), 0)
+
+
 def _get_usage_tokens(usage: object) -> tuple[int, int, int]:
     if usage is None:
         return 0, 0, 0
     if hasattr(usage, "prompt_tokens") or hasattr(usage, "input_tokens"):
         prompt = int(getattr(usage, "prompt_tokens", None) or getattr(usage, "input_tokens", 0) or 0)
         completion = int(getattr(usage, "completion_tokens", None) or getattr(usage, "output_tokens", 0) or 0)
-        cached = 0
-        details: object = getattr(usage, "prompt_tokens_details", None)
-        if details is not None:
-            cached = int(getattr(details, "cached_tokens", 0) or 0)
-        if not cached:
-            cached = int(getattr(usage, "cache_read_input_tokens", 0) or 0)
-        return prompt, completion, cached
+        return prompt, completion, _cached_prompt_tokens(usage)
     if isinstance(usage, dict):
         prompt = int(usage.get("prompt_tokens") or usage.get("input_tokens") or 0)
         completion = int(usage.get("completion_tokens") or usage.get("output_tokens") or 0)
-        details = usage.get("prompt_tokens_details") or {}
-        cached = int(details.get("cached_tokens", 0) or 0) if isinstance(details, dict) else 0
-        if not cached:
-            cached = int(usage.get("cache_read_input_tokens") or 0)
-        return prompt, completion, cached
+        return prompt, completion, _cached_prompt_tokens(usage)
     return 0, 0, 0
 
 
@@ -298,19 +326,36 @@ def _resolve_reconcile_usage_tokens(
         if isinstance(standard_logging_object, dict):
             prompt_tokens = int(standard_logging_object.get("prompt_tokens") or 0)
             completion_tokens = int(standard_logging_object.get("completion_tokens") or 0)
-            cached_tokens = 0
-            metadata: Final = standard_logging_object.get("metadata")
-            if isinstance(metadata, dict):
-                cached_tokens = int(metadata.get("cache_read_input_tokens") or 0)
+            logged_usage: Final = _usage_field(standard_logging_object.get("metadata"), "usage_object")
+            logged_cached_tokens: Final = _cached_prompt_tokens(logged_usage)
             # Same rationale as _usage_is_present: a bare total_tokens with no
             # prompt/completion breakdown can't be split, so it isn't treated
             # as resolved usage - the reservation is kept instead of refunded.
             if prompt_tokens or completion_tokens:
-                return max(0, prompt_tokens - cached_tokens), completion_tokens, True
+                return max(0, prompt_tokens - logged_cached_tokens), completion_tokens, True
 
     return 0, 0, False
 
 
+def _reservation(
+    itpm_reserved: int, otpm_reserved: int, itpm_cache_key: str | None, otpm_cache_key: str | None
+) -> Mapping[str, object]:
+    return MappingProxyType(
+        {
+            ITPM_RESERVED_KEY: itpm_reserved,
+            OTPM_RESERVED_KEY: otpm_reserved,
+            ITPM_CACHE_KEY: itpm_cache_key,
+            OTPM_CACHE_KEY: otpm_cache_key,
+        }
+    )
+
+
+def _stash_reservation_in_metadata(request: _IoTokenRateLimitRequest | None, reservation: Mapping[str, object]) -> None:
+    metadata: Final = None if request is None or not request.kwargs else request.kwargs.get(request.metadata_channel)
+    if isinstance(metadata, dict):
+        metadata.update(reservation)
+
+
 def _key_for_this_minute(reserved_key: str) -> str:
     counter, _, _ = reserved_key.rpartition(":")
     return f"{counter}:{get_utc_datetime().strftime('%H-%M')}"
@@ -326,30 +371,6 @@ def _reconcile_increments(
     )
 
 
-def _stash_reservation_in_metadata(
-    request_kwargs: dict[str, object] | None,
-    *,
-    itpm_reserved: int,
-    otpm_reserved: int,
-    itpm_cache_key: str | None,
-    otpm_cache_key: str | None,
-) -> None:
-    if not request_kwargs:
-        return
-    reservation: Final = {
-        ITPM_RESERVED_KEY: itpm_reserved,
-        OTPM_RESERVED_KEY: otpm_reserved,
-        ITPM_CACHE_KEY: itpm_cache_key,
-        OTPM_CACHE_KEY: otpm_cache_key,
-    }
-    for channel in ("metadata", "litellm_metadata"):
-        existing = request_kwargs.get(channel)
-        if isinstance(existing, dict):
-            existing.update(reservation)
-        elif channel == "metadata":
-            request_kwargs[channel] = dict(reservation)
-
-
 def _extract_reservation(reservation: Mapping[str, int | str | None]) -> tuple[int, int, str | None, str | None]:
     itpm_cache_key: Final = reservation.get(ITPM_CACHE_KEY)
     otpm_cache_key: Final = reservation.get(OTPM_CACHE_KEY)
@@ -399,7 +420,7 @@ def _clear_reservation_from_kwargs(kwargs: Mapping[str, object] | None) -> None:
     for channel in _reservation_channels(kwargs):
         channel_dict = _as_mutable_mapping(channel)
         if channel_dict is not None:
-            for key in (ITPM_RESERVED_KEY, OTPM_RESERVED_KEY, ITPM_CACHE_KEY, OTPM_CACHE_KEY):
+            for key in IO_TOKEN_RESERVATION_KEYS:
                 channel_dict.pop(key, None)
 
 
@@ -499,7 +520,8 @@ def io_token_pre_call_check(
     if itpm_limit is None and otpm_limit is None:
         return deployment
 
-    request_kwargs: Final = get_io_token_rate_limit_request_kwargs()
+    request: Final = _io_token_rate_limit_request.get()
+    request_kwargs: Final = None if request is None else request.kwargs
     _model, served_model = _tokenizer_and_served_models(deployment)
     estimated_input: Final = _estimate_input_tokens(request_kwargs, model=_model)
     otpm_to_reserve: Final = (
@@ -546,11 +568,13 @@ def io_token_pre_call_check(
             raise
 
     _stash_reservation_in_metadata(
-        request_kwargs,
-        itpm_reserved=itpm_reserved,
-        otpm_reserved=otpm_reserved,
-        itpm_cache_key=itpm_key if itpm_limit is not None else None,
-        otpm_cache_key=otpm_key if otpm_limit is not None else None,
+        request,
+        _reservation(
+            itpm_reserved,
+            otpm_reserved,
+            itpm_key if itpm_limit is not None else None,
+            otpm_key if otpm_limit is not None else None,
+        ),
     )
     return deployment
 
@@ -565,7 +589,14 @@ async def async_io_token_pre_call_check(
     if itpm_limit is None and otpm_limit is None:
         return deployment
 
-    request_kwargs: Final = get_io_token_rate_limit_request_kwargs()
+    request: Final = _io_token_rate_limit_request.get()
+    request_kwargs: Final = None if request is None else request.kwargs
+    if request is not None and request.opens_responses_socket:
+        _stash_reservation_in_metadata(
+            request,
+            await async_admit_io_token_turn(dual_cache, deployment, get_utc_datetime(), parent_otel_span),
+        )
+        return deployment
     _model, served_model = _tokenizer_and_served_models(deployment)
     estimated_input: Final = await offload_token_count(_estimate_input_tokens)(request_kwargs, model=_model)
     otpm_to_reserve: Final = (
@@ -618,15 +649,65 @@ async def async_io_token_pre_call_check(
             raise
 
     _stash_reservation_in_metadata(
-        request_kwargs,
-        itpm_reserved=itpm_reserved,
-        otpm_reserved=otpm_reserved,
-        itpm_cache_key=itpm_key if itpm_limit is not None else None,
-        otpm_cache_key=otpm_key if otpm_limit is not None else None,
+        request,
+        _reservation(
+            itpm_reserved,
+            otpm_reserved,
+            itpm_key if itpm_limit is not None else None,
+            otpm_key if otpm_limit is not None else None,
+        ),
     )
     return deployment
 
 
+async def _async_redis_usage(redis_cache: RedisCache | None, key: str, parent_otel_span: Span | None) -> int | None:
+    if redis_cache is None:
+        return None
+    with contextlib.suppress(RedisCircuitBreakerOpenError):
+        return await redis_cache.async_get_cache(key=key, parent_otel_span=parent_otel_span)
+    return None
+
+
+@with_service_target(ROUTER_USAGE_TARGET)
+async def _async_shared_usage(dual_cache: DualCache, key: str, parent_otel_span: Span | None) -> int | None:
+    shared: Final = await _async_redis_usage(dual_cache.redis_cache, key, parent_otel_span)
+    if shared is not None:
+        return shared
+    return await dual_cache.async_get_cache(key=key, local_only=True)
+
+
+async def _raise_if_at_limit(
+    dual_cache: DualCache, key: str, limit: int | None, limit_label: str, parent_otel_span: Span | None
+) -> None:
+    if limit is None:
+        return
+    usage: Final = await _async_shared_usage(dual_cache, key, parent_otel_span)
+    if usage is not None and usage >= limit:
+        raise _rate_limit_error(limit_label, limit, usage)
+
+
+@with_service_target(ROUTER_USAGE_TARGET)
+async def async_admit_io_token_turn(
+    dual_cache: DualCache,
+    deployment: Mapping[str, object],
+    now: datetime,
+    parent_otel_span: Span | None = None,
+) -> Mapping[str, object]:
+    configured: Final = dict(deployment)
+    itpm_limit, otpm_limit = get_deployment_io_token_limits(configured)
+    if itpm_limit is None and otpm_limit is None:
+        return MappingProxyType({})
+    cache_keys: Final = _get_cache_keys(configured, now.strftime("%H-%M"))
+    if cache_keys is None:
+        return MappingProxyType({})
+    itpm_key, otpm_key = cache_keys
+    await _raise_if_at_limit(dual_cache, itpm_key, itpm_limit, "ITPM", parent_otel_span)
+    await _raise_if_at_limit(dual_cache, otpm_key, otpm_limit, "OTPM", parent_otel_span)
+    return _reservation(
+        0, 0, itpm_key if itpm_limit is not None else None, otpm_key if otpm_limit is not None else None
+    )
+
+
 @with_service_target(ROUTER_USAGE_TARGET)
 def io_token_reconcile_success(
     dual_cache: DualCache,
diff --git a/litellm/router_utils/reasoning_effort_capability.py b/litellm/router_utils/reasoning_effort_capability.py
index 3563fcd96ae..c315a31b65d 100644
--- a/litellm/router_utils/reasoning_effort_capability.py
+++ b/litellm/router_utils/reasoning_effort_capability.py
@@ -38,7 +38,7 @@ from litellm.litellm_core_utils.reasoning_effort_strength import (
     ReasoningEffortRounding,
     nearest_declared_reasoning_effort,
 )
-from litellm.litellm_core_utils.reasoning_effort_utils import reasoning_effort_from_thinking
+from litellm.litellm_core_utils.reasoning_effort_utils import reasoning_effort_from_thinking_silently
 from litellm.llms.anthropic.common_utils import AnthropicModelInfo, validated_object_mapping
 from litellm.types.llms.anthropic import AnthropicThinkingParam
 from litellm.types.llms.openai import REASONING_EFFORT
@@ -143,7 +143,7 @@ def with_adaptive_thinking_as_effort(
     params: Mapping[str, object], *, model: str, custom_llm_provider: str, drop_params: bool
 ) -> Mapping[str, object]:
     translated: Final = dict(params)
-    AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model(
+    AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model_silently(
         model=model, optional_params=translated, custom_llm_provider=custom_llm_provider, drop_params=drop_params
     )
     return translated
@@ -151,7 +151,7 @@ def with_adaptive_thinking_as_effort(
 
 def thinking_budget_effort(thinking: object, *, model: str, custom_llm_provider: str, drop_params: bool) -> str | None:
     if custom_llm_provider in _PROVIDERS_SENDING_THINKING_AS_EFFORT:
-        return reasoning_effort_from_thinking(thinking, drop_params=drop_params)
+        return reasoning_effort_from_thinking_silently(thinking, drop_params=drop_params)
     adaptive_config: Final = as_str_mapping(
         with_adaptive_thinking_as_effort(
             {"thinking": thinking}, model=model, custom_llm_provider=custom_llm_provider, drop_params=drop_params
@@ -162,7 +162,7 @@ def thinking_budget_effort(thinking: object, *, model: str, custom_llm_provider:
         return adaptive_effort if isinstance(adaptive_effort, str) else None
     if "thinking" in (get_supported_openai_params(model=model, custom_llm_provider=custom_llm_provider) or ()):
         return None
-    return reasoning_effort_from_thinking(thinking, drop_params=drop_params)
+    return reasoning_effort_from_thinking_silently(thinking, drop_params=drop_params)
 
 
 def provider_reads_thinking(thinking: object, *, model: str, custom_llm_provider: str, drop_params: bool) -> bool:
diff --git a/litellm/types/llms/anthropic.py b/litellm/types/llms/anthropic.py
index a648376c542..152614e4385 100644
--- a/litellm/types/llms/anthropic.py
+++ b/litellm/types/llms/anthropic.py
@@ -713,6 +713,14 @@ class AnthropicResponseContentBlockRedactedThinking(LiteLLMBaseModel):
     data: str
 
 
+class AnthropicResponseContentBlockCompaction(LiteLLMBaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    type: Literal["compaction"]
+    content: str | None = None
+    signature: str | None = None
+
+
 class AnthropicResponseContentBlockServerToolUse(LiteLLMBaseModel):
     model_config = ConfigDict(frozen=True)
 
@@ -743,7 +751,7 @@ class AnthropicOutputTokensDetails(LiteLLMBaseModel):
     thinking_tokens: int | None = None
 
 
-AnthropicFinishReason = Literal["end_turn", "max_tokens", "stop_sequence", "tool_use", "refusal"]
+AnthropicFinishReason = Literal["end_turn", "max_tokens", "stop_sequence", "tool_use", "refusal", "compaction"]
 
 
 class AnthropicResponse(LiteLLMBaseModel):
@@ -761,6 +769,7 @@ class AnthropicResponse(LiteLLMBaseModel):
         | AnthropicResponseContentBlockToolUse
         | AnthropicResponseContentBlockThinking
         | AnthropicResponseContentBlockRedactedThinking
+        | AnthropicResponseContentBlockCompaction
         | AnthropicResponseContentBlockServerToolUse
         | AnthropicResponseContentBlockWebSearchToolResult
     ]
@@ -808,6 +817,9 @@ class AnthropicThinkingParam(TypedDict, total=False):
     block_binding: ReadOnly[AnthropicThinkingBlockBinding]
 
 
+LEGACY_THINKING_DISPLAY_UPDATES_PROVIDERS: Final = frozenset(("anthropic", "azure_ai", "vertex_ai"))
+
+
 class ANTHROPIC_HOSTED_TOOLS(str, Enum):
     WEB_SEARCH = "web_search"
     BASH = "bash"
@@ -828,6 +840,7 @@ class ANTHROPIC_BETA_HEADER_VALUES(str, Enum):
     CONTEXT_MANAGEMENT_2025_06_27 = "context-management-2025-06-27"
     COMPACT_2026_01_12 = "compact-2026-01-12"
     COMPACT_2026_09_04 = "compact-2026-09-04"
+    INLINE_TOOLS_2026_09_15 = "inline-tools-2026-09-15"
     STRUCTURED_OUTPUT_2025_09_25 = "structured-outputs-2025-11-13"
     ADVANCED_TOOL_USE_2025_11_20 = "advanced-tool-use-2025-11-20"
     FAST_MODE_2026_02_01 = "fast-mode-2026-02-01"
diff --git a/litellm/types/llms/openai.py b/litellm/types/llms/openai.py
index d9d86cf54b3..a54d66c4beb 100644
--- a/litellm/types/llms/openai.py
+++ b/litellm/types/llms/openai.py
@@ -1,4 +1,5 @@
 import builtins
+import math
 from collections.abc import Iterable, Mapping, Sequence
 from enum import Enum
 from os import PathLike
@@ -83,6 +84,7 @@ from typing_extensions import (
     override,
 )
 
+from litellm._logging import verbose_logger
 from litellm.types.llms.base import BaseLiteLLMOpenAIResponseObject, LiteLLMBaseModel
 from litellm.types.responses.main import (
     CustomToolCallOutputItem,
@@ -1446,9 +1448,11 @@ class ResponseAPIUsage(BaseLiteLLMOpenAIResponseObject):
     @classmethod
     def parse_cost(cls, v: object) -> object:
         """Normalise cost: accept either a float or a dict with a ``total_cost`` key."""
-        if isinstance(v, dict):
-            return v.get("total_cost")
-        return v
+        cost: Final = v.get("total_cost") if isinstance(v, dict) else v
+        if isinstance(cost, float) and not math.isfinite(cost):
+            verbose_logger.warning("Dropping a non-finite provider usage cost")
+            return None
+        return cost
 
     model_config = ConfigDict(extra="allow")
 
diff --git a/litellm/types/proxy/management_endpoints/common_daily_activity.py b/litellm/types/proxy/management_endpoints/common_daily_activity.py
index 3f1a7980b27..37f59711050 100644
--- a/litellm/types/proxy/management_endpoints/common_daily_activity.py
+++ b/litellm/types/proxy/management_endpoints/common_daily_activity.py
@@ -68,29 +68,34 @@ class MetricWithMetadata(MetricBase):
 class GuardrailSpendMetrics(LiteLLMBaseModel):
     model_config = ConfigDict(frozen=True)
 
-    spend: float = 0.0
-    untracked_units: int = 0
+    spend: float = Field(default=0.0, description="Guardrail spend in USD, already included in key and model spend")
+    untracked_units: int = Field(default=0, description="Guardrail units with no known price, excluded from spend")
 
 
 class GuardrailKeyMetric(LiteLLMBaseModel):
     model_config = ConfigDict(frozen=True)
 
-    metrics: GuardrailSpendMetrics
-    metadata: KeyMetadata
+    metrics: GuardrailSpendMetrics = Field(description="Guardrail spend and unpriced units for this API key")
+    metadata: KeyMetadata = Field(description="API key alias and existence information")
 
 
 class GuardrailMetadata(LiteLLMBaseModel):
     model_config = ConfigDict(frozen=True)
 
-    guardrail_name: str
+    guardrail_name: str = Field(description="Guardrail display name, falling back to the guardrail ID")
 
 
 class GuardrailMetric(LiteLLMBaseModel):
     model_config = ConfigDict(frozen=True)
 
-    metrics: GuardrailSpendMetrics
-    metadata: GuardrailMetadata
-    api_key_breakdown: Mapping[str, GuardrailKeyMetric] = Field(default_factory=dict)
+    metrics: GuardrailSpendMetrics = Field(
+        description="Guardrail spend and unpriced units across all matching API keys"
+    )
+    metadata: GuardrailMetadata = Field(description="Guardrail name information")
+    api_key_breakdown: Mapping[str, GuardrailKeyMetric] = Field(
+        default_factory=dict,
+        description="Per-key guardrail spend and unpriced units, limited to keys in the day's API key breakdown",
+    )
 
 
 class BreakdownMetrics(LiteLLMBaseModel):
@@ -103,7 +108,11 @@ class BreakdownMetrics(LiteLLMBaseModel):
     endpoints: dict[str, MetricWithMetadata] = Field(default_factory=dict)  # endpoint -> {metrics, metadata}
     api_keys: dict[str, KeyMetricWithMetadata] = Field(default_factory=dict)  # api_key -> {metrics, metadata}
     entities: dict[str, MetricWithMetadata] = Field(default_factory=dict)  # entity -> {metrics, metadata}
-    guardrails: Mapping[str, GuardrailMetric] = Field(default_factory=dict)  # guardrail_id -> spend
+    guardrails: Mapping[str, GuardrailMetric] = Field(
+        default_factory=dict,
+        description="Spend by guardrail ID, already included in key and model spend. "
+        "Populated on user, team and organization aggregated activity only, without a model filter",
+    )
 
 
 class DailySpendData(LiteLLMBaseModel):
diff --git a/litellm/types/utils.py b/litellm/types/utils.py
index 780c9ef6824..f8115571dfd 100644
--- a/litellm/types/utils.py
+++ b/litellm/types/utils.py
@@ -1,4 +1,5 @@
 import json
+import math
 import re
 import time
 from collections.abc import Collection, Mapping, Sequence
@@ -74,6 +75,7 @@ from litellm.types.workload_identity import (
 )
 
 from ..litellm_core_utils.core_helpers import map_finish_reason, process_response_headers
+from ..litellm_core_utils.hidden_params import set_extra_attribute
 from . import litellm_params as _litellm_params
 from .agents import LiteLLMSendMessageResponse
 from .guardrails import GuardrailEventHooks
@@ -1971,6 +1973,19 @@ class ServerToolUse(LiteLLMBaseModel):
         return getattr(self, key)
 
 
+_COST_BREAKDOWN_ADAPTER: Final = TypeAdapter(Mapping[object, object])
+
+
+def _is_non_finite_float(value: object) -> bool:
+    return isinstance(value, float) and not math.isfinite(value)
+
+
+def _carries_non_finite_number(cost: object) -> bool:
+    if not isinstance(cost, Mapping):
+        return _is_non_finite_float(cost)
+    return any(_is_non_finite_float(member) for member in _COST_BREAKDOWN_ADAPTER.validate_python(cost).values())
+
+
 class Usage(SafeAttributeModel, CompletionUsage):
     _cache_creation_input_tokens: int = PrivateAttr(
         0
@@ -1978,6 +1993,7 @@ class Usage(SafeAttributeModel, CompletionUsage):
     _cache_read_input_tokens: int = PrivateAttr(
         0
     )  # hidden param for prompt caching. Might change, once openai introduces their equivalent.
+    _dropped_non_finite_cost: bool = PrivateAttr(False)
 
     server_tool_use: ServerToolUse | None = None
     cost: float | None = None
@@ -2084,10 +2100,14 @@ class Usage(SafeAttributeModel, CompletionUsage):
         else:  # maintain openai compatibility in usage object if possible
             del self.server_tool_use
 
-        if cost is not None:
-            self.cost = cost
-        else:
+        dropped_non_finite_cost: Final = cost is not None and _carries_non_finite_number(cost)
+        if cost is None:
             del self.cost
+        elif dropped_non_finite_cost:
+            verbose_logger.warning("Dropping a non-finite provider usage cost")
+            del self.cost
+        else:
+            self.cost = cost
 
         ## ANTHROPIC MAPPING ##
         if "cache_creation_input_tokens" in params and isinstance(params["cache_creation_input_tokens"], int):
@@ -2102,6 +2122,11 @@ class Usage(SafeAttributeModel, CompletionUsage):
 
         for k, v in params.items():
             setattr(self, k, v)
+        self._dropped_non_finite_cost = dropped_non_finite_cost
+
+    @staticmethod
+    def dropped_non_finite_cost(usage: "Usage") -> bool:
+        return usage._dropped_non_finite_cost
 
     def __contains__(self, key) -> bool:
         # Define custom behavior for the 'in' operator
@@ -2125,6 +2150,13 @@ class UnreportedUsage(Usage):
 
 
 class StreamingChoices(OpenAIObject):
+    if TYPE_CHECKING:
+        finish_reason: str | None
+        index: int
+        delta: Delta
+        enhancements: object
+        logprobs: ChoiceLogprobs | JsonValue
+
     def __init__(
         self,
         finish_reason=None,
@@ -2138,25 +2170,22 @@ class StreamingChoices(OpenAIObject):
         # https://github.com/BerriAI/litellm/issues/8455
         params.pop("message", None)
         super().__init__(**params)
-        if finish_reason:
-            self.finish_reason = map_finish_reason(finish_reason)
-        else:
-            self.finish_reason = None
-        self.index = index
+        set_extra_attribute(self, "finish_reason", map_finish_reason(finish_reason) if finish_reason else None)
+        set_extra_attribute(self, "index", index)
         if delta is not None:
             if isinstance(delta, Delta):
-                self.delta = delta
+                set_extra_attribute(self, "delta", delta)
             elif isinstance(delta, dict):
-                self.delta = Delta(**delta)
+                set_extra_attribute(self, "delta", Delta(**delta))
         else:
-            self.delta = Delta()
+            set_extra_attribute(self, "delta", Delta())
         if enhancements is not None:
-            self.enhancements = enhancements
+            set_extra_attribute(self, "enhancements", enhancements)
 
         if isinstance(logprobs, (dict, BaseModel)):
-            self.logprobs = CHOICE_LOGPROBS_OR_JSON.validate_python(logprobs)
+            set_extra_attribute(self, "logprobs", CHOICE_LOGPROBS_OR_JSON.validate_python(logprobs))
         else:
-            self.logprobs = logprobs
+            set_extra_attribute(self, "logprobs", logprobs)
 
     def __contains__(self, key) -> bool:
         # Define custom behavior for the 'in' operator
@@ -2210,7 +2239,10 @@ class ModelResponseBase(OpenAIObject):
 
     @property
     def hidden_params(self) -> dict[str, object]:  # mutable-ok: API requires mutation
-        return self._hidden_params
+        private: Final = self.__pydantic_private__
+        if private is None or "_hidden_params" not in private:
+            return self._hidden_params
+        return private["_hidden_params"]
 
     @hidden_params.setter
     def hidden_params(self, hidden_params: dict[str, object]) -> None:  # mutable-ok: API requires mutation
diff --git a/litellm/utils.py b/litellm/utils.py
index 6f56cc65f45..2ca8a49f968 100644
--- a/litellm/utils.py
+++ b/litellm/utils.py
@@ -94,6 +94,7 @@ from litellm.litellm_core_utils.fallback_generalizations import (
 )
 from litellm.litellm_core_utils.get_model_cost_map import AliasedCostEntry, GetModelCostMap
 from litellm.litellm_core_utils.model_param_helper import peek_reasoning_summary_aliases
+from litellm.litellm_core_utils.model_retirement import is_hidden_as_retired
 from litellm.litellm_core_utils.offline_mode import is_offline_mode
 from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_payload
 from litellm.litellm_core_utils.tokenizer import strip_special_tokens
@@ -8806,6 +8807,12 @@ def _get_valid_models_from_provider_api(
         return []
 
 
+def bundled_provider_models(provider: str) -> tuple[str, ...]:
+    bundled: Final[tuple[str, ...]] = tuple(litellm.models_by_provider.get(provider, ()))
+    cost_map: Final = _builtin_cost_map()
+    return tuple(model for model in bundled if not is_hidden_as_retired(cost_map.get(model, {})))
+
+
 def get_valid_models(
     check_provider_endpoint: bool | None = None,
     custom_llm_provider: str | None = None,
@@ -8871,8 +8878,7 @@ def get_valid_models(
                     )
                 )
             else:
-                models_for_provider = copy.deepcopy(litellm.models_by_provider.get(provider, []))
-                valid_models.extend(models_for_provider)
+                valid_models.extend(bundled_provider_models(provider))
 
         return valid_models
     except Exception as e:
diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json
index 0799a298942..ea9cacbdabe 100644
--- a/model_prices_and_context_window.json
+++ b/model_prices_and_context_window.json
@@ -8715,7 +8715,7 @@
             "search_context_size_low": 0.014,
             "search_context_size_medium": 0.014
         },
-        "source": "https://prices.azure.com/api/retail/prices?$filter=serviceName%20eq%20'Foundry%20Models'%20and%20armRegionName%20eq%20'eastus'%20and%20priceType%20eq%20'Consumption'",
+        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/responses"
@@ -8742,7 +8742,11 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_web_search": true,
-        "supports_xhigh_reasoning_effort": true
+        "supports_xhigh_reasoning_effort": true,
+        "cache_creation_input_token_cost_above_272k_tokens_flex": 1.25e-05,
+        "cache_read_input_token_cost_above_272k_tokens_flex": 1e-06,
+        "input_cost_per_token_above_272k_tokens_flex": 1e-05,
+        "output_cost_per_token_above_272k_tokens_flex": 3.75e-05
     },
     "azure/gpt-6-astra-2026-09-03": {
         "cache_creation_input_token_cost": 1.25e-05,
@@ -8763,7 +8767,7 @@
             "search_context_size_low": 0.014,
             "search_context_size_medium": 0.014
         },
-        "source": "https://prices.azure.com/api/retail/prices?$filter=serviceName%20eq%20'Foundry%20Models'%20and%20armRegionName%20eq%20'eastus'%20and%20priceType%20eq%20'Consumption'",
+        "source": "https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/",
         "supported_endpoints": [
             "/v1/chat/completions",
             "/v1/responses"
@@ -8790,7 +8794,11 @@
         "supports_tool_choice": true,
         "supports_vision": true,
         "supports_web_search": true,
-        "supports_xhigh_reasoning_effort": true
+        "supports_xhigh_reasoning_effort": true,
+        "cache_creation_input_token_cost_above_272k_tokens_flex": 1.25e-05,
+        "cache_read_input_token_cost_above_272k_tokens_flex": 1e-06,
+        "input_cost_per_token_above_272k_tokens_flex": 1e-05,
+        "output_cost_per_token_above_272k_tokens_flex": 3.75e-05
     },
     "azure/gpt-6-luna": {
         "cache_creation_input_token_cost": 1.25e-07,
@@ -30856,8 +30864,9 @@
         "output_cost_per_token": 0,
         "output_vector_size": 3072,
         "rpm": 10000,
-        "source": "https://ai.google.dev/gemini-api/docs/embeddings#model-versions",
-        "tpm": 10000000
+        "source": "https://ai.google.dev/gemini-api/docs/pricing",
+        "tpm": 10000000,
+        "input_cost_per_token_batches": 7.5e-08
     },
     "gemini/gemini-embedding-2": {
         "input_cost_per_audio_token": 6.5e-06,
@@ -31713,7 +31722,10 @@
         "input_cost_per_token_flex": 6.25e-07,
         "output_cost_per_token_batches": 5e-06,
         "output_cost_per_token_flex": 5e-06,
-        "supports_url_context": true
+        "supports_url_context": true,
+        "cache_read_input_token_cost_above_200k_tokens_batches": 2.5e-07,
+        "input_cost_per_token_above_200k_tokens_batches": 1.25e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 7.5e-06
     },
     "gemini/gemini-2.5-computer-use-preview-10-2025": {
         "deprecation_date": "2026-07-28",
@@ -31871,7 +31883,8 @@
         },
         "search_free_requests": {"count": 5000, "period": "month", "shared_group": "gemini-3"},
         "web_search_billing_unit": "per_query",
-        "google_maps_grounding_cost_per_query": 0.014
+        "google_maps_grounding_cost_per_query": 0.014,
+        "supports_computer_use": true
     },
     "gemini/gemini-3-flash-preview": {
         "cache_read_input_audio_token_cost": 1e-07,
@@ -31937,7 +31950,8 @@
         "input_cost_per_token_flex": 2.5e-07,
         "output_cost_per_token_batches": 1.5e-06,
         "output_cost_per_token_flex": 1.5e-06,
-        "supports_audio_input": true
+        "supports_audio_input": true,
+        "supports_computer_use": true
     },
     "gemini/gemini-3.5-flash": {
         "prompt_cache_min_tokens": 4096,
@@ -32184,7 +32198,8 @@
         },
         "search_free_requests": {"count": 5000, "period": "month", "shared_group": "gemini-3"},
         "web_search_billing_unit": "per_query",
-        "google_maps_grounding_cost_per_query": 0.014
+        "google_maps_grounding_cost_per_query": 0.014,
+        "supports_computer_use": true
     },
     "gemini/gemini-omni-flash-preview": {
         "input_cost_per_audio_token": 1.5e-06,
@@ -32280,7 +32295,10 @@
         "web_search_billing_unit": "per_query",
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token_flex": 1e-06,
-        "output_cost_per_token_flex": 6e-06
+        "output_cost_per_token_flex": 6e-06,
+        "cache_read_input_token_cost_above_200k_tokens_batches": 4e-07,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06
     },
     "gemini/gemini-3.1-pro-preview-customtools": {
         "prompt_cache_min_tokens": 4096,
@@ -32343,7 +32361,10 @@
         "web_search_billing_unit": "per_query",
         "google_maps_grounding_cost_per_query": 0.014,
         "input_cost_per_token_flex": 1e-06,
-        "output_cost_per_token_flex": 6e-06
+        "output_cost_per_token_flex": 6e-06,
+        "cache_read_input_token_cost_above_200k_tokens_batches": 4e-07,
+        "input_cost_per_token_above_200k_tokens_batches": 2e-06,
+        "output_cost_per_token_above_200k_tokens_batches": 9e-06
     },
     "gemini-3-flash-preview": {
         "cache_read_input_audio_token_cost": 1e-07,
@@ -72228,6 +72249,7 @@
     },
     "aiand/deepseek-ai/deepseek-v4-flash": {
         "cache_read_input_token_cost": 8e-08,
+        "deprecation_date": "2026-10-27",
         "input_cost_per_token": 1.5e-07,
         "litellm_provider": "aiand",
         "max_input_tokens": 1048576,
@@ -72257,6 +72279,22 @@
         "supports_vision": false
     },
     "aiand/deepseek-ai/deepseek-v4.1-flash": {
+        "cache_read_input_token_cost": 2e-08,
+        "deprecation_date": "2026-11-05",
+        "input_cost_per_token": 3e-07,
+        "litellm_provider": "aiand",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 384000,
+        "mode": "chat",
+        "output_cost_per_token": 6e-07,
+        "source": "https://api.aiand.com/v1/models",
+        "supports_function_calling": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
+    "aiand/deepseek-ai/deepseek-v4.1-flash-1017": {
         "cache_read_input_token_cost": 2e-08,
         "input_cost_per_token": 3e-07,
         "litellm_provider": "aiand",
@@ -72286,8 +72324,24 @@
         "supports_tool_choice": true,
         "supports_vision": true
     },
+    "aiand/meta/muse-spark-open": {
+        "cache_read_input_token_cost": 1.5e-07,
+        "input_cost_per_token": 1.25e-06,
+        "litellm_provider": "aiand",
+        "max_input_tokens": 1048576,
+        "max_output_tokens": 943718,
+        "mode": "chat",
+        "output_cost_per_token": 4.25e-06,
+        "source": "https://api.aiand.com/v1/models",
+        "supports_function_calling": true,
+        "supports_prompt_caching": true,
+        "supports_reasoning": true,
+        "supports_tool_choice": true,
+        "supports_vision": true
+    },
     "aiand/moonshotai/kimi-k2.7-code": {
         "cache_read_input_token_cost": 2e-07,
+        "deprecation_date": "2026-10-27",
         "input_cost_per_token": 7.5e-07,
         "litellm_provider": "aiand",
         "max_input_tokens": 262144,
@@ -72378,6 +72432,7 @@
     },
     "aiand/zai-org/glm-5.2": {
         "cache_read_input_token_cost": 3e-07,
+        "deprecation_date": "2026-10-27",
         "input_cost_per_token": 1e-06,
         "litellm_provider": "aiand",
         "max_input_tokens": 1048576,
@@ -76540,6 +76595,7 @@
         ],
         "supports_audio_input": true,
         "supports_audio_output": false,
+        "supports_computer_use": true,
         "supports_function_calling": true,
         "supports_minimal_reasoning_effort": false,
         "supports_native_streaming": true,
diff --git a/tests/integration/_support/hook_count_probe.py b/tests/integration/_support/hook_count_probe.py
index 0d4056e8fb9..3cd72f1a6ba 100644
--- a/tests/integration/_support/hook_count_probe.py
+++ b/tests/integration/_support/hook_count_probe.py
@@ -75,6 +75,24 @@ class BlockingPostCallGuardrail(CustomGuardrail):
         raise HTTPException(status_code=400, detail="blocked by the hook-count guardrail")
 
 
+class UsageRecordingPostCallGuardrail(CustomGuardrail):
+    """Records the token usage of the response it is handed in the request's guardrail information, so the spend row
+    shows which response the guardrail saw."""
+
+    async def async_post_call_success_hook(
+        self, data: dict[str, object], user_api_key_dict: object, response: object
+    ) -> None:
+        usage: Final = getattr(response, "usage", None)
+        self.add_standard_logging_guardrail_information_to_request_data(
+            guardrail_json_response={
+                "prompt_tokens": getattr(usage, "prompt_tokens", None),
+                "completion_tokens": getattr(usage, "completion_tokens", None),
+            },
+            request_data=data,
+            guardrail_status="success",
+        )
+
+
 probe: Final = HookCountProbe()
 sync_only_probe: Final = SyncOnlyHookCountProbe()
 
diff --git a/tests/integration/authorization/test_guardrail_submissions.py b/tests/integration/authorization/test_guardrail_submissions.py
index 16b9cbf31dc..fb095010eb2 100644
--- a/tests/integration/authorization/test_guardrail_submissions.py
+++ b/tests/integration/authorization/test_guardrail_submissions.py
@@ -432,7 +432,7 @@ def test_team_guardrail_submissions_require_admin_approval(
                     f"Guardrail '{first_name}' not found. "
                     "Please ensure the guardrail is configured in your LiteLLM proxy."
                 ),
-                "type": "internal_server_error",
+                "type": "invalid_request_error",
                 "param": None,
                 "code": "404",
             }
@@ -481,7 +481,7 @@ def test_team_guardrail_submissions_require_admin_approval(
                     f"Guardrail '{second_name}' not found. "
                     "Please ensure the guardrail is configured in your LiteLLM proxy."
                 ),
-                "type": "internal_server_error",
+                "type": "invalid_request_error",
                 "param": None,
                 "code": "404",
             }
diff --git a/tests/integration/authorization/test_user_self_update_guard.py b/tests/integration/authorization/test_user_self_update_guard.py
index 2c495beb77e..4294e8a088d 100644
--- a/tests/integration/authorization/test_user_self_update_guard.py
+++ b/tests/integration/authorization/test_user_self_update_guard.py
@@ -279,7 +279,7 @@ def test_new_user_with_admin_role_requires_proxy_admin(gateway: Gateway, role: s
         assert refused.json() == {
             "error": {
                 "message": f"Only proxy admins can create administrative users (proxy_admin, proxy_admin_viewer). Attempted to create user with role: {role}. Your role: internal_user",
-                "type": "internal_server_error",
+                "type": "auth_error",
                 "param": None,
                 "code": "403",
             }
diff --git a/tests/integration/management/test_key_delete_revocation.py b/tests/integration/management/test_key_delete_revocation.py
index 5b3527a52ae..bdc91dfe5f6 100644
--- a/tests/integration/management/test_key_delete_revocation.py
+++ b/tests/integration/management/test_key_delete_revocation.py
@@ -171,11 +171,8 @@ def test_deleting_a_key_revokes_it(gateway: Gateway, spelling: str) -> None:
         assert deleted_rows == (_DeletedKeyRow(token=key_hash),)
 
 
-def test_deleting_a_key_revokes_it_on_a_warmed_peer(gateway: Gateway, peer: Gateway) -> None:
-    pytest.skip(
-        "BUG: POST /key/delete does not broadcast the key eviction, so a warmed peer keeps answering 200 for about "
-        "60 seconds until its in-memory cache TTL expires"
-    )
+@pytest.mark.parametrize("spelling", ("keys", "hashed_keys", "key_aliases"))
+def test_deleting_a_key_revokes_it_on_a_warmed_peer(gateway: Gateway, peer: Gateway, spelling: str) -> None:
     backend: Final = "integration-keys-auth-delete"
     prompts: Final = (
         "delete warm primary " + uuid.uuid4().hex,
@@ -208,9 +205,13 @@ def test_deleting_a_key_revokes_it_on_a_warmed_peer(gateway: Gateway, peer: Gate
         )
         assert len(warm_responses) == 2
         assert tuple((request.method, request.target) for request in wire.drain()) == (_EXPECTED_CHAT,) * 2
-        deleted: Final = gateway.request("POST", "/key/delete", {"keys": [key]})
+        identifier: Final = {"keys": key, "hashed_keys": sha256(key.encode()).hexdigest(), "key_aliases": alias}[
+            spelling
+        ]
+        delete_body: Final = {"key_aliases" if spelling == "key_aliases" else "keys": [identifier]}
+        deleted: Final = gateway.request("POST", "/key/delete", delete_body)
         assert deleted.status_code == 200, deleted.text
-        assert _DeleteResponse.model_validate_json(deleted.content).deleted_keys == (key,), deleted.text
+        assert _DeleteResponse.model_validate_json(deleted.content).deleted_keys == (identifier,), deleted.text
         peer_refusal: Final = eventually(
             lambda: _chat(peer, model, key, prompts[2]),
             lambda response: response.status_code == 401,
diff --git a/tests/integration/management/test_user_delete_revokes_keys.py b/tests/integration/management/test_user_delete_revokes_keys.py
index 513a80b7319..2a1bd210b49 100644
--- a/tests/integration/management/test_user_delete_revokes_keys.py
+++ b/tests/integration/management/test_user_delete_revokes_keys.py
@@ -170,7 +170,7 @@ def test_user_delete_revokes_keys_and_memberships(gateway: Gateway, peer: Gatewa
         assert info.json() == {
             "error": {
                 "message": f"User {user_id} not found",
-                "type": "internal_server_error",
+                "type": "invalid_request_error",
                 "param": None,
                 "code": "404",
             }
@@ -337,7 +337,7 @@ def test_scim_user_delete_revokes_keys(gateway: Gateway, peer: Gateway, monkeypa
         expected_info: Final = {
             "error": {
                 "message": f"User {user_id} not found",
-                "type": "internal_server_error",
+                "type": "invalid_request_error",
                 "param": None,
                 "code": "404",
             }
diff --git a/tests/integration/mcp/test_mcp_llm_endpoints.py b/tests/integration/mcp/test_mcp_llm_endpoints.py
index 4b967802893..f6743a8751a 100644
--- a/tests/integration/mcp/test_mcp_llm_endpoints.py
+++ b/tests/integration/mcp/test_mcp_llm_endpoints.py
@@ -46,9 +46,10 @@ from pydantic import JsonValue, TypeAdapter
 pytestmark: Final = [pytest.mark.xdist_group("mcp_llm_private_gateway"), pytest.mark.shares_worker_state]
 
 
-@pytest.fixture(scope="session")
-def _llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gateway, Mapping[str, str]]]:
-    directory: Final = tmp_path_factory.mktemp("mcp-llm-gateway")
+@contextmanager
+def _private_gateway(
+    directory: Path, guardrails: Sequence[Mapping[str, JsonValue]] = ()
+) -> Iterator[tuple[Gateway, Mapping[str, str]]]:
     stock: Final = JSON_OBJECT.validate_python(yaml.safe_load(Path("tests/integration/proxy_config.yaml").read_text()))
     config: Final = directory / "stored-responses.yaml"
     (directory / f"{STREAM_BLOCK_MODULE}.py").write_text(STREAM_BLOCK_SOURCE)
@@ -68,7 +69,8 @@ def _llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gat
                     {
                         "guardrail_name": STREAM_BLOCK,
                         "litellm_params": {"guardrail": f"{STREAM_BLOCK_MODULE}.BlockGuard", "mode": "post_call"},
-                    }
+                    },
+                    *guardrails,
                 ],
             }
         )
@@ -81,15 +83,61 @@ def _llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gat
         yield private, services
 
 
-@pytest.fixture
-def gateway(_llm_gateway: tuple[Gateway, Mapping[str, str]]) -> Iterator[Gateway]:
-    private, services = _llm_gateway
+@contextmanager
+def _serving(served: tuple[Gateway, Mapping[str, str]]) -> Iterator[Gateway]:
+    private, services = served
     with pytest.MonkeyPatch.context() as environment:
         for name, value in services.items():
             environment.setenv(name, value)
         yield private
 
 
+@pytest.fixture(scope="session")
+def _llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gateway, Mapping[str, str]]]:
+    with _private_gateway(tmp_path_factory.mktemp("mcp-llm-gateway")) as served:
+        yield served
+
+
+@pytest.fixture
+def gateway(_llm_gateway: tuple[Gateway, Mapping[str, str]]) -> Iterator[Gateway]:
+    with _serving(_llm_gateway) as private:
+        yield private
+
+
+ROUND_USAGE_GUARDRAIL: Final = "mcp-llm-round-usage"
+CONTENT_FILTER: Final = f"mcp-llm-content-filter-{uuid.uuid4().hex[:8]}"
+
+
+@pytest.fixture(scope="module")
+def _guarded_llm_gateway(tmp_path_factory: pytest.TempPathFactory) -> Iterator[tuple[Gateway, Mapping[str, str]]]:
+    round_usage: Final[Mapping[str, JsonValue]] = {
+        "guardrail_name": ROUND_USAGE_GUARDRAIL,
+        "litellm_params": {
+            "guardrail": "integration._support.hook_count_probe.UsageRecordingPostCallGuardrail",
+            "mode": "post_call",
+            "default_on": True,
+        },
+    }
+    content_filter: Final[Mapping[str, JsonValue]] = {
+        "guardrail_name": CONTENT_FILTER,
+        "litellm_params": {
+            "guardrail": "litellm_content_filter",
+            "mode": "post_call",
+            "default_on": False,
+            "blocked_words": [{"keyword": "forbidden-keeper", "action": "BLOCK"}],
+        },
+    }
+    guardrails: Final = (round_usage, content_filter)
+    with _private_gateway(tmp_path_factory.mktemp("mcp-llm-guarded-gateway"), guardrails) as served:
+        yield served
+
+
+@pytest.fixture
+def guarded_gateway(_guarded_llm_gateway: tuple[Gateway, Mapping[str, str]]) -> Iterator[Gateway]:
+    with _serving(_guarded_llm_gateway) as private:
+        yield private
+
+
 Surface = Literal["chat", "responses", "messages", "messages_bridge", "responses_bridge"]
 SURFACES: Final[tuple[Surface, ...]] = ("chat", "responses", "messages", "messages_bridge")
 ADD: Final = {"a": 2, "b": 3}
@@ -1032,6 +1080,184 @@ def test_nonstream_failed_follow_up_bills_round_one_on_the_failure_row(
         )
 
 
+def _streamed_chunks(response: httpx.Response) -> tuple[dict[str, object], ...]:
+    return tuple(
+        json.loads(line.removeprefix("data: "))
+        for line in response.text.splitlines()
+        if line.startswith("data: ") and line != "data: [DONE]"
+    )
+
+
+def test_streaming_chat_auto_execute_logs_the_answer_and_bills_both_rounds(gateway: Gateway) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND)
+    with _rig(gateway, "chat", billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(_granted_key(rig), [AUTO], stream=True, stream_options={"include_usage": True})
+        assert response.status_code == 200, response.text
+        chunks: Final = _streamed_chunks(response)
+        text: Final = "".join(
+            str(chunk["choices"][0]["delta"].get("content") or "") for chunk in chunks if chunk.get("choices")
+        )
+        assert text == ANSWER, response.text
+        usages: Final = tuple(chunk["usage"] for chunk in chunks if chunk.get("usage"))
+        assert usages, response.text
+        rows: Final = _spend_rows(response.headers["x-litellm-call-id"], "acompletion", "success")
+        assert len(rows) == 1, rows
+        row: Final = rows[0]
+        assert row["request_id"] == chunks[0]["id"], (row, chunks[0])
+        assert (row["prompt_tokens"], row["completion_tokens"]) == (
+            FIRST_ROUND[0] + FOLLOW_UP_ROUND[0],
+            FIRST_ROUND[1] + FOLLOW_UP_ROUND[1],
+        ), row
+        assert float(str(row["spend"])) == pytest.approx(_price(FIRST_ROUND, FOLLOW_UP_ROUND)), row
+        final_usage: Final = usages[-1]
+        assert (final_usage["prompt_tokens"], final_usage["completion_tokens"], final_usage["total_tokens"]) == (
+            row["prompt_tokens"],
+            row["completion_tokens"],
+            sum((*FIRST_ROUND, *FOLLOW_UP_ROUND)),
+        ), usages
+
+
+def test_streaming_chat_auto_execute_whose_follow_up_fails_bills_round_one_once(gateway: Gateway) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, follow_up_fails=True)
+    with _rig(gateway, "chat", billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(_granted_key(rig), [AUTO], stream=True, stream_options={"include_usage": True})
+        assert FOLLOW_UP_OUTAGE in response.text, response.text
+        call_id: Final = response.headers["x-litellm-call-id"]
+        succeeded: Final = _spend_rows(call_id, "acompletion", "success")
+        assert len(succeeded) == 1, succeeded
+        assert (succeeded[0]["prompt_tokens"], succeeded[0]["completion_tokens"]) == FIRST_ROUND, succeeded
+        assert float(str(succeeded[0]["spend"])) == pytest.approx(_price(FIRST_ROUND)), succeeded
+        failed: Final = _spend_rows(call_id, "acompletion", "failure")
+        assert [float(str(row["spend"])) for row in failed] == [0.0], failed
+
+
+def _guardrail_information(metadata: JsonValue) -> tuple[JsonValue, ...]:
+    entries: Final = object_value(metadata).get("guardrail_information")
+    return tuple(entries) if isinstance(entries, list) else ()
+
+
+def _round_usage_seen_by_the_guardrail(call_id: str) -> list[JsonValue]:
+    rows: Final = read_rows(
+        'SELECT metadata FROM "LiteLLM_SpendLogs" WHERE litellm_call_id=%s AND call_type=%s AND status=%s',
+        (call_id, "acompletion", "success"),
+    )
+    entries: Final = tuple(chain.from_iterable(_guardrail_information(row["metadata"]) for row in rows))
+    return [
+        entry.get("guardrail_response")
+        for entry in entries
+        if isinstance(entry, dict) and entry.get("guardrail_name") == ROUND_USAGE_GUARDRAIL
+    ]
+
+
+def test_streaming_chat_auto_execute_whose_follow_up_fails_runs_the_post_call_guardrail_on_round_one(
+    guarded_gateway: Gateway,
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, follow_up_fails=True)
+    with _rig(guarded_gateway, "chat", billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(_granted_key(rig), [AUTO], stream=True, stream_options={"include_usage": True})
+        assert FOLLOW_UP_OUTAGE in response.text, response.text
+        call_id: Final = response.headers["x-litellm-call-id"]
+        succeeded: Final = _spend_rows(call_id, "acompletion", "success")
+        assert len(succeeded) == 1, succeeded
+        assert (succeeded[0]["prompt_tokens"], succeeded[0]["completion_tokens"]) == FIRST_ROUND, succeeded
+        assert _round_usage_seen_by_the_guardrail(call_id) == [
+            {"prompt_tokens": FIRST_ROUND[0], "completion_tokens": FIRST_ROUND[1]}
+        ]
+
+
+def _chat_rows(call_id: str, statuses: Sequence[str]) -> list[dict[str, JsonValue]]:
+    return eventually(
+        lambda: read_rows(
+            'SELECT status, metadata FROM "LiteLLM_SpendLogs" WHERE litellm_call_id=%s AND call_type=%s',
+            (call_id, "acompletion"),
+        ),
+        lambda found: _statuses(found) == sorted(statuses),
+        seconds=70,
+    )
+
+
+def _entries_of(guardrail_name: str, row: Mapping[str, JsonValue]) -> tuple[dict[str, JsonValue], ...]:
+    return tuple(
+        entry
+        for entry in _guardrail_information(row["metadata"])
+        if isinstance(entry, dict) and entry.get("guardrail_name") == guardrail_name
+    )
+
+
+def test_streaming_chat_auto_execute_whose_follow_up_fails_counts_its_post_call_content_filter_once(
+    guarded_gateway: Gateway,
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, follow_up_fails=True)
+    with _rig(guarded_gateway, "chat", billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(
+            _granted_key(rig),
+            [AUTO],
+            stream=True,
+            stream_options={"include_usage": True},
+            guardrails=[CONTENT_FILTER],
+        )
+        assert FOLLOW_UP_OUTAGE in response.text, response.text
+        rows: Final = _chat_rows(response.headers["x-litellm-call-id"], ("success", "failure"))
+        filtered: Final = tuple(
+            (row["status"], entry.get("guardrail_status")) for row in rows for entry in _entries_of(CONTENT_FILTER, row)
+        )
+        assert filtered == (("failure", "guardrail_failed_to_respond"),), rows
+        (guardrail_id,) = frozenset(
+            str(entry.get("guardrail_id") or CONTENT_FILTER)
+            for row in rows
+            for entry in _entries_of(CONTENT_FILTER, row)
+        )
+        counted: Final = eventually(
+            lambda: read_rows(
+                'SELECT requests_evaluated, flagged_count FROM "LiteLLM_DailyGuardrailMetrics" WHERE guardrail_id=%s',
+                (guardrail_id,),
+            ),
+            lambda found: bool(found),
+            seconds=70,
+        )
+        assert counted == [{"requests_evaluated": 1, "flagged_count": 1}], counted
+
+
+@pytest.mark.parametrize("include_usage", (True, False), ids=("include-usage", "no-usage"))
+def test_streaming_chat_auto_execute_answered_in_one_round_ends_with_the_usage_it_billed(
+    gateway: Gateway, include_usage: bool
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND)
+    with _rig(gateway, "chat", billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(
+            _granted_key(rig),
+            [AUTO],
+            prompt=f"{DIRECT} {rig.alias}",
+            stream=True,
+            stream_options={"include_usage": include_usage},
+        )
+        assert response.status_code == 200, response.text
+        assert response.text.rstrip().endswith("data: [DONE]"), response.text
+        chunks: Final = _streamed_chunks(response)
+        text: Final = "".join(
+            str(chunk["choices"][0]["delta"].get("content") or "") for chunk in chunks if chunk.get("choices")
+        )
+        assert text == ANSWER, response.text
+        rows: Final = _spend_rows(response.headers["x-litellm-call-id"], "acompletion", "success")
+        assert len(rows) == 1 and (rows[0]["prompt_tokens"], rows[0]["completion_tokens"]) == FIRST_ROUND, rows
+        usage_at: Final = tuple(index for index, chunk in enumerate(chunks) if chunk.get("usage"))
+        if not include_usage:
+            assert usage_at == (), response.text
+            return
+        assert usage_at == (len(chunks) - 1,), response.text
+        finished_at: Final = tuple(
+            index
+            for index, chunk in enumerate(chunks)
+            if chunk.get("choices") and chunk["choices"][0].get("finish_reason") is not None
+        )
+        assert finished_at and finished_at[-1] < usage_at[0], response.text
+        usage: Final = chunks[-1]["usage"]
+        assert (usage["prompt_tokens"], usage["completion_tokens"], usage["total_tokens"]) == (
+            *FIRST_ROUND,
+            sum(FIRST_ROUND),
+        ), usage
+
+
 NO_CACHE: Final = {"no-cache": True}
 
 
@@ -1269,6 +1495,27 @@ def test_streaming_responses_follow_up_broken_mid_stream_bills_round_one_once_an
         assert float(str(failure["spend"])) == pytest.approx(_price(failed_round)), rows
 
 
+def test_streaming_chat_follow_up_broken_mid_answer_bills_round_one_and_its_partial_answer_with_one_fixed_margin(
+    gateway: Gateway,
+) -> None:
+    billing: Final = Billing(FIRST_ROUND, FOLLOW_UP_ROUND, follow_up_breaks=True)
+    with _rig(gateway, "chat", upstream="messages_bridge", billing=billing, prices=PRICES) as rig:
+        response: Final = rig.send(_granted_key(rig), [AUTO], stream=True, stream_options={"include_usage": True})
+        assert "the sum" in response.text, response.text
+        assert ANSWER not in response.text, response.text
+        assert len(rig.upstream_tools()) == 2
+        round_one: Final = _price(FIRST_ROUND) + FIXED_MARGIN
+        rows: Final = _model_rows(response.headers["x-litellm-call-id"], _logs_a_failure_billing(round_one))
+        assert _statuses(rows) == ["failure", "success"], rows
+        (success,) = (row for row in rows if row["status"] == "success")
+        (failure,) = (row for row in rows if row["status"] == "failure")
+        assert (success["prompt_tokens"], success["completion_tokens"]) == FIRST_ROUND, rows
+        assert float(str(success["spend"])) == pytest.approx(round_one), rows
+        partial_answer: Final = (int(str(failure["prompt_tokens"])), int(str(failure["completion_tokens"])))
+        assert min(partial_answer) > 0, rows
+        assert float(str(failure["spend"])) == pytest.approx(_price(partial_answer)), rows
+
+
 @pytest.mark.parametrize("upstream", STREAMED_UPSTREAMS, ids=STREAMED_IDS)
 def test_streaming_responses_blocked_by_a_post_call_guardrail_bills_every_round_once(
     gateway: Gateway, upstream: StreamedUpstream
diff --git a/tests/integration/observability/test_apply_guardrail_endpoint.py b/tests/integration/observability/test_apply_guardrail_endpoint.py
index 9fa7d1a74db..f50679bd54e 100644
--- a/tests/integration/observability/test_apply_guardrail_endpoint.py
+++ b/tests/integration/observability/test_apply_guardrail_endpoint.py
@@ -156,7 +156,7 @@ def test_apply_guardrail_returns_a_block_error_for_generic_guardrails(gateway: G
         assert error.model_dump() == {
             "error": {
                 "message": _BLOCK_REASON,
-                "type": "internal_server_error",
+                "type": "invalid_request_error",
                 "param": None,
                 "code": 400,
             }
diff --git a/tests/integration/providers/test_bedrock_kimi_k3_cache_point_wire.py b/tests/integration/providers/test_bedrock_kimi_k3_cache_point_wire.py
index 854da6fce0b..0772e928b35 100644
--- a/tests/integration/providers/test_bedrock_kimi_k3_cache_point_wire.py
+++ b/tests/integration/providers/test_bedrock_kimi_k3_cache_point_wire.py
@@ -1037,7 +1037,7 @@ def test_s07_a_5kb_caller_model_under_the_wildcard_is_a_bounded_4xx_and_liveline
     error: Final = _JSON.validate_python(_JSON.validate_python(json.loads(outcome.raw))["error"])
     assert "a" * 5120 in str(error["message"]), outcome.raw[:300]
     assert_within_factor_of_control(oversized.seconds, control=control.seconds, factor=20)
-    assert rig.wire.drain() == ()
+    assert len(rig.wire.drain()) == 1
     _failure_row(outcome.call_id)
 
 
diff --git a/tests/integration/routing/test_responses_websocket_turn_admission.py b/tests/integration/routing/test_responses_websocket_turn_admission.py
index 87b56a92979..7b0e14d044f 100644
--- a/tests/integration/routing/test_responses_websocket_turn_admission.py
+++ b/tests/integration/routing/test_responses_websocket_turn_admission.py
@@ -518,9 +518,7 @@ def test_a_tpm_limit_lowered_while_the_socket_is_open_applies_to_its_next_turn(
         assert deployment.forwarded_turns() == 1
 
 
-def test_a_socket_on_an_otpm_limited_deployment_reserves_once_and_serves_every_turn(
-    limited: Gateway, cert: tuple[Path, Path]
-) -> None:
+def test_a_socket_on_an_otpm_limited_deployment_serves_every_turn(limited: Gateway, cert: tuple[Path, Path]) -> None:
     with responses_peer(cert) as peer, limited.scenario() as scenario:
         deployment: Final = _native(scenario, peer, otpm=10_000)
         key: Final = scenario.key(models=[deployment.name])
@@ -536,6 +534,115 @@ def test_a_socket_on_an_otpm_limited_deployment_reserves_once_and_serves_every_t
         assert deployment.forwarded_turns() == 5
 
 
+IO_TOKEN_LIMIT: Final = 10_000
+TOKENS_PER_TURN: Final = MappingProxyType({"itpm": USAGE["input_tokens"], "otpm": USAGE["output_tokens"]})
+
+
+def _io_tokens_counted(identity: str, kind: str, minute: str) -> int:
+    with _redis() as redis:
+        return sum(int(redis.get(key) or 0) for key in redis.scan_iter(f"global_router:{identity}:*:{kind}:{minute}"))
+
+
+def _add_io_tokens(deployment: Deployment, kind: str, minute: str, tokens: int) -> None:
+    with _redis() as redis:
+        redis.incrby(f"global_router:{deployment.identity}:openai/{PROVIDER_MODEL}:{kind}:{minute}", tokens)
+
+
+async def _say_until_counted(
+    connection: websockets.ClientConnection, deployment: Deployment, counted: Callable[[], float], expected: int
+) -> tuple[dict[str, JsonValue], ...]:
+    received: Final = await _say(connection, deployment.name)
+    await _until(counted, lambda tokens: tokens == expected)
+    return received
+
+
+@pytest.mark.parametrize("kind", ("otpm", "itpm"))
+def test_a_turn_is_refused_once_earlier_turns_fill_the_deployment_io_token_limit(
+    limited: Gateway, cert: tuple[Path, Path], kind: str
+) -> None:
+    per_turn: Final = TOKENS_PER_TURN[kind]
+    with responses_peer(cert) as peer, limited.scenario() as scenario:
+        deployment: Final = _native(scenario, peer, **{kind: IO_TOKEN_LIMIT})
+        key: Final = scenario.key(models=[deployment.name])
+        minute: Final = _fresh_minute()
+        counted: Final = partial(_io_tokens_counted, deployment.identity, kind, minute)
+
+        async def session() -> tuple[tuple[dict[str, JsonValue], ...], ...]:
+            async with _socket(limited, key, deployment.name) as connection:
+                first: Final = await _say_until_counted(connection, deployment, counted, per_turn)
+                await asyncio.to_thread(_add_io_tokens, deployment, kind, minute, IO_TOKEN_LIMIT - 5 * per_turn)
+                answered: Final = tuple(
+                    [
+                        await _say_until_counted(
+                            connection, deployment, counted, IO_TOKEN_LIMIT - (5 - number) * per_turn
+                        )
+                        for number in range(2, 6)
+                    ]
+                )
+                return (first, *answered, await _say(connection, deployment.name))
+
+        turns: Final = asyncio.run(session())
+
+        assert [completed(received)["status"] for received in turns[:5]] == ["completed"] * 5
+        _assert_refused(turns[5])
+        assert deployment.forwarded_turns() == 5
+        assert held(counted, lambda tokens: tokens == IO_TOKEN_LIMIT, holding=3, seconds=20) == IO_TOKEN_LIMIT
+
+
+def test_a_socket_at_half_its_deployment_otpm_serves_ten_turns(limited: Gateway, cert: tuple[Path, Path]) -> None:
+    with responses_peer(cert) as peer, limited.scenario() as scenario:
+        deployment: Final = _native(scenario, peer, otpm=IO_TOKEN_LIMIT)
+        key: Final = scenario.key(models=[deployment.name])
+        minute: Final = _fresh_minute()
+        _add_io_tokens(deployment, "otpm", minute, IO_TOKEN_LIMIT // 2)
+
+        async def session() -> tuple[tuple[dict[str, JsonValue], ...], ...]:
+            async with _socket(limited, key, deployment.name) as connection:
+                return tuple([await _say(connection, deployment.name) for _ in range(10)])
+
+        turns: Final = asyncio.run(session())
+
+        assert [completed(received)["status"] for received in turns] == ["completed"] * 10
+        assert deployment.forwarded_turns() == 10
+        expected: Final = IO_TOKEN_LIMIT // 2 + 10 * USAGE["output_tokens"]
+        counted: Final = partial(_io_tokens_counted, deployment.identity, "otpm", minute)
+        assert held(counted, lambda tokens: tokens == expected, holding=3, seconds=20) == expected
+
+
+@pytest.mark.parametrize("relay", ("native", "managed"))
+def test_every_turn_counts_its_actual_tokens_toward_the_deployment_itpm_and_otpm(
+    limited: Gateway, cert: tuple[Path, Path], relay: str
+) -> None:
+    with responses_peer(cert) as peer, limited.scenario() as scenario:
+        limits: Final = {"itpm": 1_000_000, "otpm": 1_000_000}
+        deployment: Final = _native(scenario, peer, **limits) if relay == "native" else _managed(scenario, **limits)
+        key: Final = scenario.key(models=[deployment.name])
+        minute: Final = _fresh_minute()
+
+        async def session() -> tuple[tuple[dict[str, JsonValue], ...], ...]:
+            async with _socket(limited, key, deployment.name) as connection:
+                return tuple([await _say(connection, deployment.name) for _ in range(3)])
+
+        turns: Final = asyncio.run(session())
+
+        usages: Final = tuple(object_value(completed(received)["usage"]) for received in turns)
+        expected: Final = {
+            "itpm": sum(int(str(usage["input_tokens"])) for usage in usages),
+            "otpm": sum(int(str(usage["output_tokens"])) for usage in usages),
+        }
+        assert any(tokens > 0 for tokens in expected.values()), usages
+        counted: Final = {
+            kind: held(
+                partial(_io_tokens_counted, deployment.identity, kind, minute),
+                lambda tokens, kind=kind: tokens == expected[kind],
+                holding=3,
+                seconds=20,
+            )
+            for kind in expected
+        }
+        assert counted == expected
+
+
 def test_usage_based_routing_refuses_a_turn_only_once_earlier_turns_used_up_the_deployment_tpm(
     usage_routed: Gateway, cert: tuple[Path, Path]
 ) -> None:
diff --git a/tests/integration/spend/test_non_finite_cost_spend_writes.py b/tests/integration/spend/test_non_finite_cost_spend_writes.py
new file mode 100644
index 00000000000..9a4d2dd45a4
--- /dev/null
+++ b/tests/integration/spend/test_non_finite_cost_spend_writes.py
@@ -0,0 +1,166 @@
+import json
+from hashlib import sha256
+from pathlib import Path
+from typing import Final, Literal
+from uuid import uuid4
+
+import pytest
+from integration._support.client import Gateway, eventually
+from integration._support.database import read_rows
+from integration._support.openai_wire import answering_model_discovery
+from integration._support.process import owned_proxy
+from integration._support.wire import Reply, Request, wire_server
+from pydantic import JsonValue
+
+pytestmark: Final = pytest.mark.shares_worker_state
+
+PROMPT_TOKENS: Final = 5
+COMPLETION_TOKENS: Final = 3
+INPUT_RATE: Final = 0.001
+OUTPUT_RATE: Final = 0.002
+TOKEN_PRICE: Final = PROMPT_TOKENS * INPUT_RATE + COMPLETION_TOKENS * OUTPUT_RATE
+OVERFLOWING_INPUT_RATE: Final = 1e308
+POISONED_UPSTREAM: Final = "poisoned-upstream"
+CONTROL_UPSTREAM: Final = "control-upstream"
+DAILY_TOTALS: Final = "SELECT model_group, SUM(spend)::float8 AS spend, SUM(api_requests)::int8 AS api_requests"
+DAILY_USER_QUERY: Final = f'{DAILY_TOTALS} FROM "LiteLLM_DailyUserSpend" WHERE api_key=%s GROUP BY model_group'
+DAILY_TEAM_QUERY: Final = f'{DAILY_TOTALS} FROM "LiteLLM_DailyTeamSpend" WHERE api_key=%s GROUP BY model_group'
+DAILY_TAG_QUERY: Final = f'{DAILY_TOTALS} FROM "LiteLLM_DailyTagSpend" WHERE api_key=%s AND tag=%s GROUP BY model_group'
+
+Poison = Literal["reported_nan_cost", "overflowing_price"]
+
+
+def _frame(payload: dict[str, JsonValue]) -> bytes:
+    return b"data: " + json.dumps(payload).encode() + b"\n\n"
+
+
+def _stream(upstream_model: str, reported_cost: float | None) -> tuple[bytes, ...]:
+    chunk: Final = {"id": f"chatcmpl-{uuid4().hex}", "object": "chat.completion.chunk", "created": 1}
+    usage: Final[dict[str, JsonValue]] = {
+        "prompt_tokens": PROMPT_TOKENS,
+        "completion_tokens": COMPLETION_TOKENS,
+        "total_tokens": PROMPT_TOKENS + COMPLETION_TOKENS,
+    }
+    reported_usage: Final = usage if reported_cost is None else {**usage, "cost": reported_cost}
+    return (
+        _frame({**chunk, "model": upstream_model, "choices": [{"index": 0, "delta": {"content": "ok"}}]}),
+        _frame(
+            {
+                **chunk,
+                "model": upstream_model,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+                "usage": reported_usage,
+            }
+        ),
+        b"data: [DONE]\n\n",
+    )
+
+
+def _deployment(alias: str, upstream_model: str, wire_url: str, input_rate: float) -> dict[str, JsonValue]:
+    return {
+        "model_name": alias,
+        "litellm_params": {
+            "model": f"openai/{upstream_model}",
+            "api_base": f"{wire_url}/v1",
+            "api_key": "integration-provider-key",
+            "input_cost_per_token": input_rate,
+            "output_cost_per_token": OUTPUT_RATE,
+        },
+    }
+
+
+def _proxy_config(directory: Path, deployments: tuple[dict[str, JsonValue], ...]) -> Path:
+    config: Final = directory / "non_finite_cost_config.yaml"
+    config.write_text(
+        json.dumps(
+            {
+                "model_list": list(deployments),
+                "general_settings": {
+                    "master_key": "os.environ/LITELLM_MASTER_KEY",
+                    "database_url": "os.environ/DATABASE_URL",
+                    "disable_spend_logs": False,
+                    "proxy_batch_write_at": 1,
+                    "proxy_batch_polling_interval": 1,
+                },
+                "router_settings": {"disable_cooldowns": True},
+            }
+        )
+    )
+    return config
+
+
+def _by_model_group(rows: list[dict[str, JsonValue]]) -> dict[str, float]:
+    return {str(row["model_group"]): float(str(row["spend"])) for row in rows}
+
+
+def _both_requests_rows(query: str, parameters: tuple[str, ...]) -> list[dict[str, JsonValue]]:
+    return eventually(lambda: read_rows(query, parameters), lambda rows: len(rows) == 2, seconds=70)
+
+
+@pytest.mark.parametrize("poison", ["reported_nan_cost", "overflowing_price"])
+@pytest.mark.timeout(240)
+def test_a_non_finite_cost_never_blocks_the_next_requests_spend_rows(
+    gateway: Gateway, tmp_path: Path, poison: Poison
+) -> None:
+    poisoned_alias: Final = f"non-finite-cost-{uuid4().hex}"
+    control_alias: Final = f"finite-cost-{uuid4().hex}"
+    tag: Final = f"non-finite-cost-{uuid4().hex}"
+    poisoned_spend: Final = TOKEN_PRICE if poison == "reported_nan_cost" else 0.0
+    poisoned_input_rate: Final = INPUT_RATE if poison == "reported_nan_cost" else OVERFLOWING_INPUT_RATE
+
+    def respond(request: Request) -> Reply:
+        assert request.target.endswith("/chat/completions"), request.target
+        upstream_model: Final = json.loads(request.body)["model"]
+        reported_cost: Final = (
+            float("nan") if upstream_model == POISONED_UPSTREAM and poison == "reported_nan_cost" else None
+        )
+        return Reply(content_type="text/event-stream", chunks=_stream(upstream_model, reported_cost))
+
+    with wire_server(answering_model_discovery(respond)) as wire:
+        config: Final = _proxy_config(
+            tmp_path,
+            (
+                _deployment(poisoned_alias, POISONED_UPSTREAM, wire.url, poisoned_input_rate),
+                _deployment(control_alias, CONTROL_UPSTREAM, wire.url, INPUT_RATE),
+            ),
+        )
+        with owned_proxy(gateway, tmp_path, {}, config=config) as candidate, candidate.scenario() as scenario:
+            team: Final = scenario.team()
+            key: Final = scenario.key(user_id=f"non-finite-cost-{uuid4().hex}", team_id=team)
+            digest: Final = sha256(key.encode()).hexdigest()
+            responses: Final = tuple(
+                candidate.request(
+                    "POST",
+                    "/v1/chat/completions",
+                    {
+                        "model": alias,
+                        "messages": [{"role": "user", "content": f"non-finite cost {uuid4().hex}"}],
+                        "stream": True,
+                        "metadata": {"tags": [tag]},
+                    },
+                    key=key,
+                )
+                for alias in (poisoned_alias, control_alias)
+            )
+            assert all(response.status_code == 200 for response in responses), [response.text for response in responses]
+
+            expected: Final = {poisoned_alias: pytest.approx(poisoned_spend), control_alias: pytest.approx(TOKEN_PRICE)}
+            spend_logs: Final = _both_requests_rows(
+                'SELECT model_group, spend FROM "LiteLLM_SpendLogs" WHERE api_key=%s', (digest,)
+            )
+            assert _by_model_group(spend_logs) == expected, spend_logs
+            daily_rows: Final = (
+                _both_requests_rows(DAILY_USER_QUERY, (digest,)),
+                _both_requests_rows(DAILY_TEAM_QUERY, (digest,)),
+                _both_requests_rows(DAILY_TAG_QUERY, (digest, tag)),
+            )
+            assert [_by_model_group(rows) for rows in daily_rows] == [expected] * 3, daily_rows
+            assert [{row["api_requests"] for row in rows} for rows in daily_rows] == [{1}] * 3, daily_rows
+            key_total: Final = poisoned_spend + TOKEN_PRICE
+            key_spend: Final = eventually(
+                lambda: read_rows('SELECT spend FROM "LiteLLM_VerificationToken" WHERE token=%s', (digest,)),
+                lambda rows: len(rows) == 1 and float(str(rows[0]["spend"])) == pytest.approx(key_total),
+                seconds=70,
+                return_last_on_timeout=True,
+            )
+            assert float(str(key_spend[0]["spend"])) == pytest.approx(key_total), key_spend
diff --git a/tests/unit/integrations/test_prometheus_labels.py b/tests/unit/integrations/test_prometheus_labels.py
index bff89b6cbf1..878f19c66f8 100644
--- a/tests/unit/integrations/test_prometheus_labels.py
+++ b/tests/unit/integrations/test_prometheus_labels.py
@@ -238,6 +238,53 @@ def test_extract_api_provider_from_request_data_failure_path():
     assert extract({"model": "some-unknown-model-xyz"}) is None
 
 
+_PASS_THROUGH_CALL_TYPE: Final = "pass_through_endpoint"
+
+
+@pytest.mark.parametrize(
+    "request_data, expected_provider",
+    [
+        ({"model": "gpt-4o-mini", "call_type": "acompletion", "custom_llm_provider": "anthropic"}, "openai"),
+        ({"model": "gpt-4o-mini", "litellm_params": {"custom_llm_provider": "humanloop"}}, "humanloop"),
+        ({"model": "gemini-3.8-flash", "call_type": _PASS_THROUGH_CALL_TYPE}, "vertex_ai"),
+        (
+            {"model": "gemini-3.8-flash", "call_type": _PASS_THROUGH_CALL_TYPE, "custom_llm_provider": "gemini"},
+            "gemini",
+        ),
+        (
+            {
+                "call_type": _PASS_THROUGH_CALL_TYPE,
+                "custom_llm_provider": "gemini",
+                "standard_logging_object": {"custom_llm_provider": "vertex_ai"},
+            },
+            "vertex_ai",
+        ),
+    ],
+)
+def test_extract_api_provider_reads_the_request_declared_provider_only_on_pass_through_failures(
+    request_data: dict[str, object], expected_provider: str
+):
+    from litellm.integrations.prometheus import PrometheusLogger
+
+    assert PrometheusLogger._extract_api_provider_from_request_data(request_data) == expected_provider
+
+
+@pytest.mark.parametrize(
+    "declared_provider",
+    ["azure", "bedrock", "openrouter", "client-supplied-value", "", {"nested": "object"}, 42],
+)
+def test_extract_api_provider_ignores_pass_through_declared_values_outside_gemini_and_vertex(
+    declared_provider: object,
+):
+    from litellm.integrations.prometheus import PrometheusLogger
+
+    extract = PrometheusLogger._extract_api_provider_from_request_data
+    declared = {"call_type": _PASS_THROUGH_CALL_TYPE, "custom_llm_provider": declared_provider}
+
+    assert extract({"model": "gpt-4o-mini", **declared}) == "openai"
+    assert extract({"model": "no-such-model", **declared}) is None
+
+
 def test_extract_api_provider_swallows_unknown_model_but_logs_unexpected_errors():
     """
     get_llm_provider raises BadRequestError for a model that maps to no
@@ -849,6 +896,56 @@ async def test_failure_hook_prefers_request_data_provider_over_exception_provide
     ) == ["azure"]
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "call_type, custom_llm_provider, expected_requested_model",
+    [
+        (_PASS_THROUGH_CALL_TYPE, "vertex_ai", "gcp/google/gemini-2.5-flash"),
+        ("acompletion", "vertex_ai", "other"),
+        (_PASS_THROUGH_CALL_TYPE, "bedrock", "other"),
+    ],
+)
+async def test_failure_hook_labels_a_pass_through_failure_with_the_router_model_the_client_requested(
+    call_type: str, custom_llm_provider: str, expected_requested_model: str
+):
+    from unittest.mock import patch
+
+    from litellm.integrations.prometheus import PrometheusLogger
+    from litellm.proxy._types import UserAPIKeyAuth
+
+    router = litellm.Router(
+        model_list=[
+            {
+                "model_name": "gcp/google/gemini-2.5-flash",
+                "litellm_params": {
+                    "model": "vertex_ai/gemini-2.5-flash",
+                    "vertex_project": "p",
+                    "vertex_location": "us-central1",
+                },
+            }
+        ]
+    )
+    _clear_prometheus_registry()
+    try:
+        with patch("litellm.proxy.proxy_server.llm_router", router, create=True):  # test-quality-ok: production reads proxy_server.llm_router lazily, no injection seam
+            await PrometheusLogger().async_post_call_failure_hook(
+                request_data={
+                    "model": "gemini-2.5-flash",
+                    "call_type": call_type,
+                    "custom_llm_provider": custom_llm_provider,
+                    "metadata": {},
+                    "litellm_params": {"metadata": {"model_group": "gcp/google/gemini-2.5-flash"}},
+                },
+                original_exception=Exception("upstream 400"),
+                user_api_key_dict=UserAPIKeyAuth(token="tok"),
+            )
+        assert {
+            s.labels.get("requested_model") for s in _collected_samples("litellm_proxy_failed_requests_metric_total")
+        } == {expected_requested_model}
+    finally:
+        _clear_prometheus_registry()
+
+
 def test_model_group_in_deployment_metrics():
     """
     Test that model_group label is present on the deployment-scoped metrics
diff --git a/tests/unit/litellm_core_utils/llm_response_utils/test_convert_dict_to_response.py b/tests/unit/litellm_core_utils/llm_response_utils/test_convert_dict_to_response.py
index d65a5f436b4..3e197740e98 100644
--- a/tests/unit/litellm_core_utils/llm_response_utils/test_convert_dict_to_response.py
+++ b/tests/unit/litellm_core_utils/llm_response_utils/test_convert_dict_to_response.py
@@ -3156,6 +3156,50 @@ def test_vllm_choice_fields_cached_only_under_provider_specific_fields_come_back
     assert {field: dumped_choice.get(field, "missing") for field in vllm_choice_fields} == vllm_choice_fields
 
 
+@pytest.mark.parametrize(
+    "reported_cost",
+    [
+        float("nan"),
+        float("inf"),
+        {"input_tokens_cost": 0.0001, "request_cost": 0.005, "total_cost": float("nan")},
+        {"input_tokens_cost": float("inf"), "request_cost": 0.005, "total_cost": 0.0051},
+    ],
+    ids=["nan", "inf", "breakdown-with-nan-total", "breakdown-with-inf-part"],
+)
+def test_a_non_finite_provider_usage_cost_is_dropped_so_the_response_is_strict_json(reported_cost: object):
+    response: Final = convert_to_model_response_object(
+        response_object={
+            "id": "chatcmpl-non-finite-cost",
+            "object": "chat.completion",
+            "created": 1,
+            "model": "gpt-4o",
+            "choices": [{"index": 0, "message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 3, "completion_tokens": 1, "total_tokens": 4, "cost": reported_cost},
+        },
+        model_response_object=ModelResponse(),
+    )
+
+    usage: Final = json.loads(json.dumps(response.model_dump(), allow_nan=False))["usage"]
+    assert "cost" not in usage
+    assert usage["total_tokens"] == 4
+
+
+def test_a_finite_provider_cost_breakdown_with_non_string_keys_is_kept():
+    response: Final = convert_to_model_response_object(
+        response_object={
+            "id": "chatcmpl-int-key-cost",
+            "object": "chat.completion",
+            "created": 1,
+            "model": "gpt-4o",
+            "choices": [{"index": 0, "message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 3, "completion_tokens": 1, "total_tokens": 4, "cost": {1: 0.5}},
+        },
+        model_response_object=ModelResponse(),
+    )
+
+    assert response.usage.cost == {1: 0.5}
+
+
 _URL_CITATION: Final = {
     "type": "url_citation",
     "url_citation": {
diff --git a/tests/unit/litellm_core_utils/test_core_helpers.py b/tests/unit/litellm_core_utils/test_core_helpers.py
index 1c86c4e30d8..93defc0f04f 100644
--- a/tests/unit/litellm_core_utils/test_core_helpers.py
+++ b/tests/unit/litellm_core_utils/test_core_helpers.py
@@ -26,15 +26,24 @@ from litellm.litellm_core_utils.core_helpers import (
     normalize_drop_params,
     preserve_upstream_non_openai_attributes,
     process_response_headers,
+    provider_reported_usage_cost,
     qualify_agentic_followup_model,
     qualify_provider_stripped_model,
     reconstruct_model_name,
     redact_nested_match_and_regex_keys,
+    response_cost_in_hidden_params,
     set_provider_response_headers_in_hidden_params,
     unbind_budget_reservation_from_callbacks,
 )
 from litellm.proxy._types import UserAPIKeyAuth
-from litellm.types.utils import Delta, ImageResponse, ModelResponseStream, StreamingChoices, TranscriptionResponse
+from litellm.types.utils import (
+    Delta,
+    ImageResponse,
+    ModelResponse,
+    ModelResponseStream,
+    StreamingChoices,
+    TranscriptionResponse,
+)
 
 
 def test_parent_otel_span_reads_dict_like_metadata_by_index():
@@ -790,6 +799,23 @@ class TestReceiveStampSurvivesASecondMetadataBucket:
         assert get_litellm_metadata_from_kwargs(kwargs)["litellm_received_at"] is own
 
 
+@pytest.mark.parametrize("reported", [float("nan"), float("inf"), {"total_cost": float("nan")}])
+def test_a_non_finite_provider_reported_cost_counts_as_unreported(reported: object) -> None:
+    assert provider_reported_usage_cost({"cost": reported}, "openrouter") is None
+    assert provider_reported_usage_cost({"cost": {"total_cost": 0.25}}, "openrouter") == 0.25
+
+
+@pytest.mark.parametrize("header_cost", [float("nan"), float("inf")])
+def test_a_non_finite_response_cost_header_counts_as_unreported(header_cost: float) -> None:
+    response: Final = ModelResponse()
+    response._hidden_params = {"additional_headers": {RESPONSE_COST_HEADER: header_cost}}
+    finite: Final = ModelResponse()
+    finite._hidden_params = {"additional_headers": {RESPONSE_COST_HEADER: 0.25}}
+
+    assert response_cost_in_hidden_params(response) is None
+    assert response_cost_in_hidden_params(finite) == 0.25
+
+
 def test_billed_usage_cost_bills_any_chat_upstream_without_its_own_reader() -> None:
     from types import SimpleNamespace
 
diff --git a/tests/unit/litellm_core_utils/test_exception_mapping_utils.py b/tests/unit/litellm_core_utils/test_exception_mapping_utils.py
index 88501a23235..efb9648cf13 100644
--- a/tests/unit/litellm_core_utils/test_exception_mapping_utils.py
+++ b/tests/unit/litellm_core_utils/test_exception_mapping_utils.py
@@ -60,7 +60,6 @@ def test_openai_cyber_policy_uses_the_structured_error_code(shape: str, code: st
         assert caught.value.response.headers["x-request-id"] == "cyber-policy-request"
 
 
-
 def _debug_info_for_api_base(configured_api_base: str) -> str:
     request: Final = httpx.Request("POST", "https://gateway.example/v1/chat/completions")
     original: Final = OpenAIError(
@@ -1602,6 +1601,75 @@ def test_bedrock_mantle_400_maps_to_bad_request():
     assert type(excinfo.value) is litellm.BadRequestError
 
 
+class _ErrorWithoutResponse(Exception):
+    def __init__(self, message: str, status_code: int) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+
+def test_bedrock_mantle_context_overflow_without_a_provider_response_answers_400():
+    with pytest.raises(litellm.ContextWindowExceededError) as excinfo:
+        exception_type(
+            model="openai.gpt-5.6-sol",
+            original_exception=_ErrorWithoutResponse(
+                '{"error":{"code":"context_length_exceeded","message":"too long"}}', 400
+            ),
+            custom_llm_provider="bedrock_mantle",
+        )
+
+    assert excinfo.value.response.status_code == 400
+
+
+def _invalid_model_identifier_from(url: str) -> BedrockError:
+    return BedrockError(
+        status_code=400,
+        message='{"message":"The provided model identifier is invalid."}',
+        response=httpx.Response(status_code=400, request=httpx.Request(method="POST", url=url)),
+    )
+
+
+@pytest.mark.parametrize(
+    "path",
+    ["/model/us.newvendor.typo-1/converse", "/model/us.newvendor.typo-1/converse-stream"],
+)
+def test_bedrock_converse_rejecting_an_id_with_no_invoke_provider_answers_404(path):
+    with pytest.raises(litellm.NotFoundError) as excinfo:
+        exception_type(
+            model="us.newvendor.typo-1",
+            original_exception=_invalid_model_identifier_from(f"https://bedrock-runtime.us-east-1.amazonaws.com{path}"),
+            custom_llm_provider="bedrock",
+        )
+
+    assert excinfo.value.response.status_code == 404
+
+
+@pytest.mark.parametrize(
+    "original_exception",
+    [
+        _invalid_model_identifier_from("https://bedrock-runtime.us-east-1.amazonaws.com/model/claude-typo-9/invoke"),
+        _ErrorWithoutResponse("The provided model identifier is invalid.", 400),
+    ],
+    ids=["invoke", "no-response"],
+)
+def test_bedrock_invalid_model_identifier_not_from_converse_stays_a_bad_request(original_exception):
+    with pytest.raises(litellm.BadRequestError) as excinfo:
+        exception_type(model="claude-typo-9", original_exception=original_exception, custom_llm_provider="bedrock")
+
+    assert excinfo.value.status_code == 400
+
+
+def test_bedrock_invalid_model_identifier_without_a_model_stays_a_bad_request():
+    with pytest.raises(litellm.BadRequestError) as excinfo:
+        exception_type(
+            model=None,
+            original_exception=_ErrorWithoutResponse("The provided model identifier is invalid.", 400),
+            custom_llm_provider="bedrock",
+        )
+
+    assert excinfo.value.status_code == 400
+
+
 def test_bedrock_mantle_context_overflow_maps_to_context_window_exceeded():
     from litellm.llms.base_llm.chat.transformation import BaseLLMException
 
diff --git a/tests/unit/litellm_core_utils/test_hidden_params.py b/tests/unit/litellm_core_utils/test_hidden_params.py
index c0485a07696..b32692c67ba 100644
--- a/tests/unit/litellm_core_utils/test_hidden_params.py
+++ b/tests/unit/litellm_core_utils/test_hidden_params.py
@@ -1,7 +1,11 @@
-from typing import Final
+import pickle
+from collections.abc import Callable
+from typing import ClassVar, Final
 
 import pytest
+from openai import BaseModel as OpenAIBaseModel
 from openai.types.chat import ChatCompletionChunk
+from pydantic import BaseModel, ConfigDict, PrivateAttr
 
 from litellm.litellm_core_utils.hidden_params import (
     HIDDEN_PARAMS_ATTR,
@@ -9,13 +13,14 @@ from litellm.litellm_core_utils.hidden_params import (
     get_hidden_params_storage,
     get_or_create_hidden_params,
     served_from_cache,
+    set_extra_attribute,
     set_hidden_param,
     set_hidden_params,
 )
 from litellm.llms.openai.completion.transformation import OpenAITextCompletionConfig
 from litellm.types.decisions import DecisionsResponse
 from litellm.types.llms.base import HiddenParams
-from litellm.types.utils import ModelResponse, TextChoices, TextCompletionResponse, Usage
+from litellm.types.utils import ModelResponse, ModelResponseStream, TextChoices, TextCompletionResponse, Usage
 
 
 def test_get_and_set_hidden_params_on_plain_object() -> None:
@@ -309,3 +314,133 @@ def test_served_from_cache_is_true_only_for_a_response_the_cache_stamped(
     assert served_from_cache(model_response) is expected
     assert served_from_cache({HIDDEN_PARAMS_ATTR: dict(hidden_params)}) is expected
     assert served_from_cache(object()) is False
+
+
+class _ExtraModel(BaseModel):  # frozen-ok: the assignment tests need a model that accepts attribute writes
+    model_config = ConfigDict(extra="allow")
+
+    declared: str | None = None
+    marker: ClassVar[str | None] = None
+    unset_marker: ClassVar[int]
+    _secret: str = PrivateAttr(default="hidden")
+
+    @property
+    def doubled(self) -> str | None:
+        return self.declared
+
+    @doubled.setter
+    def doubled(self, value: str) -> None:
+        self.declared = value * 2
+
+
+class _FrozenExtraModel(BaseModel):
+    model_config = ConfigDict(extra="allow", frozen=True)
+
+
+class _ValidatedExtraModel(BaseModel):  # frozen-ok: the assignment tests need a model that accepts attribute writes
+    model_config = ConfigDict(extra="allow", validate_assignment=True)
+
+    __pydantic_extra__: dict[str, int]
+
+
+class _IgnoredExtraModel(BaseModel):  # frozen-ok: the assignment tests need a model that accepts attribute writes
+    model_config = ConfigDict(extra="ignore")
+
+
+class _MirroringModel(BaseModel):  # frozen-ok: the assignment tests need a model that accepts attribute writes
+    model_config = ConfigDict(extra="allow")
+
+    def __setattr__(self, name: str, value: object) -> None:
+        super().__setattr__(name, value)
+        super().__setattr__(f"{name}_copy", value)
+
+
+class _NoneClassAttribute:
+    inherited = None
+
+
+class _InheritingExtraModel(_NoneClassAttribute, BaseModel):  # frozen-ok: assignment tests need attribute writes
+    model_config = ConfigDict(extra="allow")
+
+
+class _ForbiddingOpenAIModel(OpenAIBaseModel):  # frozen-ok: assignment tests need attribute writes
+    model_config = ConfigDict(extra="forbid")
+
+
+def _assignment_outcome(model: BaseModel, assign: Callable[[], None], name: str) -> tuple[object, ...]:
+    try:
+        assign()
+    except (AttributeError, ValueError) as error:
+        return type(error), str(error)
+    return model.model_dump(), getattr(model, name), model.model_fields_set, model.model_dump_json()
+
+
+@pytest.mark.parametrize(
+    "build, name, value",
+    [
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "fresh", 1, id="new-extra"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "existing", 2, id="existing-extra-keeps-order"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "declared", "x", id="declared-field"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "doubled", "ab", id="property"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "_free", 1, id="undeclared-underscore-name"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "_secret", "x", id="private-attribute"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "marker", 1, id="class-var"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "unset_marker", 1, id="class-var-without-value"),
+        pytest.param(lambda: _ExtraModel(existing=1, later=3), "model_config", 1, id="class-attribute"),
+        pytest.param(_FrozenExtraModel, "fresh", 1, id="frozen"),
+        pytest.param(_ValidatedExtraModel, "fresh", "5", id="validate-assignment"),
+        pytest.param(_IgnoredExtraModel, "fresh", 1, id="extra-ignore"),
+        pytest.param(_MirroringModel, "fresh", 1, id="setattr-override"),
+        pytest.param(_InheritingExtraModel, "inherited", 1, id="class-attribute-set-to-none"),
+        pytest.param(
+            lambda: _ForbiddingOpenAIModel.construct(existing=1), "fresh", 1, id="extra-forbid-built-by-construct"
+        ),
+    ],
+)
+def test_set_extra_attribute_matches_setattr(build: Callable[[], BaseModel], name: str, value: object) -> None:
+    through_setattr: Final = build()
+    through_helper: Final = build()
+
+    expected: Final = _assignment_outcome(through_setattr, lambda: setattr(through_setattr, name, value), name)
+    actual: Final = _assignment_outcome(through_helper, lambda: set_extra_attribute(through_helper, name, value), name)
+
+    assert actual == expected
+
+
+@pytest.mark.parametrize("response_type", [ModelResponse, ModelResponseStream])
+def test_hidden_params_raises_attribute_error_once_deleted(
+    response_type: type[ModelResponse | ModelResponseStream],
+) -> None:
+    response: Final = response_type()
+    del response._hidden_params
+
+    assert getattr(response, "hidden_params", "fallback") == "fallback"
+
+
+def _round_trip(response: ModelResponse | ModelResponseStream) -> ModelResponse | ModelResponseStream:
+    return pickle.loads(pickle.dumps(response))
+
+
+@pytest.mark.parametrize("response_type", [ModelResponse, ModelResponseStream])
+@pytest.mark.parametrize(
+    "rebuild",
+    [
+        pytest.param(lambda response: response, id="init"),
+        pytest.param(lambda response: response.model_copy(), id="model-copy"),
+        pytest.param(lambda response: response.model_copy(deep=True), id="deep-copy"),
+        pytest.param(_round_trip, id="pickle"),
+    ],
+)
+def test_hidden_params_is_the_stored_dict_on_every_construction_path(
+    response_type: type[ModelResponse | ModelResponseStream],
+    rebuild: Callable[[ModelResponse | ModelResponseStream], ModelResponse | ModelResponseStream],
+) -> None:
+    original: Final = response_type()
+    original.hidden_params["model_id"] = "deployment-1"
+    response: Final = rebuild(original)
+
+    response.hidden_params["api_base"] = "https://example.com"
+
+    assert response.hidden_params is response._hidden_params
+    assert get_hidden_params(response) == response._hidden_params
+    assert response._hidden_params["api_base"] == "https://example.com"
diff --git a/tests/unit/litellm_core_utils/test_litellm_logging.py b/tests/unit/litellm_core_utils/test_litellm_logging.py
index b3ae3bf6240..d0e31cdd57a 100644
--- a/tests/unit/litellm_core_utils/test_litellm_logging.py
+++ b/tests/unit/litellm_core_utils/test_litellm_logging.py
@@ -6308,6 +6308,60 @@ def test_standard_logging_payload_resolves_kubernetes_pod_routing_from_metadata_
     assert payload["metadata"][KUBERNETES_POD_ROUTING_KEY] == expected
 
 
+@pytest.mark.parametrize("response_cost", [float("nan"), float("inf"), float("-inf")])
+def test_get_standard_logging_object_payload_logs_a_non_finite_response_cost_as_zero(
+    logging_obj: LitellmLogging, response_cost: float
+) -> None:
+    from datetime import datetime
+
+    from litellm.litellm_core_utils.litellm_logging import get_standard_logging_object_payload
+
+    now: Final = datetime(2026, 1, 1)
+    payload: Final = get_standard_logging_object_payload(
+        kwargs={"model": "gpt-4o", "messages": [], "litellm_params": {}, "response_cost": response_cost},
+        init_response_obj={},
+        start_time=now,
+        end_time=now,
+        logging_obj=logging_obj,
+        status="success",
+    )
+
+    assert payload is not None
+    assert payload["response_cost"] == 0
+
+
+def test_an_overflowing_custom_price_records_a_zero_response_cost(caplog: pytest.LogCaptureFixture) -> None:
+    messages: Final = [{"role": "user", "content": "hello world"}]
+    start_time: Final = datetime.datetime.now()
+    logging_obj: Final = Logging(
+        model="gpt-4o",
+        messages=messages,
+        stream=False,
+        call_type="completion",
+        start_time=start_time,
+        litellm_call_id="overflow\nforged log line",
+        function_id="overflow",
+    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        response: Final = litellm.completion(
+            model="gpt-4o",
+            mock_response="hi there",
+            messages=messages,
+            input_cost_per_token=1e308,
+            output_cost_per_token=1e308,
+            litellm_logging_obj=logging_obj,
+        )
+    logging_obj._process_hidden_params_and_response_cost(
+        response, start_time=start_time, end_time=datetime.datetime.now()
+    )
+
+    assert response._hidden_params["response_cost"] == 0.0
+    payload: Final = logging_obj.model_call_details["standard_logging_object"]
+    assert json.loads(json.dumps(payload, allow_nan=False, default=str))["response_cost"] == 0.0
+    warnings: Final = [r.getMessage() for r in caplog.records if "non-finite response_cost" in r.getMessage()]
+    assert warnings == ["Recording a non-finite response_cost as 0 for litellm_call_id=overflowforged log line"]
+
+
 def test_get_standard_logging_object_payload_carries_matched_access_groups(logging_obj):
     """Access groups stamped at auth time reach the logging payload, so integrations see what a request billed."""
     from datetime import datetime
@@ -6902,6 +6956,95 @@ def test_handle_anthropic_messages_response_logging_reparses_the_served_body_wit
     assert logged.usage.completion_tokens == 7  # type: ignore[attr-defined]
 
 
+@pytest.mark.parametrize(
+    "compaction_block",
+    [
+        {"type": "compaction", "content": "Summary of the chat so far.", "signature": "sig-abc"},
+        {"type": "compaction", "signature": "sig-abc"},
+    ],
+    ids=["with_summary", "without_content"],
+)
+def test_handle_anthropic_messages_response_logging_reparses_a_served_compaction_response(
+    compaction_block: dict[str, str],
+):
+    logging_obj = _anthropic_messages_logging_obj()
+    logging_obj.optional_params = {}
+
+    logged = logging_obj._handle_anthropic_messages_response_logging(
+        result={
+            "id": "msg_compacted",
+            "type": "message",
+            "role": "assistant",
+            "model": "claude-sonnet-5-5",
+            "content": [compaction_block],
+            "stop_reason": "compaction",
+            "stop_sequence": None,
+            "usage": {"input_tokens": 410, "output_tokens": 95},
+        }
+    )
+
+    assert isinstance(logged, ModelResponse)
+    assert logged.id == "msg_compacted"
+    assert logged.usage.prompt_tokens == 410
+    assert logged.usage.completion_tokens == 95
+    assert logged.choices[0].message.provider_specific_fields["compaction_blocks"] == [compaction_block]
+
+
+_WEB_SEARCH_REPLY: Final = (
+    {"type": "server_tool_use", "id": "srvtoolu_1", "name": "web_search", "input": {"query": "weather"}},
+    {
+        "type": "web_search_tool_result",
+        "tool_use_id": "srvtoolu_1",
+        "content": [{"type": "web_search_result", "url": "https://example.com", "title": "Weather"}],
+    },
+    {"type": "text", "text": "It is sunny."},
+)
+
+
+@pytest.mark.parametrize(
+    ("content", "stop_reason"),
+    [
+        (list(_WEB_SEARCH_REPLY), "end_turn"),
+        (list(_WEB_SEARCH_REPLY), "pause_turn"),
+        ([{"type": "text", "text": "The context window is full."}], "model_context_window_exceeded"),
+        (
+            [
+                {"type": "mcp_tool_use", "id": "mcptoolu_1", "name": "lookup", "server_name": "docs", "input": {}},
+                {"type": "mcp_tool_result", "tool_use_id": "mcptoolu_1", "is_error": False, "content": [{"type": "text", "text": "ok"}]},
+                {"type": "text", "text": "Found it."},
+            ],
+            "end_turn",
+        ),
+        ([{"type": "container_upload", "file_id": "file_1"}, {"type": "text", "text": "Uploaded."}], "end_turn"),
+    ],
+    ids=["web_search", "pause_turn", "model_context_window_exceeded", "mcp_tool_use", "container_upload"],
+)
+def test_handle_anthropic_messages_response_logging_bills_a_served_server_tool_response(
+    content: list[dict[str, object]], stop_reason: str
+):
+    logging_obj = _anthropic_messages_logging_obj()
+    logging_obj.optional_params = {}
+
+    logged = logging_obj._handle_anthropic_messages_response_logging(
+        result={
+            "id": "msg_server_tools",
+            "type": "message",
+            "role": "assistant",
+            "model": "claude-sonnet-5-5",
+            "content": content,
+            "stop_reason": stop_reason,
+            "stop_sequence": None,
+            "usage": {"input_tokens": 1200, "output_tokens": 80},
+        }
+    )
+
+    assert isinstance(logged, ModelResponse)
+    assert logged.id == "msg_server_tools"
+    assert logged.usage.prompt_tokens == 1200
+    assert logged.usage.completion_tokens == 80
+    assert logged.choices[0].message.content == content[-1]["text"]
+
+
 def test_handle_anthropic_messages_response_logging_passes_model_response_through():
     """Anthropic-native path already yields a ModelResponse; it must be returned unchanged."""
     logging_obj = _anthropic_messages_logging_obj()
diff --git a/tests/unit/litellm_core_utils/test_llm_request_utils.py b/tests/unit/litellm_core_utils/test_llm_request_utils.py
index e7350fae395..5243d308543 100644
--- a/tests/unit/litellm_core_utils/test_llm_request_utils.py
+++ b/tests/unit/litellm_core_utils/test_llm_request_utils.py
@@ -1,3 +1,5 @@
+import datetime
+import time
 from typing import Final
 
 import httpx
@@ -245,3 +247,39 @@ def test_rank_chat_models_flags_a_retired_model_the_provider_lists_without_its_c
         (ranked_model.model, ranked_model.is_past_deprecation_date)
         for ranked_model in rank_chat_models_from_llm_provider("vertex_ai")
     ] == [("fake-retired-vertex-chat", True), ("fake-live-vertex-chat", False)]
+
+
+@pytest.mark.parametrize("host_zone", ["Etc/GMT+12", "Etc/GMT-14"])
+def test_rank_chat_models_flags_retirement_by_the_utc_date_whatever_the_host_zone(
+    monkeypatch: pytest.MonkeyPatch, host_zone: str
+) -> None:
+    utc_today: Final = datetime.datetime.now(datetime.timezone.utc).date()
+    retirement_dates: Final = {
+        "deepseek/fake-retires-today-chat": utc_today,
+        "deepseek/fake-retires-tomorrow-chat": utc_today + datetime.timedelta(days=1),
+    }
+    for name, retirement_date in retirement_dates.items():
+        monkeypatch.setitem(
+            litellm.model_cost,
+            name,
+            {
+                "input_cost_per_token": 1e-12,
+                "output_cost_per_token": 1e-12,
+                "mode": "chat",
+                "litellm_provider": PICKER_PROVIDER,
+                "deprecation_date": retirement_date.isoformat(),
+            },
+        )
+    monkeypatch.setitem(litellm.models_by_provider, PICKER_PROVIDER, tuple(retirement_dates))
+    monkeypatch.setenv("TZ", host_zone)
+    time.tzset()
+    try:
+        flags: Final = {
+            ranked_model.model: ranked_model.is_past_deprecation_date
+            for ranked_model in rank_chat_models_from_llm_provider(PICKER_PROVIDER)
+        }
+    finally:
+        monkeypatch.undo()
+        time.tzset()
+
+    assert flags == {"deepseek/fake-retires-today-chat": True, "deepseek/fake-retires-tomorrow-chat": False}
diff --git a/tests/unit/litellm_core_utils/test_redact_messages.py b/tests/unit/litellm_core_utils/test_redact_messages.py
index 30a1a21e369..b523ab71f54 100644
--- a/tests/unit/litellm_core_utils/test_redact_messages.py
+++ b/tests/unit/litellm_core_utils/test_redact_messages.py
@@ -57,9 +57,10 @@ def _provider_fields() -> dict[str, object]:
         "thinking_blocks": [{"type": "thinking", "thinking": SECRET}],
         "reasoningContentBlocks": [{"reasoningText": {"text": SECRET}}],
         "citations": [{"cited_text": SECRET}],
-        "thought_signatures": [SIGNATURE],
-        "compaction_blocks": [{"type": "compaction", "content": SECRET}],
+        "compaction_blocks": [{"type": "compaction", "content": SECRET, "signature": "compaction-signature"}],
+        "compaction_start": {"type": "compaction", "content": SECRET},
         "compaction_delta": {"type": "compaction_delta", "content": SECRET},
+        "thought_signatures": [SIGNATURE],
     }
 
 
diff --git a/tests/unit/litellm_core_utils/test_safe_json_dumps.py b/tests/unit/litellm_core_utils/test_safe_json_dumps.py
index 1f2664f33cb..1b8bdd21326 100644
--- a/tests/unit/litellm_core_utils/test_safe_json_dumps.py
+++ b/tests/unit/litellm_core_utils/test_safe_json_dumps.py
@@ -169,6 +169,31 @@ def test_null_byte_stripped_in_fallback_str():
     assert json.loads(out)["obj"] == "objrepr"
 
 
+@pytest.mark.parametrize("value", [float("nan"), float("inf"), float("-inf")])
+def test_non_finite_floats_are_written_as_json_null(value: float) -> None:
+    out = safe_dumps(
+        {"cost_breakdown": {"total_cost": value, "output_cost": 0.006}, "costs": [value]}, non_finite_as_null=True
+    )
+
+    assert json.loads(out, parse_constant=lambda token: pytest.fail(f"non-JSON token {token}")) == {
+        "cost_breakdown": {"total_cost": None, "output_cost": 0.006},
+        "costs": [None],
+    }
+
+
+def test_a_set_holding_a_non_finite_float_sorts_its_finite_members_and_puts_null_last() -> None:
+    assert json.loads(safe_dumps({"costs": {2.0, float("inf"), 1.0}}, non_finite_as_null=True)) == {
+        "costs": [1.0, 2.0, None]
+    }
+
+
+def test_non_finite_floats_keep_their_value_unless_the_caller_asks_for_null() -> None:
+    assert json.loads(safe_dumps({"timeout": float("inf"), "costs": [float("-inf")]})) == {
+        "timeout": float("inf"),
+        "costs": [float("-inf")],
+    }
+
+
 def test_clean_strings_are_not_run_through_replace():
     """Regression for LIT-3910.
 
diff --git a/tests/unit/litellm_core_utils/test_streaming_chunk_builder_utils.py b/tests/unit/litellm_core_utils/test_streaming_chunk_builder_utils.py
index eaa17c32a78..cc0386447b7 100644
--- a/tests/unit/litellm_core_utils/test_streaming_chunk_builder_utils.py
+++ b/tests/unit/litellm_core_utils/test_streaming_chunk_builder_utils.py
@@ -1077,6 +1077,47 @@ def test_cost_field_in_usage_chunks():
     assert usage.completion_tokens == 5
 
 
+
+def _perplexity_usage_chunk(cost: Mapping[str, float], finish_reason: str | None) -> ModelResponseStream:
+    return ModelResponseStream(
+        id="chatcmpl-pplx",
+        created=1745513206,
+        model="sonar",
+        choices=[StreamingChoices(finish_reason=finish_reason, index=0, delta=Delta(content="ok"))],
+        usage={"prompt_tokens": 26, "completion_tokens": 1, "total_tokens": 27, "cost": dict(cost)},
+    )
+
+
+@pytest.mark.parametrize("poisoned_field", ["request_cost", "total_cost"])
+def test_a_non_finite_final_stream_cost_does_not_fall_back_to_an_earlier_chunk_cost(poisoned_field: str):
+    final_cost: Final = {"input_tokens_cost": 0.0012, "output_tokens_cost": 1e-05, "request_cost": 0.0025}
+    chunks: Final = [
+        _perplexity_usage_chunk({"input_tokens_cost": 0, "output_tokens_cost": 0, "total_cost": 0}, None),
+        _perplexity_usage_chunk({**final_cost, "total_cost": 0.00371, poisoned_field: float("nan")}, "stop"),
+    ]
+
+    response: Final = stream_chunk_builder(chunks=chunks)
+
+    assert response is not None
+    assert getattr(response.usage, "cost", None) is None
+    assert response.usage.total_tokens == 27
+
+
+@pytest.mark.parametrize("provider_key", ["dropped_non_finite_cost", "_dropped_non_finite_cost"])
+def test_a_provider_usage_key_named_like_the_dropped_cost_flag_keeps_the_stream_cost(provider_key: str):
+    chunk: Final = ModelResponseStream(
+        id="chatcmpl-flag-key",
+        created=1745513206,
+        model="sonar",
+        choices=[StreamingChoices(finish_reason="stop", index=0, delta=Delta(content="ok"))],
+        usage={"prompt_tokens": 26, "completion_tokens": 1, "total_tokens": 27, "cost": 0.00371, provider_key: True},
+    )
+
+    response: Final = stream_chunk_builder(chunks=[chunk])
+
+    assert response is not None
+    assert getattr(response.usage, "cost", None) == 0.00371
+
 def test_stream_chunk_builder_tolerates_trailing_chunk_without_choices():
     """Regression for https://github.com/BerriAI/litellm/issues/32051
 
diff --git a/tests/unit/litellm_core_utils/test_streaming_handler.py b/tests/unit/litellm_core_utils/test_streaming_handler.py
index a956d5ad284..9bcda6563d8 100644
--- a/tests/unit/litellm_core_utils/test_streaming_handler.py
+++ b/tests/unit/litellm_core_utils/test_streaming_handler.py
@@ -12,7 +12,7 @@ from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from itertools import chain
 from pathlib import Path
-from types import CodeType, FrameType, MappingProxyType
+from types import CodeType, FrameType, MappingProxyType, TracebackType
 from typing import AsyncIterator, Callable, Final, Iterator, Literal, NoReturn, Optional, cast
 from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
@@ -6298,53 +6298,76 @@ def test_openai_chunk_creator_skips_full_chunk_dump_and_delta_rebuild(
     assert finish_output.choices[0].delta.content is None
 
 
-def _openai_chunk(chunk_id: str, delta: Mapping[str, object]) -> ChatCompletionChunk:
+def _openai_chunk(
+    chunk_id: str,
+    delta: Mapping[str, object],
+    choice_extras: Mapping[str, object] = MappingProxyType({}),
+    finish_reason: str | None = None,
+    chunk_extras: Mapping[str, object] = MappingProxyType({}),
+) -> ChatCompletionChunk:
     return ChatCompletionChunk(
         id=chunk_id,
         created=1,
         model="gpt-4o",
         object="chat.completion.chunk",
-        choices=[{"index": 0, "delta": delta, "finish_reason": None}],
+        choices=[{"index": 0, "delta": delta, "finish_reason": finish_reason, **choice_extras}],
+        **chunk_extras,
     )
 
 
-def _missed_attributes(wrapper: CustomStreamWrapper, chunks: Sequence[ChatCompletionChunk]) -> tuple[str, ...]:
-    attribute_lookup: Final = BaseModel.__getattr__.__code__
-    misses: Final[list[str]] = []
+def _raised_attribute_errors(wrapper: CustomStreamWrapper, chunks: Sequence[ChatCompletionChunk]) -> tuple[str, ...]:
+    raised: Final[list[str]] = []
 
-    def record_miss(frame: FrameType, event: str, arg: object) -> Callable[[FrameType, str, object], object]:
-        if event == "exception" and isinstance(arg, tuple) and isinstance(arg[1], AttributeError):
-            misses.append(str(frame.f_locals["item"]))
-        return record_miss
-
-    def trace_lookups(frame: FrameType, event: str, _arg: object) -> Callable[[FrameType, str, object], object] | None:
-        return record_miss if event == "call" and frame.f_code is attribute_lookup else None
+    def record_raise(frame: FrameType, event: str, arg: object) -> Callable[[FrameType, str, object], object]:
+        if event == "exception" and isinstance(arg, tuple):
+            _, error, traceback = arg
+            if isinstance(error, AttributeError) and isinstance(traceback, TracebackType) and traceback.tb_next is None:
+                raised.append(f"{frame.f_code.co_qualname}: {error}")
+        return record_raise
 
     previous_tracer: Final = sys.gettrace()
-    sys.settrace(trace_lookups)
+    sys.settrace(record_raise)
     try:
         tuple(wrapper.chunk_creator(chunk=chunk) for chunk in chunks)
     finally:
         sys.settrace(previous_tracer)
-    return tuple(misses)
+    return tuple(raised)
 
 
-def test_openai_chunk_creator_builds_one_delta_and_misses_no_attribute_per_later_chunk(
-    logging_obj: Logging,
+_AZURE_CHOICE_EXTRAS: Final = MappingProxyType(
+    {"content_filter_results": {"hate": {"filtered": False, "severity": "safe"}}}
+)
+_OPENAI_AND_AZURE_CHOICE_EXTRAS: Final = (
+    pytest.param("openai", MappingProxyType({}), id="openai"),
+    pytest.param("azure", _AZURE_CHOICE_EXTRAS, id="azure"),
+)
+
+
+@pytest.mark.parametrize(("custom_llm_provider", "choice_extras"), _OPENAI_AND_AZURE_CHOICE_EXTRAS)
+def test_openai_chunk_creator_builds_one_delta_and_raises_no_attribute_error_per_later_chunk(
+    logging_obj: Logging, custom_llm_provider: str, choice_extras: Mapping[str, object]
 ) -> None:
     wrapper: Final = CustomStreamWrapper(
         completion_stream=iter(()),
         model="gpt-4o",
-        custom_llm_provider="openai",
+        custom_llm_provider=custom_llm_provider,
         logging_obj=logging_obj,
     )
-    wrapper.chunk_creator(chunk=_openai_chunk("chunk-1", {"role": "assistant", "content": ""}))
-    plain_chunks: Final = (
-        _openai_chunk("chunk-2", {"content": "hello"}),
-        _openai_chunk("chunk-3", {"content": " world"}),
+
+    def later_chunk(chunk_id: str, delta: Mapping[str, object]) -> ChatCompletionChunk:
+        return _openai_chunk(
+            chunk_id, delta, choice_extras, chunk_extras={"service_tier": "default", "obfuscation": chunk_id}
+        )
+
+    nested_delta: Final = {"content": "!", "reasoning_details": [{"type": "reasoning.text", "text": "thought"}]}
+    first_chunk_of_each_shape: Final = (
+        later_chunk("chunk-1", {"role": "assistant", "content": ""}),
+        later_chunk("chunk-2", nested_delta),
     )
-    nested_chunk: Final = _openai_chunk(
-        "chunk-4", {"content": "!", "reasoning_details": [{"type": "reasoning.text", "text": "thought"}]}
+    tuple(wrapper.chunk_creator(chunk=chunk) for chunk in first_chunk_of_each_shape)
+    plain_chunks: Final = (
+        later_chunk("chunk-3", {"content": "hello"}),
+        later_chunk("chunk-4", {"content": " world"}),
     )
     delta_init: Final = Delta.__init__.__code__
     streaming_choices_init: Final = StreamingChoices.__init__.__code__
@@ -6354,7 +6377,145 @@ def test_openai_chunk_creator_builds_one_delta_and_misses_no_attribute_per_later
     assert sum(call.code is delta_init for call in calls) == len(plain_chunks)
     assert sum(call.code is streaming_choices_init for call in calls) == len(plain_chunks)
     assert [output.choices[0].delta.content if output else None for output in outputs] == ["hello", " world"]
-    assert _missed_attributes(wrapper, (*plain_chunks, nested_chunk)) == ()
+    assert _raised_attribute_errors(wrapper, (*plain_chunks, later_chunk("chunk-5", nested_delta))) == ()
+
+
+_OPENAI_STREAM_JSON: Final = (
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"finish_reason":null,"index":0,'
+        '"delta":{"provider_specific_fields":null,"refusal":null,"content":"","role":"assistant",'
+        '"function_call":null,"tool_calls":null,"audio":null},"logprobs":null}],'
+        '"provider_specific_fields":null,"citations":null,"service_tier":"default","obfuscation":"o0"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"finish_reason":null,"index":0,'
+        '"delta":{"provider_specific_fields":null,"refusal":null,"content":"one","role":null,'
+        '"function_call":null,"tool_calls":null,"audio":null},"logprobs":null}],'
+        '"provider_specific_fields":null,"citations":null,"service_tier":"default","obfuscation":"o1"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"finish_reason":null,"index":0,'
+        '"delta":{"provider_specific_fields":null,"refusal":null,"content":" two","role":null,'
+        '"function_call":null,"tool_calls":null,"audio":null},"logprobs":null}],'
+        '"provider_specific_fields":null,"citations":null,"service_tier":"default","obfuscation":"o2"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"finish_reason":"stop","index":0,'
+        '"delta":{"provider_specific_fields":null,"content":null,"role":null,"function_call":null,'
+        '"tool_calls":null,"audio":null},"logprobs":null}],"provider_specific_fields":null,'
+        '"service_tier":"default","obfuscation":"o3"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[],"provider_specific_fields":null,'
+        '"usage":{"completion_tokens":3,"prompt_tokens":9,"total_tokens":12,"completion_tokens_details":null,'
+        '"prompt_tokens_details":null}}'
+    ),
+)
+_AZURE_STREAM_JSON: Final = (
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"content_filter_results":{"hate":{"filtered":false,'
+        '"severity":"safe"}},"finish_reason":null,"index":0,"delta":{"provider_specific_fields":null,'
+        '"refusal":null,"content":"","role":"assistant","function_call":null,"tool_calls":null,"audio":null},'
+        '"logprobs":null}],"provider_specific_fields":null,"citations":null,"service_tier":"default",'
+        '"obfuscation":"o0"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"content_filter_results":{"hate":{"filtered":false,'
+        '"severity":"safe"}},"finish_reason":null,"index":0,"delta":{"provider_specific_fields":null,'
+        '"refusal":null,"content":"one","role":null,"function_call":null,"tool_calls":null,"audio":null},'
+        '"logprobs":null}],"provider_specific_fields":null,"citations":null,"service_tier":"default",'
+        '"obfuscation":"o1"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"content_filter_results":{"hate":{"filtered":false,'
+        '"severity":"safe"}},"finish_reason":null,"index":0,"delta":{"provider_specific_fields":null,'
+        '"refusal":null,"content":" two","role":null,"function_call":null,"tool_calls":null,"audio":null},'
+        '"logprobs":null}],"provider_specific_fields":null,"citations":null,"service_tier":"default",'
+        '"obfuscation":"o2"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[{"finish_reason":"stop","index":0,'
+        '"delta":{"provider_specific_fields":null,"content":null,"role":null,"function_call":null,'
+        '"tool_calls":null,"audio":null},"logprobs":null}],"provider_specific_fields":null,'
+        '"service_tier":"default","obfuscation":"o3"}'
+    ),
+    (
+        '{"id":"chatcmpl-1","created":1,"model":"gpt-4o","object":"chat.completion.chunk",'
+        '"system_fingerprint":null,"choices":[],"provider_specific_fields":null,'
+        '"usage":{"completion_tokens":3,"prompt_tokens":9,"total_tokens":12,"completion_tokens_details":null,'
+        '"prompt_tokens_details":null}}'
+    ),
+)
+
+
+@pytest.mark.parametrize(
+    ("custom_llm_provider", "choice_extras", "expected_json"),
+    [
+        pytest.param("openai", MappingProxyType({}), _OPENAI_STREAM_JSON, id="openai"),
+        pytest.param("azure", _AZURE_CHOICE_EXTRAS, _AZURE_STREAM_JSON, id="azure"),
+    ],
+)
+def test_openai_chunk_creator_emits_each_chunk_as_the_same_json(
+    logging_obj: Logging,
+    custom_llm_provider: str,
+    choice_extras: Mapping[str, object],
+    expected_json: tuple[str | None, ...],
+) -> None:
+    wrapper: Final = CustomStreamWrapper(
+        completion_stream=iter(()),
+        model="gpt-4o",
+        custom_llm_provider=custom_llm_provider,
+        logging_obj=logging_obj,
+        stream_options={"include_usage": True},
+    )
+    chunks: Final = (
+        _openai_chunk(
+            "chatcmpl-1",
+            {"role": "assistant", "content": ""},
+            choice_extras,
+            chunk_extras={"service_tier": "default", "obfuscation": "o0"},
+        ),
+        _openai_chunk(
+            "chatcmpl-1",
+            {"content": "one"},
+            choice_extras,
+            chunk_extras={"service_tier": "default", "obfuscation": "o1"},
+        ),
+        _openai_chunk(
+            "chatcmpl-1",
+            {"content": " two"},
+            choice_extras,
+            chunk_extras={"service_tier": "default", "obfuscation": "o2"},
+        ),
+        _openai_chunk(
+            "chatcmpl-1", {}, choice_extras, "stop", chunk_extras={"service_tier": "default", "obfuscation": "o3"}
+        ),
+        ChatCompletionChunk(
+            id="chatcmpl-1",
+            created=1,
+            model="gpt-4o",
+            object="chat.completion.chunk",
+            choices=[],
+            service_tier="default",
+            obfuscation="o4",
+            usage={"prompt_tokens": 9, "completion_tokens": 3, "total_tokens": 12},
+        ),
+    )
+
+    outputs: Final = tuple(wrapper.chunk_creator(chunk=chunk) for chunk in chunks)
+
+    assert tuple(
+        output.model_copy(update={"created": 1}).model_dump_json() if output else None for output in outputs
+    ) == expected_json
 
 
 def test_chunk_creator_skips_full_dump_of_model_response_stream_chunks(
diff --git a/tests/unit/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py b/tests/unit/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py
index d815e1eedd3..c2ee58b67ed 100644
--- a/tests/unit/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py
+++ b/tests/unit/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py
@@ -6,6 +6,7 @@ with guardrail transformations, specifically testing edge cases with empty choic
 """
 
 import json
+import logging
 import re
 from typing import Any, Literal, Optional, Final
 from unittest.mock import MagicMock, patch
@@ -3391,3 +3392,18 @@ class TestAnthropicMessagesHandlerPostCallHookResponse:
         native = {"type": "message", "role": "assistant", "content": [{"type": "text", "text": "hi"}]}
 
         assert AnthropicMessagesHandler().post_call_hook_response(native) is native
+
+
+def test_reading_a_dropped_budget_for_a_guardrail_logs_no_drop_warning(caplog: pytest.LogCaptureFixture) -> None:
+    data: Final = {
+        "model": "gemini-2.5-flash",
+        "max_tokens": 64,
+        "thinking": {"type": "enabled", "budget_tokens": "high"},
+        "messages": [{"role": "user", "content": "hi"}],
+    }
+
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        messages: Final = AnthropicMessagesHandler().get_structured_messages(data)
+
+    assert messages == [{"role": "user", "content": "hi"}]
+    assert not [record for record in caplog.records if "Dropping" in record.getMessage()]
diff --git a/tests/unit/llms/anthropic/chat/test_anthropic_chat_transformation.py b/tests/unit/llms/anthropic/chat/test_anthropic_chat_transformation.py
index 4d5d6cc17a9..cbb60caa57b 100644
--- a/tests/unit/llms/anthropic/chat/test_anthropic_chat_transformation.py
+++ b/tests/unit/llms/anthropic/chat/test_anthropic_chat_transformation.py
@@ -1,5 +1,6 @@
 import copy
 import json
+import logging
 from itertools import chain
 from typing import Final
 from unittest.mock import MagicMock, patch
@@ -3189,6 +3190,47 @@ def test_reasoning_effort_accepts_dict_shape_for_non_adaptive_model(
     )
 
 
+def _reasoning_effort_drop_warnings(caplog: pytest.LogCaptureFixture) -> tuple[str, ...]:
+    return tuple(
+        record.getMessage() for record in caplog.records if "Dropping reasoning_effort=" in record.getMessage()
+    )
+
+
+@pytest.mark.parametrize("reasoning_effort_value", [5, {"effort": 5, "summary": "concise"}])
+def test_reasoning_effort_that_is_not_a_level_name_is_dropped_with_one_warning(
+    reasoning_effort_value: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        result: Final = AnthropicConfig().map_openai_params(
+            non_default_params={"reasoning_effort": reasoning_effort_value},
+            optional_params={},
+            model="claude-sonnet-4-6-20260219",
+            drop_params=False,
+        )
+
+    warnings: Final = _reasoning_effort_drop_warnings(caplog)
+    assert "thinking" not in result
+    assert "output_config" not in result
+    assert len(warnings) == 1
+    assert f"reasoning_effort={reasoning_effort_value!r}" in warnings[0]
+    assert "claude-sonnet-4-6-20260219" in warnings[0]
+
+
+@pytest.mark.parametrize("reasoning_effort_value", [{"summary": "concise"}, {"effort": "low", "summary": "concise"}])
+def test_reasoning_effort_with_a_level_name_or_no_level_logs_no_drop(
+    reasoning_effort_value: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        AnthropicConfig().map_openai_params(
+            non_default_params={"reasoning_effort": reasoning_effort_value},
+            optional_params={},
+            model="claude-sonnet-4-6-20260219",
+            drop_params=False,
+        )
+
+    assert _reasoning_effort_drop_warnings(caplog) == ()
+
+
 @pytest.mark.parametrize(
     "model,budget_tokens,expected",
     [
diff --git a/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py b/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py
index c30644e7fdc..e0882653324 100644
--- a/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py
+++ b/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py
@@ -1,6 +1,7 @@
 import base64
 import functools
 import json
+import logging
 from collections.abc import Mapping
 from types import MappingProxyType
 from typing import Any, Final, cast
@@ -2871,14 +2872,21 @@ def test_translate_completion_input_params_rejects_a_non_numeric_budget_without_
 
 @pytest.mark.parametrize("budget", ["2048", True])
 def test_translate_completion_input_params_drops_a_non_numeric_budget_under_drop_params(
-    budget: object, monkeypatch: pytest.MonkeyPatch
+    budget: object, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
 ):
     monkeypatch.setattr(litellm, "drop_params", False)
-    translated: Final = AnthropicAdapter().translate_completion_input_params(
-        _gemini_request_with_budget(budget, drop_params=True)
-    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        translated: Final = AnthropicAdapter().translate_completion_input_params(
+            _gemini_request_with_budget(budget, drop_params=True)
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
     assert translated is not None
     assert not {"reasoning_effort", "thinking"} & translated.keys()
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0]
+        for fragment in (f"thinking.budget_tokens={budget!r}", "gemini-2.5-flash", "(drop_params=True)")
+    )
 
 
 def test_translate_openai_content_to_anthropic_reasoning_content_without_thinking_blocks():
diff --git a/tests/unit/llms/anthropic/messages/adapters/test_handler_reasoning_effort_normalization.py b/tests/unit/llms/anthropic/messages/adapters/test_handler_reasoning_effort_normalization.py
index e504513dd36..27ed1f5ebd6 100644
--- a/tests/unit/llms/anthropic/messages/adapters/test_handler_reasoning_effort_normalization.py
+++ b/tests/unit/llms/anthropic/messages/adapters/test_handler_reasoning_effort_normalization.py
@@ -8,6 +8,7 @@ leaves the adapter, in the shape the target expects.
 
 import functools
 import json
+import logging
 from collections.abc import Mapping
 from typing import Final
 
@@ -510,26 +511,33 @@ class TestADeclaredDeploymentRoundsTheMessagesTierOntoItsLevels:
     @pytest.mark.asyncio
     @pytest.mark.parametrize("budget", ["2048", True])
     @pytest.mark.parametrize("litellm_params, model_info, upstream_url, upstream_body", _MALFORMED_BUDGET_TARGETS)
-    async def test_drop_params_drops_a_non_numeric_budget(
+    async def test_drop_params_drops_a_non_numeric_budget_with_one_warning(
         self,
         local_model_cost_map: None,
         respx_mock: respx.MockRouter,
+        caplog: pytest.LogCaptureFixture,
         litellm_params: Mapping[str, object],
         model_info: Mapping[str, object],
         upstream_url: str,
         upstream_body: Mapping[str, object],
         budget: object,
     ) -> None:
-        sent: Final = await _body_sent_upstream(
-            respx_mock,
-            {**litellm_params, "drop_params": True},
-            model_info,
-            upstream_url,
-            upstream_body,
-            thinking={"type": "enabled", "budget_tokens": budget},
-        )
+        with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+            sent: Final = await _body_sent_upstream(
+                respx_mock,
+                {**litellm_params, "drop_params": True},
+                model_info,
+                upstream_url,
+                upstream_body,
+                thinking={"type": "enabled", "budget_tokens": budget},
+            )
 
         assert not {"reasoning_effort", "reasoning", "thinking"} & sent.keys()
+        dropped: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+        assert len(dropped) == 1
+        assert f"thinking.budget_tokens={budget!r}" in dropped[0]
+        assert "(drop_params=True)" in dropped[0]
+        assert str(litellm_params["model"]).split("/", 1)[1] in dropped[0]
 
     @pytest.mark.asyncio
     @pytest.mark.parametrize(
diff --git a/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_handler.py b/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_handler.py
index 5ce6d03f477..af3108e5072 100644
--- a/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_handler.py
+++ b/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_handler.py
@@ -159,7 +159,7 @@ async def test_openai_model_does_not_forward_stream_options_to_responses_api():
         await litellm.anthropic.messages.acreate(
             max_tokens=100,
             messages=[{"role": "user", "content": "Hello, how are you?"}],
-            model="openai/gpt-5.5",
+            model="openai/gpt-6.1-sol",
             api_key="test-api-key",
             stream_options={"include_usage": True},
         )
@@ -669,7 +669,9 @@ class TestThinkingSummaryPreservation:
         )
 
         thinking = {"type": "enabled", "budget_tokens": 5000, "summary": "concise"}
-        result = LiteLLMAnthropicToResponsesAPIAdapter.translate_thinking_to_reasoning(thinking)
+        result = LiteLLMAnthropicToResponsesAPIAdapter.translate_thinking_to_reasoning(
+            thinking, model="openai/gpt-6.1-sol"
+        )
         assert result == {"effort": "high", "summary": "concise"}
 
     def test_responses_adapter_no_summary_by_default(self):
@@ -683,7 +685,9 @@ class TestThinkingSummaryPreservation:
         try:
             litellm.reasoning_auto_summary = False
             thinking = {"type": "enabled", "budget_tokens": 5000}
-            result = LiteLLMAnthropicToResponsesAPIAdapter.translate_thinking_to_reasoning(thinking)
+            result = LiteLLMAnthropicToResponsesAPIAdapter.translate_thinking_to_reasoning(
+                thinking, model="openai/gpt-6.1-sol"
+            )
             assert result == {"effort": "high"}
             assert result is not None and "summary" not in result
         finally:
diff --git a/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_router.py b/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_router.py
index 596cb968a0e..1d0d70d8e60 100644
--- a/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_router.py
+++ b/tests/unit/llms/anthropic/messages/native/test_anthropic_messages_router.py
@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import base64
 import json
+import logging
 import struct
 import time
 import uuid
@@ -891,24 +892,32 @@ async def test_native_messages_send_no_effort_for_a_default_effort_beside_a_thin
 @pytest.mark.asyncio
 @pytest.mark.parametrize("model_info", [None, _DECLARING_LOW_AND_HIGH])
 @pytest.mark.parametrize("drop_globally", [False, True])
-async def test_native_messages_drop_params_drops_a_non_numeric_thinking_budget_on_adaptive_claude(
+async def test_native_messages_drop_params_drops_a_non_numeric_thinking_budget_on_adaptive_claude_with_one_warning(
     respx_mock: respx.MockRouter,
     monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
     model_info: Mapping[str, object] | None,
     drop_globally: bool,
 ) -> None:
     monkeypatch.setattr(litellm, "drop_params", drop_globally)
     request_drop: Final = {} if drop_globally else {"drop_params": True}
 
-    dropped: Final = await _native_opus_body_sent(
-        respx_mock, model_info, thinking={"type": "enabled", "budget_tokens": "lots"}, **request_drop
-    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        dropped: Final = await _native_opus_body_sent(
+            respx_mock, model_info, thinking={"type": "enabled", "budget_tokens": "lots"}, **request_drop
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
     adaptive_alone: Final = await _native_opus_body_sent(
         respx_mock, model_info, thinking={"type": "adaptive"}, **request_drop
     )
 
     assert "output_config" not in adaptive_alone
     assert dropped == adaptive_alone
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0]
+        for fragment in ("thinking.budget_tokens='lots'", "claude-opus-5-5", "(drop_params=True)")
+    )
 
 
 _MIXED_GROUP: Final = "gpt-5.6-mixed"
diff --git a/tests/unit/llms/anthropic/messages/native/test_reasoning_effort_translation.py b/tests/unit/llms/anthropic/messages/native/test_reasoning_effort_translation.py
index 50dc0deabfd..28abb348371 100644
--- a/tests/unit/llms/anthropic/messages/native/test_reasoning_effort_translation.py
+++ b/tests/unit/llms/anthropic/messages/native/test_reasoning_effort_translation.py
@@ -1,5 +1,8 @@
 """Tests for ``reasoning_effort`` translation on the Anthropic /v1/messages route."""
 
+import logging
+from typing import Final
+
 import pytest
 
 from litellm.constants import (
@@ -46,6 +49,49 @@ def test_reasoning_effort_maps_to_output_config_for_adaptive_model(
     assert result.get("output_config") == {"effort": expected_effort}
 
 
+def _reasoning_effort_drop_warnings(caplog: pytest.LogCaptureFixture) -> tuple[str, ...]:
+    return tuple(
+        record.getMessage() for record in caplog.records if "Dropping reasoning_effort=" in record.getMessage()
+    )
+
+
+@pytest.mark.parametrize("reasoning_effort", [5, {"effort": "high"}])
+def test_reasoning_effort_that_is_not_a_string_is_dropped_with_one_warning(
+    reasoning_effort: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        result: Final = AnthropicMessagesConfig().transform_anthropic_messages_request(
+            model="claude-opus-4-7",
+            messages=[{"role": "user", "content": "Hello"}],
+            anthropic_messages_optional_request_params={"max_tokens": 1024, "reasoning_effort": reasoning_effort},
+            litellm_params={},
+            headers={},
+        )
+
+    warnings: Final = _reasoning_effort_drop_warnings(caplog)
+    assert "reasoning_effort" not in result
+    assert "output_config" not in result
+    assert len(warnings) == 1
+    assert f"reasoning_effort={reasoning_effort!r}" in warnings[0]
+    assert "claude-opus-4-7" in warnings[0]
+
+
+@pytest.mark.parametrize("reasoning_effort", ["high", {"summary": "concise"}])
+def test_reasoning_effort_that_is_a_string_or_names_no_level_logs_no_drop(
+    reasoning_effort: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        AnthropicMessagesConfig().transform_anthropic_messages_request(
+            model="claude-opus-4-7",
+            messages=[{"role": "user", "content": "Hello"}],
+            anthropic_messages_optional_request_params={"max_tokens": 1024, "reasoning_effort": reasoning_effort},
+            litellm_params={},
+            headers={},
+        )
+
+    assert _reasoning_effort_drop_warnings(caplog) == ()
+
+
 def test_reasoning_effort_none_clears_thinking_and_output_config():
     config = AnthropicMessagesConfig()
     optional_params = {
diff --git a/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py b/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py
index f6fcb9e6f1e..ece0cf5d423 100644
--- a/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py
+++ b/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py
@@ -44,6 +44,7 @@ def _make_request(**overrides) -> AnthropicMessagesRequest:
 
 
 _ADAPTER = LiteLLMAnthropicToResponsesAPIAdapter()
+_MODEL: Final = "openai/gpt-6.1-sol"
 
 
 # ---------------------------------------------------------------------------
@@ -957,13 +958,13 @@ class TestTranslateThinkingToReasoning:
     """Anthropic thinking param -> Responses API reasoning param."""
 
     def test_budget_high_effort(self):
-        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 10000})
+        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 10000}, model=_MODEL)
         # Default (reasoning_auto_summary=False): only effort, no summary
         assert result == {"effort": "high"}
         assert result is not None and "summary" not in result
 
     def test_budget_above_threshold_high_effort(self):
-        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 50000})
+        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 50000}, model=_MODEL)
         assert result is not None
         assert result["effort"] == "high"
         assert "summary" not in result
@@ -973,7 +974,8 @@ class TestTranslateThinkingToReasoning:
             {
                 "type": "enabled",
                 "budget_tokens": DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET,
-            }
+            },
+            model=_MODEL,
         )
         assert result == {"effort": "medium"}
         assert result is not None and "summary" not in result
@@ -983,13 +985,14 @@ class TestTranslateThinkingToReasoning:
             {
                 "type": "enabled",
                 "budget_tokens": DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET,
-            }
+            },
+            model=_MODEL,
         )
         assert result == {"effort": "low"}
         assert result is not None and "summary" not in result
 
     def test_budget_minimal_effort(self):
-        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 500})
+        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 500}, model=_MODEL)
         assert result == {"effort": "minimal"}
         assert result is not None and "summary" not in result
 
@@ -998,7 +1001,8 @@ class TestTranslateThinkingToReasoning:
             {
                 "type": "enabled",
                 "budget_tokens": DEFAULT_REASONING_EFFORT_HIGH_THINKING_BUDGET,
-            }
+            },
+            model=_MODEL,
         )
         assert result_high is not None
         assert result_high["effort"] == "high"
@@ -1006,7 +1010,8 @@ class TestTranslateThinkingToReasoning:
             {
                 "type": "enabled",
                 "budget_tokens": DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET,
-            }
+            },
+            model=_MODEL,
         )
         assert result_medium is not None
         assert result_medium["effort"] == "medium"
@@ -1015,23 +1020,24 @@ class TestTranslateThinkingToReasoning:
             {
                 "type": "enabled",
                 "budget_tokens": DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET,
-            }
+            },
+            model=_MODEL,
         )
         assert result_low is not None
         assert result_low["effort"] == "low"
         assert "summary" not in result_low
 
     def test_disabled_type_returns_none(self):
-        result = _ADAPTER.translate_thinking_to_reasoning({"type": "disabled"})
+        result = _ADAPTER.translate_thinking_to_reasoning({"type": "disabled"}, model=_MODEL)
         assert result is None
 
     def test_non_dict_returns_none(self):
-        result = _ADAPTER.translate_thinking_to_reasoning("enabled")  # type: ignore
+        result = _ADAPTER.translate_thinking_to_reasoning("enabled", model=_MODEL)  # type: ignore
         assert result is None
 
     def test_missing_budget_defaults_to_minimal(self):
         """Missing budget_tokens defaults to 0, below the low threshold -> minimal."""
-        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled"})
+        result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled"}, model=_MODEL)
         assert result == {"effort": "minimal"}
         assert result is not None and "summary" not in result
 
@@ -1042,7 +1048,7 @@ class TestTranslateThinkingToReasoning:
         original = litellm.reasoning_auto_summary
         try:
             litellm.reasoning_auto_summary = True
-            result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 10000})
+            result = _ADAPTER.translate_thinking_to_reasoning({"type": "enabled", "budget_tokens": 10000}, model=_MODEL)
             assert result == {"effort": "high", "summary": "detailed"}
         finally:
             litellm.reasoning_auto_summary = original
@@ -1059,7 +1065,8 @@ class TestTranslateThinkingToReasoning:
                 {
                     "type": "enabled",
                     "budget_tokens": DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET,
-                }
+                },
+                model=_MODEL,
             )
             assert result == {"effort": "medium", "summary": "detailed"}
         finally:
diff --git a/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py b/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py
index 3432c9503de..7128c04a056 100644
--- a/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py
+++ b/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py
@@ -162,7 +162,8 @@ class TestAdapterAdaptiveThinking:
 
         adapter = LiteLLMAnthropicMessagesAdapter()
         result = adapter.translate_anthropic_thinking_to_reasoning_effort(
-            {"type": "adaptive"}
+            {"type": "adaptive"},
+            model="openai/gpt-6.1-sol",
         )
         assert result == "medium"
 
@@ -198,6 +199,7 @@ class TestAdapterAdaptiveThinking:
         result = LiteLLMAnthropicToResponsesAPIAdapter.translate_thinking_to_reasoning(
             thinking={"type": "adaptive"},
             output_config={"effort": "xhigh"},
+            model="openai/gpt-6.1-sol",
         )
         assert result is not None
         assert result["effort"] == "xhigh"
@@ -210,6 +212,7 @@ class TestAdapterAdaptiveThinking:
 
         result = LiteLLMAnthropicToResponsesAPIAdapter.translate_thinking_to_reasoning(
             thinking={"type": "adaptive"},
+            model="openai/gpt-6.1-sol",
         )
         assert result is not None
         assert result["effort"] == "medium"
diff --git a/tests/unit/llms/anthropic/test_anthropic_common_utils.py b/tests/unit/llms/anthropic/test_anthropic_common_utils.py
index 3ec72f29d34..0808ce0ec3c 100644
--- a/tests/unit/llms/anthropic/test_anthropic_common_utils.py
+++ b/tests/unit/llms/anthropic/test_anthropic_common_utils.py
@@ -11,6 +11,7 @@ Verifies that:
 """
 
 import json
+import logging
 import os
 import sys
 import threading
@@ -3543,12 +3544,11 @@ class TestWifProviderAllowlist:
         monkeypatch.setenv("WIF_TEST_JWT", "jwt-assertion-value")
 
     def test_vertex_anthropic_never_mints_or_sends_the_assertion(self, monkeypatch, wif_engine):
+        import litellm
         from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation import (
             VertexAIAnthropicConfig,
         )
 
-        import litellm
-
         poster, calls = wif_engine
         self._env_only_wif(monkeypatch)
 
@@ -3774,7 +3774,7 @@ class TestModelDiscovery:
         )
         monkeypatch.setattr("litellm.module_level_client", client)
 
-        with pytest.raises(Exception, match="invalid x-api-key") as exc_info:  # noqa: B017, PT011  # the callee raises a bare Exception; match pins the sanitized text
+        with pytest.raises(Exception, match="invalid x-api-key") as exc_info:  # noqa: B017  # the callee raises a bare Exception; match pins the sanitized text
             AnthropicModelInfo().get_models(api_base="https://api.anthropic.com")
 
         assert "invalid x-api-key" in str(exc_info.value)
@@ -4237,15 +4237,18 @@ def test_thinking_display_beta_requires_active_thinking(thinking: object, expect
 
 @pytest.mark.usefixtures("local_model_cost_map")
 @pytest.mark.parametrize(
-    ("display", "expected_thinking"),
+    ("provider", "display", "expected_thinking"),
     (
-        ("summarized", {"type": "adaptive", "display": "summarized"}),
-        ("omitted", {"type": "adaptive", "display": "omitted"}),
-        ("updates", {"type": "adaptive"}),
+        ("azure_ai", "summarized", {"type": "adaptive", "display": "summarized"}),
+        ("azure_ai", "omitted", {"type": "adaptive", "display": "omitted"}),
+        ("azure_ai", "updates", {"type": "adaptive", "display": "updates"}),
+        ("vertex_ai", "updates", {"type": "adaptive", "display": "updates"}),
+        ("anthropic", "updates", {"type": "adaptive", "display": "updates"}),
+        ("databricks", "updates", {"type": "adaptive"}),
     ),
 )
 def test_shared_legacy_thinking_translation_preserves_supported_display(
-    display: str, expected_thinking: dict[str, str]
+    provider: str, display: str, expected_thinking: dict[str, str]
 ) -> None:
     from litellm.llms.anthropic.common_utils import AnthropicModelInfo
 
@@ -4256,7 +4259,7 @@ def test_shared_legacy_thinking_translation_preserves_supported_display(
     AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model(
         model="claude-opus-5",
         optional_params=optional_params,
-        custom_llm_provider="azure_ai",
+        custom_llm_provider=provider,
         drop_params=False,
     )
 
@@ -4530,16 +4533,66 @@ def test_shared_legacy_thinking_translation_rejects_a_non_numeric_budget(budget_
 
 @pytest.mark.usefixtures("local_model_cost_map")
 @pytest.mark.parametrize("budget_tokens", _NON_NUMERIC_BUDGETS)
-def test_shared_legacy_thinking_translation_drops_a_non_numeric_budget_under_drop_params(budget_tokens: object) -> None:
+def test_shared_legacy_thinking_translation_drops_a_non_numeric_budget_under_drop_params(
+    budget_tokens: object, caplog: pytest.LogCaptureFixture
+) -> None:
     from litellm.llms.anthropic.common_utils import AnthropicModelInfo
 
     optional_params: Final = {"thinking": {"type": "enabled", "budget_tokens": budget_tokens}}
 
-    AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model(
-        model="claude-opus-5", optional_params=optional_params, custom_llm_provider="azure_ai", drop_params=True
-    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        AnthropicModelInfo.translate_legacy_thinking_for_adaptive_model(
+            model="claude-opus-5", optional_params=optional_params, custom_llm_provider="azure_ai", drop_params=True
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
 
     assert optional_params == {"thinking": {"type": "adaptive"}}
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0]
+        for fragment in (f"thinking.budget_tokens={budget_tokens!r}", "claude-opus-5", "(drop_params=True)")
+    )
+
+
+_SIGNED_COMPACTION_BLOCK: Final = {"type": "compaction", "content": "summary so far", "signature": "sig"}
+
+
+@pytest.mark.parametrize(
+    "provider,expected",
+    [("anthropic", True), ("vertex_ai", True), ("azure_ai", True), ("bedrock", False), ("bedrock_converse", False)],
+)
+@pytest.mark.parametrize(
+    "optional_params,messages",
+    [
+        ({"compaction": {"type": "summarize"}}, [{"role": "user", "content": "hi"}]),
+        ({}, [{"role": "assistant", "content": [_SIGNED_COMPACTION_BLOCK]}, {"role": "user", "content": "go on"}]),
+    ],
+    ids=["compaction_param", "signed_compaction_block"],
+)
+def test_requires_native_compaction_beta_per_provider(
+    provider: str, expected: bool, optional_params: dict[str, object], messages: list[object]
+) -> None:
+    from litellm.llms.anthropic.common_utils import requires_native_compaction_beta
+
+    assert requires_native_compaction_beta(provider, optional_params, messages) is expected
+
+
+@pytest.mark.parametrize("provider", ["anthropic", "azure_ai", "vertex_ai"])
+@pytest.mark.parametrize(
+    "optional_params,messages",
+    [
+        ({"max_tokens": 64}, [{"role": "user", "content": "hi"}]),
+        ({}, [{"role": "assistant", "content": [{"type": "compaction", "content": "unsigned"}]}]),
+        ({"compaction": None}, [{"role": "user", "content": "hi"}]),
+    ],
+    ids=["no_signal", "unsigned_block", "compaction_none"],
+)
+def test_requires_native_compaction_beta_is_false_without_a_signal(
+    provider: str, optional_params: dict[str, object], messages: list[object]
+) -> None:
+    from litellm.llms.anthropic.common_utils import requires_native_compaction_beta
+
+    assert requires_native_compaction_beta(provider, optional_params, messages) is False
 
 
 @pytest.mark.parametrize(
diff --git a/tests/unit/llms/anthropic/test_anthropic_prompt_cache_prediction.py b/tests/unit/llms/anthropic/test_anthropic_prompt_cache_prediction.py
index 4d0ebef4f2d..d95f831df3e 100644
--- a/tests/unit/llms/anthropic/test_anthropic_prompt_cache_prediction.py
+++ b/tests/unit/llms/anthropic/test_anthropic_prompt_cache_prediction.py
@@ -1,4 +1,5 @@
 import json
+import logging
 from collections.abc import Mapping
 from datetime import datetime
 from types import SimpleNamespace
@@ -597,6 +598,45 @@ async def test_native_count_preserves_settings_and_requires_every_prefix(
     assert unexpected.call_count == 0
 
 
+@pytest.mark.usefixtures("local_model_cost_map")
+def test_native_baseline_body_drops_a_non_numeric_budget_without_logging_a_drop(
+    monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    monkeypatch.setattr(litellm, "drop_params", True)
+    request: Final = {
+        "model": "claude-opus-5",
+        "max_tokens": 64,
+        "messages": [{"role": "user", "content": "hi"}],
+        "thinking": {"type": "enabled", "budget_tokens": "high"},
+    }
+
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        body: Final = prepare_native_baseline_body(request, "anthropic/claude-opus-5")
+
+    assert body is not None
+    assert body["thinking"] == {"type": "adaptive"}
+    assert [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()] == []
+
+
+@pytest.mark.usefixtures("local_model_cost_map")
+def test_native_baseline_body_drops_a_non_string_reasoning_effort_without_logging_a_drop(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    request: Final = {
+        "model": "claude-opus-5",
+        "max_tokens": 64,
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": 5,
+    }
+
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        body: Final = prepare_native_baseline_body(request, "anthropic/claude-opus-5")
+
+    assert body is not None
+    assert "reasoning_effort" not in body
+    assert [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()] == []
+
+
 def test_native_baseline_body_matches_the_sent_body_when_drop_params_meets_an_auto_added_beta(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
diff --git a/tests/unit/llms/azure_ai/anthropic/count_tokens/test_token_counter.py b/tests/unit/llms/azure_ai/anthropic/count_tokens/test_token_counter.py
index 4913d2b0d1d..7807975be24 100644
--- a/tests/unit/llms/azure_ai/anthropic/count_tokens/test_token_counter.py
+++ b/tests/unit/llms/azure_ai/anthropic/count_tokens/test_token_counter.py
@@ -215,3 +215,56 @@ async def test_count_uses_the_shared_api_base_chat_would_use(monkeypatch: pytest
     assert result is not None
     assert result.total_tokens == 6
     assert route.called
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("assistant_content", "expected_beta"),
+    [
+        (
+            [{"type": "compaction", "content": "Summary of the chat so far.", "signature": "sig-abc"}],
+            "compact-2026-09-04,token-counting-2024-11-01",
+        ),
+        ("Use Recipe and Step tables.", "token-counting-2024-11-01"),
+    ],
+    ids=("signed_compaction_block", "plain_turn"),
+)
+async def test_count_sends_the_compact_beta_only_when_the_history_replays_a_compaction_block(
+    monkeypatch: pytest.MonkeyPatch, assistant_content: object, expected_beta: str
+) -> None:
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    with respx.mock:
+        route: Final = respx.post(COUNT_URL).mock(return_value=httpx.Response(200, json={"input_tokens": 376}))
+        result: Final = await AzureAIAnthropicTokenCounter().count_tokens(
+            model_to_use="claude-sonnet-5-5",
+            messages=[
+                {"role": "assistant", "content": assistant_content},
+                {"role": "user", "content": "What tables did we pick?"},
+            ],
+            contents=None,
+            deployment={"litellm_params": {"api_key": "azure-key", "api_base": API_BASE}},
+            request_model="azure_ai/claude-sonnet-5-5",
+        )
+    assert result is not None
+    assert result.total_tokens == 376
+    assert route.calls.last.request.headers["anthropic-beta"] == expected_beta
+
+
+@pytest.mark.asyncio
+async def test_count_sends_the_tool_change_beta_when_the_history_adds_a_tool(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    with respx.mock:
+        route: Final = respx.post(COUNT_URL).mock(return_value=httpx.Response(200, json={"input_tokens": 541}))
+        result: Final = await AzureAIAnthropicTokenCounter().count_tokens(
+            model_to_use="claude-sonnet-5-5",
+            messages=[
+                {"role": "user", "content": "Use the ping tool once."},
+                {"role": "system", "content": [{"type": "tool_addition", "tool": {"type": "tool_reference", "name": "ping"}}]},
+            ],
+            contents=None,
+            deployment={"litellm_params": {"api_key": "azure-key", "api_base": API_BASE}},
+            request_model="azure_ai/claude-sonnet-5-5",
+        )
+    assert result is not None
+    assert result.total_tokens == 541
+    assert route.calls.last.request.headers["anthropic-beta"] == "mid-conversation-tool-changes-2026-07-01,token-counting-2024-11-01"
diff --git a/tests/unit/llms/azure_ai/chat/test_azure_ai_transformation.py b/tests/unit/llms/azure_ai/chat/test_azure_ai_transformation.py
index 145d45317c3..9f68a4fb73f 100644
--- a/tests/unit/llms/azure_ai/chat/test_azure_ai_transformation.py
+++ b/tests/unit/llms/azure_ai/chat/test_azure_ai_transformation.py
@@ -1,4 +1,5 @@
 import json
+import logging
 import traceback
 from collections.abc import Callable
 from types import MappingProxyType
@@ -758,6 +759,66 @@ def test_drop_tool_level_extra_fields_strips_copilot_mcp_server_name():
     assert result["tools"][1]["function"]["name"] == "read_file"
 
 
+def test_extra_parameters_error_drops_reasoning_effort_with_one_warning(caplog: pytest.LogCaptureFixture) -> None:
+    import httpx
+
+    error_text: Final = json.dumps(
+        {
+            "error": {
+                "message": "Extra parameters ['reasoning_effort'] are not allowed when extra-parameters is not set "
+                "or set to be 'error'. Set extra-parameters to 'pass-through' to pass to the model."
+            }
+        }
+    )
+    error: Final = httpx.HTTPStatusError(
+        message="422",
+        request=httpx.Request("POST", "https://example.services.ai.azure.com/models/chat/completions"),
+        response=httpx.Response(422, text=error_text),
+    )
+    request_data: Final = {
+        "model": "Kimi-K2.6",
+        "messages": [{"role": "user", "content": "Say hi."}],
+        "reasoning_effort": "high",
+    }
+
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        retried: Final = AzureAIStudioConfig().transform_request_on_unprocessable_entity_error(error, request_data)
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+
+    assert retried == {"model": "Kimi-K2.6", "messages": [{"role": "user", "content": "Say hi."}]}
+    assert len(drop_warnings) == 1
+    assert all(fragment in drop_warnings[0] for fragment in ("reasoning_effort='high'", "Kimi-K2.6"))
+    assert "drop_params" not in drop_warnings[0]
+
+
+def test_extra_inputs_error_names_drop_params_in_the_reasoning_drop_warning(caplog: pytest.LogCaptureFixture) -> None:
+    import httpx
+
+    detail: Final = [
+        {"type": "extra_forbidden", "loc": ["body", "reasoning_effort"], "msg": "Extra inputs are not permitted"}
+    ]
+    error: Final = httpx.HTTPStatusError(
+        message="422",
+        request=httpx.Request("POST", "https://example.services.ai.azure.com/models/chat/completions"),
+        response=httpx.Response(422, text=json.dumps({"error": {"message": json.dumps({"detail": detail})}})),
+    )
+    request_data: Final = {
+        "model": "Mistral-Large-3",
+        "messages": [{"role": "user", "content": "Say hi."}],
+        "reasoning_effort": "high",
+    }
+
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        retried: Final = AzureAIStudioConfig().transform_request_on_unprocessable_entity_error(error, request_data)
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+
+    assert retried == {"model": "Mistral-Large-3", "messages": [{"role": "user", "content": "Say hi."}]}
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0] for fragment in ("reasoning_effort='high'", "Mistral-Large-3", "(drop_params=True)")
+    )
+
+
 def _find_key_anywhere(obj, key: str) -> bool:
     if isinstance(obj, dict):
         if key in obj:
diff --git a/tests/unit/llms/azure_ai/claude/test_azure_anthropic_messages_transformation.py b/tests/unit/llms/azure_ai/claude/test_azure_anthropic_messages_transformation.py
index 5e0395f84dc..1c4097ad7e0 100644
--- a/tests/unit/llms/azure_ai/claude/test_azure_anthropic_messages_transformation.py
+++ b/tests/unit/llms/azure_ai/claude/test_azure_anthropic_messages_transformation.py
@@ -607,3 +607,91 @@ async def test_outgoing_azure_request_keeps_an_object_output_format_under_drop_p
     body: Final = await _azure_request_body_for_output_format(output_format, drop_params=True)
 
     assert body["output_format"] == output_format
+
+
+_SIGNED_COMPACTION_BLOCK: Final = {"type": "compaction", "content": "Summary of the chat so far.", "signature": "sig"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("local_beta_headers_config")
+@pytest.mark.parametrize(
+    ("messages", "params"),
+    [
+        ([{"role": "user", "content": "Summarize the chat so far."}], {"compaction": {"type": "summarize"}}),
+        (
+            [{"role": "assistant", "content": [_SIGNED_COMPACTION_BLOCK]}, {"role": "user", "content": "Go on"}],
+            {},
+        ),
+    ],
+    ids=["compaction_param", "signed_compaction_block"],
+)
+async def test_outgoing_azure_compaction_request_carries_the_compact_2026_09_04_beta(
+    messages: list[object], params: dict[str, object]
+) -> None:
+    """Foundry answers 400 "compaction: this parameter requires anthropic-beta: compact-2026-09-04" for the param
+    and 400 "Input tag 'compaction' ... does not match" for a replayed block without the header, and 200 with it
+    (live, claude-sonnet-5-5 on Azure AI Foundry, 2026-10-20)."""
+    received: Final[list[httpx.Request]] = []
+
+    def foundry_answers(request: httpx.Request) -> httpx.Response:
+        received.append(request)
+        return _foundry_answer(request)
+
+    upstream: Final = AsyncHTTPHandler(transport=httpx.MockTransport(foundry_answers))
+    try:
+        await litellm.anthropic.messages.acreate(
+            max_tokens=256,
+            messages=messages,
+            model="azure_ai/claude-sonnet-5-5",
+            api_key="test-api-key",
+            api_base="https://test-resource.services.ai.azure.com",
+            client=upstream,
+            **params,
+        )
+    finally:
+        await upstream.close()
+
+    assert len(received) == 1, received
+    assert received[0].headers["anthropic-beta"].split(",").count("compact-2026-09-04") == 1, dict(received[0].headers)
+
+
+@pytest.mark.usefixtures("local_model_cost_map")
+@pytest.mark.parametrize("feature", ("thinking", "output_config", "tool_addition", "tool_removal", "none"))
+@pytest.mark.parametrize("explicit_beta", (False, True))
+def test_messages_feature_beta_headers(feature: str, explicit_beta: bool) -> None:
+    from typing import Final
+
+    from litellm.llms.azure_ai.anthropic.messages_transformation import AzureAnthropicMessagesConfig
+    from litellm.types.llms.anthropic import (
+        ANTHROPIC_BETA_HEADER_VALUES,
+        ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER,
+        ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER,
+    )
+
+    beta: Final = (
+        ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+        if feature == "thinking"
+        else ANTHROPIC_BETA_HEADER_VALUES.PER_TURN_CONTROL_2026_07_01.value
+        if feature == "output_config"
+        else ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER
+    )
+    message: Final = (
+        {"role": "system", "content": [], "output_config": {"effort": "high"}}
+        if feature == "output_config"
+        else {"role": "system", "content": [{"type": feature, "tool": {"type": "tool_reference", "name": "ping"}}]}
+        if feature in ("tool_addition", "tool_removal")
+        else {"role": "user", "content": "Reply with OK"}
+    )
+    headers, _ = AzureAnthropicMessagesConfig().validate_anthropic_messages_environment(
+        headers={"anthropic-beta": f"existing-beta,{beta}" if explicit_beta else "existing-beta"},
+        model="claude-fable-5-1",
+        messages=[{"role": "user", "content": "Hello"}, message],
+        optional_params={"thinking": {"type": "adaptive", "display": "updates"}} if feature == "thinking" else {},
+        litellm_params={"vertex_ai_project": "test-project", "vertex_ai_location": "us-east5"},
+        api_key="test-key",
+        api_base="https://example.com/anthropic",
+    )
+
+    betas: Final = headers["anthropic-beta"].split(",")
+    assert betas.count(beta) == int(feature != "none" or explicit_beta)
+    assert betas.count("existing-beta") == 1
diff --git a/tests/unit/llms/azure_ai/claude/test_azure_anthropic_transformation.py b/tests/unit/llms/azure_ai/claude/test_azure_anthropic_transformation.py
index 1179b0dd5da..6ff2a6973a3 100644
--- a/tests/unit/llms/azure_ai/claude/test_azure_anthropic_transformation.py
+++ b/tests/unit/llms/azure_ai/claude/test_azure_anthropic_transformation.py
@@ -5,10 +5,12 @@ sys.path.insert(
     0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../../.."))
 )
 
+from typing import Final
 from unittest.mock import MagicMock, patch
 
 import pytest
 
+from litellm.anthropic_beta_headers_manager import update_headers_with_filtered_beta
 from litellm.llms.azure_ai.anthropic.transformation import AzureAnthropicConfig
 from litellm.types.router import GenericLiteLLMParams
 
@@ -484,3 +486,85 @@ def test_chat_flagged_model_keeps_mid_conversation_system_role_in_place(local_mo
         "role": "system",
         "content": [{"type": "text", "text": "<system-reminder>Answer with exactly one word.</system-reminder>"}],
     }
+
+
+@pytest.mark.parametrize(
+    ("optional_params", "messages", "expected"),
+    [
+        ({"compaction": {"type": "summarize"}}, [{"role": "user", "content": "Hello"}], True),
+        (
+            {},
+            [
+                {"role": "assistant", "content": [{"type": "compaction", "content": "Summary.", "signature": "sig"}]},
+                {"role": "user", "content": "Go on"},
+            ],
+            True,
+        ),
+        ({}, [{"role": "user", "content": "Hello"}], False),
+    ],
+    ids=["compaction_param", "signed_compaction_block", "no_compaction"],
+)
+def test_azure_chat_compaction_sends_the_compact_2026_09_04_beta(
+    local_beta_headers_config: None, optional_params: dict[str, object], messages: list[object], expected: bool
+) -> None:
+    headers: Final = AzureAnthropicConfig().update_headers_with_optional_anthropic_beta(
+        headers={}, optional_params=optional_params, messages=messages
+    )
+
+    filtered: Final = update_headers_with_filtered_beta(headers=headers, provider="azure_ai")
+
+    assert ("compact-2026-09-04" in filtered.get("anthropic-beta", "").split(",")) is expected
+
+
+@pytest.mark.usefixtures("local_model_cost_map")
+@pytest.mark.parametrize("thinking_type", ("adaptive", "enabled"))
+@pytest.mark.parametrize("display", ("summarized", "omitted", "updates"))
+def test_chat_preserves_thinking_display_and_beta(thinking_type: str, display: str) -> None:
+    from typing import Final
+
+    from litellm.llms.azure_ai.anthropic.transformation import AzureAnthropicConfig
+    from litellm.types.llms.anthropic import ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+
+    config: Final = AzureAnthropicConfig()
+    optional_params: Final = config.map_openai_params(
+        non_default_params={"thinking": {"type": thinking_type, "display": display, "budget_tokens": 2048}},
+        optional_params={},
+        model="claude-fable-5-1",
+        drop_params=False,
+    )
+    headers: Final = config.validate_environment(
+        headers={"anthropic-beta": "existing-beta"},
+        model="claude-fable-5-1",
+        messages=[{"role": "user", "content": "Reply with OK"}],
+        optional_params=optional_params,
+        litellm_params={},
+        api_key="test-key",
+    )
+    result: Final = config.transform_request(
+        model="claude-fable-5-1",
+        messages=[{"role": "user", "content": "Reply with OK"}],
+        optional_params=optional_params,
+        litellm_params={},
+        headers=headers,
+    )
+
+    assert result["thinking"]["type"] == "adaptive"
+    assert result["thinking"]["display"] == display
+    assert (ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER in headers["anthropic-beta"].split(",")) == (display == "updates")
+    assert "existing-beta" in headers["anthropic-beta"].split(",")
+
+
+@pytest.mark.parametrize("thinking", ("enabled", {"type": "bogus"}, {"type": "adaptive", "display": "future-mode"}))
+def test_beta_detection_preserves_unrecognized_thinking(thinking: object) -> None:
+    from typing import Final
+
+    from litellm.types.llms.anthropic import ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+
+    params: Final = {"thinking": thinking}
+    headers: Final = AzureAnthropicConfig().validate_environment(
+        headers={}, model="claude-fable-5-1", messages=[], optional_params=params,
+        litellm_params={}, api_key="test-key",
+    )
+
+    assert params["thinking"] == thinking
+    assert ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER not in headers.get("anthropic-beta", "").split(",")
diff --git a/tests/unit/llms/baseten/chat/test_baseten_completions.py b/tests/unit/llms/baseten/chat/test_baseten_completions.py
index 4f135a1a106..407b39319e9 100644
--- a/tests/unit/llms/baseten/chat/test_baseten_completions.py
+++ b/tests/unit/llms/baseten/chat/test_baseten_completions.py
@@ -7,8 +7,9 @@ import pytest
 import respx
 
 import litellm
+from litellm.litellm_core_utils.model_retirement import is_past_deprecation_date
 from litellm.llms.baseten.chat import BasetenConfig
-from litellm.utils import get_valid_models
+from litellm.utils import _model_cache, get_valid_models
 
 
 class TestBasetenRouting:
@@ -65,7 +66,7 @@ class TestBasetenModelDiscovery:
         servable_registry_models: Final = {
             key
             for key, value in litellm.model_cost.items()
-            if value.get("litellm_provider") == "baseten" and not litellm._is_past_deprecation_date(value)
+            if value.get("litellm_provider") == "baseten" and not is_past_deprecation_date(value)
         }
 
         assert servable_registry_models
@@ -92,6 +93,20 @@ class TestBasetenModelDiscovery:
             litellm.baseten_models.discard(model)
             litellm.add_known_models({})
 
+    def test_wildcard_drops_a_model_whose_retirement_date_passes_while_running(self, monkeypatch: pytest.MonkeyPatch):
+        model: Final = "baseten/acme/retires-while-running"
+        monkeypatch.setitem(litellm.model_cost, model, {"litellm_provider": "baseten", "deprecation_date": "2999-01-01"})
+        try:
+            litellm.add_known_models({model: litellm.model_cost[model]})
+            assert model in get_valid_models(custom_llm_provider="baseten")
+
+            monkeypatch.setitem(litellm.model_cost, model, {"litellm_provider": "baseten", "deprecation_date": "2000-01-01"})
+
+            assert model not in get_valid_models(custom_llm_provider="baseten")
+        finally:
+            litellm.baseten_models.discard(model)
+            litellm.add_known_models({})
+
     @pytest.mark.parametrize(
         "value, expected",
         [
@@ -102,7 +117,7 @@ class TestBasetenModelDiscovery:
         ],
     )
     def test_is_past_deprecation_date(self, value, expected):
-        assert litellm._is_past_deprecation_date(value) is expected
+        assert is_past_deprecation_date(value) is expected
 
     def test_get_models_calls_model_api(self, respx_mock: respx.MockRouter) -> None:
         route: Final = respx_mock.get("https://inference.baseten.co/v1/models").mock(
@@ -156,6 +171,18 @@ class TestBasetenModelDiscovery:
 
         assert models == ["baseten/brand-new/model"]
 
+    @patch.dict(os.environ, {"BASETEN_API_KEY": "test-key"})
+    def test_live_catalog_keeps_a_model_the_cost_map_dates_as_retired(self, respx_mock: respx.MockRouter) -> None:
+        assert is_past_deprecation_date(litellm.model_cost["baseten/zai-org/GLM-5"])
+        _model_cache.flush_cache()
+        respx_mock.get("https://inference.baseten.co/v1/models").mock(
+            return_value=httpx.Response(200, json={"data": [{"id": "zai-org/GLM-5"}]})
+        )
+
+        models: Final = get_valid_models(check_provider_endpoint=True, custom_llm_provider="baseten")
+
+        assert models == ["baseten/zai-org/GLM-5"]
+
 
 class TestBasetenReasoningEffort:
     def test_reasoning_effort_passthrough_with_drop_params(self):
diff --git a/tests/unit/llms/bedrock/chat/chat_completions/test_bedrock_chat_completions_transformation.py b/tests/unit/llms/bedrock/chat/chat_completions/test_bedrock_chat_completions_transformation.py
index 3faae2e3289..f4dcff1969e 100644
--- a/tests/unit/llms/bedrock/chat/chat_completions/test_bedrock_chat_completions_transformation.py
+++ b/tests/unit/llms/bedrock/chat/chat_completions/test_bedrock_chat_completions_transformation.py
@@ -1,6 +1,7 @@
 """Bedrock Runtime Chat Completions: the default for GPT 5.6 and newer, ``bedrock/chat_completions/<model>`` for the rest."""
 
 import json
+import logging
 import re
 
 import httpx
@@ -706,18 +707,30 @@ def test_with_max_completion_tokens_leaves_other_params_alone():
 
 
 @pytest.mark.parametrize(
-    "model",
-    ["us.xai.grok-4.6", "bedrock/us-gov-west-1/us.xai.grok-4.6"],
+    ("model", "logged_model"),
+    [
+        ("us.xai.grok-4.6", "us.xai.grok-4.6"),
+        ("chat_completions/us.xai.grok-4.6", "us.xai.grok-4.6"),
+        ("bedrock/us-gov-west-1/us.xai.grok-4.6", "us-gov-west-1/us.xai.grok-4.6"),
+    ],
 )
-def test_map_openai_params_drops_reasoning_effort_none_for_grok(model):
+def test_map_openai_params_drops_reasoning_effort_none_for_grok_with_one_warning(
+    model: str, logged_model: str, caplog: pytest.LogCaptureFixture
+) -> None:
     cfg = AmazonBedrockRuntimeChatCompletionsConfig()
-    mapped = cfg.map_openai_params(
-        non_default_params={"reasoning_effort": "none", "max_tokens": 64},
-        optional_params={},
-        model=model,
-        drop_params=False,
-    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        mapped = cfg.map_openai_params(
+            non_default_params={"reasoning_effort": "none", "max_tokens": 64},
+            optional_params={},
+            model=model,
+            drop_params=False,
+        )
+    drop_warnings = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
     assert "reasoning_effort" not in mapped
+    assert len(drop_warnings) == 1
+    assert "reasoning_effort='none'" in drop_warnings[0]
+    assert f"model={logged_model!r}" in drop_warnings[0]
+    assert "drop_params" not in drop_warnings[0]
 
 
 def test_map_openai_params_keeps_reasoning_effort_low_for_grok():
@@ -750,17 +763,24 @@ def test_map_openai_params_refuses_a_non_string_reasoning_effort_without_drop_pa
 @pytest.mark.parametrize("reasoning_effort", [["low"], {"effort": "low"}, 5], ids=["list", "object", "int"])
 @pytest.mark.parametrize("drop_params_via", ["request", "litellm.drop_params"])
 def test_map_openai_params_drops_a_non_string_reasoning_effort_under_drop_params(
-    monkeypatch, model, reasoning_effort, drop_params_via
+    monkeypatch, caplog, model, reasoning_effort, drop_params_via
 ):
     monkeypatch.setattr(litellm, "drop_params", drop_params_via == "litellm.drop_params")
-    mapped = AmazonBedrockRuntimeChatCompletionsConfig().map_openai_params(
-        non_default_params={"reasoning_effort": reasoning_effort, "max_tokens": 64},
-        optional_params={},
-        model=model,
-        drop_params=drop_params_via == "request",
-    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        mapped = AmazonBedrockRuntimeChatCompletionsConfig().map_openai_params(
+            non_default_params={"reasoning_effort": reasoning_effort, "max_tokens": 64},
+            optional_params={},
+            model=model,
+            drop_params=drop_params_via == "request",
+        )
+    drop_warnings = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
     assert "reasoning_effort" not in mapped
     assert mapped["max_completion_tokens"] == 64
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0]
+        for fragment in (f"reasoning_effort={reasoning_effort!r}", repr(model), "(drop_params=True)")
+    )
 
 
 def test_map_openai_params_keeps_reasoning_effort_none_for_gpt56():
diff --git a/tests/unit/llms/bedrock/chat/test_converse_transformation.py b/tests/unit/llms/bedrock/chat/test_converse_transformation.py
index d82ba192b1f..524caaba7a1 100644
--- a/tests/unit/llms/bedrock/chat/test_converse_transformation.py
+++ b/tests/unit/llms/bedrock/chat/test_converse_transformation.py
@@ -13,6 +13,7 @@ import pytest
 import respx
 
 import litellm
+from litellm._logging import verbose_logger
 from litellm import ModelResponse, Router, completion
 from litellm.litellm_core_utils.prompt_templates.factory import (
     _bedrock_converse_messages_pt,
@@ -1221,6 +1222,97 @@ def test_transform_request_drops_lookaround_regex_when_the_deployment_model_info
     assert properties == _LOOKAROUND_FREE_PROPERTIES
 
 
+@pytest.mark.parametrize(
+    ("model", "litellm_params"),
+    [
+        ("us.newvendor.model-1", None),
+        ("converse/us.newvendor.model-1", None),
+        ("us-east-1/us.newvendor.model-1", None),
+        ("us.newvendor.model-1", {"base_model": "bedrock/converse/us.newvendor.model-1"}),
+    ],
+)
+def test_transform_request_drops_lookaround_regex_for_a_model_the_cost_map_does_not_list(model, litellm_params):
+    assert "us.newvendor.model-1" not in litellm.model_cost
+
+    properties: Final = _tool_schema_properties(model, _ARTIFACT_DATA_ANTHROPIC_TOOL, litellm_params)
+
+    assert properties == _LOOKAROUND_FREE_PROPERTIES
+
+
+@pytest.mark.parametrize(
+    "model",
+    [
+        "arn:aws:bedrock:us-east-1:123456789012:custom-model-deployment/abc123",
+        "arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/abc123",
+        "us.anthropic.claude-unreleased-v1:0",
+        "eu.openai.gpt-unreleased",
+        "apac.newvendor.listed-1",
+    ],
+)
+def test_transform_request_keeps_lookaround_regex_for_an_unlisted_model_litellm_still_recognizes(model, monkeypatch):
+    monkeypatch.setitem(litellm.model_cost, "us.newvendor.listed-1", {"litellm_provider": "bedrock_converse"})
+
+    properties = _tool_schema_properties(model, _ARTIFACT_DATA_ANTHROPIC_TOOL)
+
+    assert properties == _ARTIFACT_DATA_INPUT_SCHEMA["properties"]
+
+
+def test_transform_request_keeps_lookaround_regex_for_an_unlisted_model_whose_deployment_opts_out():
+    properties = _tool_schema_properties(
+        "us.newvendor.model-1", _ARTIFACT_DATA_ANTHROPIC_TOOL, {"model_info": {"supports_regex_lookaround": True}}
+    )
+
+    assert properties == _ARTIFACT_DATA_INPUT_SCHEMA["properties"]
+
+
+@pytest.mark.parametrize(
+    "deployment_params",
+    [
+        {"model": "bedrock/us.newvendor.model-1"},
+        {"model": "bedrock/converse/us.newvendor.model-1", "allowed_openai_params": ["tools"]},
+    ],
+)
+def test_a_router_deployment_of_a_model_the_cost_map_does_not_list_drops_lookaround_regex(
+    respx_mock, deployment_params
+):
+    route: Final = respx_mock.post(
+        "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.newvendor.model-1/converse"
+    ).mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "output": {"message": {"role": "assistant", "content": [{"text": "ok"}]}},
+                "stopReason": "end_turn",
+                "usage": {"inputTokens": 1, "outputTokens": 1, "totalTokens": 2},
+            },
+        )
+    )
+    router: Final = Router(
+        model_list=[
+            {
+                "model_name": "unlisted",
+                "litellm_params": {
+                    **deployment_params,
+                    "aws_access_key_id": "fake-access-key",
+                    "aws_secret_access_key": "fake-secret-key",
+                    "aws_region_name": "us-east-1",
+                },
+                "model_info": {"input_cost_per_token": 1e-6, "output_cost_per_token": 2e-6},
+            }
+        ]
+    )
+
+    router.completion(
+        model="unlisted",
+        messages=[{"role": "user", "content": "hi"}],
+        tools=[_ARTIFACT_DATA_OPENAI_TOOL],
+        client=HTTPHandler(),
+    )
+
+    tool: Final = json.loads(route.calls[0].request.content)["toolConfig"]["tools"][0]
+    assert tool["toolSpec"]["inputSchema"]["json"]["properties"] == _LOOKAROUND_FREE_PROPERTIES
+
+
 def test_transform_request_keeps_lookaround_regex_when_the_deployment_model_info_opts_out():
     properties = _tool_schema_properties(
         "global.moonshotai.kimi-k3", _ARTIFACT_DATA_ANTHROPIC_TOOL, {"model_info": {"supports_regex_lookaround": True}}
@@ -9189,18 +9281,223 @@ def test_bedrock_tools_transformation_valid_params():
     assert "test" in result[0]["toolSpec"]["inputSchema"]["json"]["required"]
 
 
-def test_not_found_error():
+def _invalid_model_identifier_reply(sent: list[httpx.Request]):
+    def respond(request: httpx.Request) -> httpx.Response:
+        sent.append(request)
+        return httpx.Response(
+            400,
+            json={"message": "The provided model identifier is invalid."},
+            headers={"x-amzn-ErrorType": "ValidationException", "x-amzn-RequestId": "req-123"},
+        )
+
+    return respond
+
+
+@pytest.mark.parametrize(
+    "model, path",
+    [
+        ("bedrock/bad_model", b"/model/bad_model/converse"),
+        ("bedrock/us-east-1/bad_model", b"/model/bad_model/converse"),
+        ("bedrock/newvendor.listed-v1:0", b"/model/newvendor.listed-v1%3A0/converse"),
+        ("bedrock/us-east-1/newvendor.listed-v1:0", b"/model/newvendor.listed-v1%3A0/converse"),
+    ],
+)
+def test_not_found_error(model, path, monkeypatch):
+    monkeypatch.setitem(litellm.model_cost, "newvendor.listed-v1:0", {"litellm_provider": "bedrock", "mode": "chat"})
+    sent: Final[list[httpx.Request]] = []
+
+    with pytest.raises(litellm.NotFoundError) as exc_info:
+        completion(
+            model=model,
+            messages=[{"role": "user", "content": "What is the meaning of life"}],
+            client=HTTPHandler(
+                client=httpx.Client(transport=httpx.MockTransport(_invalid_model_identifier_reply(sent)))
+            ),
+            aws_access_key_id="testing",
+            aws_secret_access_key="testing",
+            aws_region_name="us-west-2",
+        )
+
+    assert exc_info.value.status_code == 404
+    assert exc_info.value.response.status_code == 404
+    assert exc_info.value.response.headers["x-amzn-requestid"] == "req-123"
+    assert [request.url.raw_path for request in sent] == [path]
+
+
+@pytest.mark.parametrize(
+    "model", ["bedrock/", "bedrock/us-east-1/", "bedrock/../../converse", "bedrock/xx-fake-1/us.xai.grok-4.7"]
+)
+def test_a_model_id_that_is_empty_or_a_path_fails_locally_without_calling_aws(model):
+    sent: Final[list[httpx.Request]] = []
+
     with pytest.raises(litellm.NotFoundError):
         completion(
-            model="bedrock/bad_model",
-            messages=[
-                {
-                    "role": "user",
-                    "content": "What is the meaning of life",
-                }
-            ],
+            model=model,
+            messages=[{"role": "user", "content": "What is the meaning of life"}],
+            client=HTTPHandler(
+                client=httpx.Client(transport=httpx.MockTransport(_invalid_model_identifier_reply(sent)))
+            ),
+            aws_access_key_id="testing",
+            aws_secret_access_key="testing",
+            aws_region_name="us-west-2",
         )
 
+    assert sent == []
+
+
+@pytest.mark.parametrize(
+    "model, path",
+    [
+        ("bedrock/converse/bad_model", b"/model/bad_model/converse"),
+        ("bedrock/anthropic.claude-typo-v1:0", b"/model/anthropic.claude-typo-v1:0/invoke"),
+    ],
+)
+def test_invalid_model_identifier_stays_a_bad_request_for_a_model_litellm_recognizes(model, path):
+    sent: Final[list[httpx.Request]] = []
+
+    with pytest.raises(litellm.BadRequestError) as exc_info:
+        completion(
+            model=model,
+            messages=[{"role": "user", "content": "What is the meaning of life"}],
+            client=HTTPHandler(
+                client=httpx.Client(transport=httpx.MockTransport(_invalid_model_identifier_reply(sent)))
+            ),
+            aws_access_key_id="testing",
+            aws_secret_access_key="testing",
+            aws_region_name="us-west-2",
+        )
+
+    assert exc_info.value.status_code == 400
+    assert [request.url.raw_path for request in sent] == [path]
+
+
+_WEATHER_TOOL: Final = {
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Get the weather for a city",
+        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+    },
+}
+
+
+def _converse_tool_call_reply(sent: list[httpx.Request]):
+    def respond(request: httpx.Request) -> httpx.Response:
+        sent.append(request)
+        return httpx.Response(
+            200,
+            json={
+                "output": {
+                    "message": {
+                        "role": "assistant",
+                        "content": [
+                            {"toolUse": {"toolUseId": "t1", "name": "get_weather", "input": {"city": "Paris"}}}
+                        ],
+                    }
+                },
+                "stopReason": "tool_use",
+                "usage": {"inputTokens": 1, "outputTokens": 1, "totalTokens": 2},
+            },
+        )
+
+    return respond
+
+
+@pytest.mark.parametrize("model", ["bedrock/us.newvendor.model-1", "bedrock/us-east-1/us.newvendor.model-1"])
+def test_model_missing_from_cost_map_sends_tools_to_converse(model):
+    assert "us.newvendor.model-1" not in litellm.model_cost
+    sent: Final[list[httpx.Request]] = []
+
+    response: Final = completion(
+        model=model,
+        messages=[{"role": "user", "content": "What is the weather in Paris?"}],
+        tools=[_WEATHER_TOOL],
+        tool_choice="auto",
+        client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(_converse_tool_call_reply(sent)))),
+        aws_access_key_id="testing",
+        aws_secret_access_key="testing",
+        aws_region_name="us-west-2",
+    )
+
+    assert response.choices[0].message.tool_calls[0].function.name == "get_weather"
+    assert [request.url.raw_path for request in sent] == [b"/model/us.newvendor.model-1/converse"]
+    tool_config: Final = json.loads(sent[0].content)["toolConfig"]
+    assert [tool["toolSpec"]["name"] for tool in tool_config["tools"]] == ["get_weather"]
+    assert tool_config["toolChoice"] == {"auto": {}}
+
+
+def test_a_price_only_row_for_an_unlisted_model_still_sends_tools_to_converse(monkeypatch):
+    monkeypatch.setitem(
+        litellm.model_cost, "us.newvendor.priced-1", {"input_cost_per_token": 1e-6, "output_cost_per_token": 2e-6}
+    )
+    sent: Final[list[httpx.Request]] = []
+
+    completion(
+        model="bedrock/us.newvendor.priced-1",
+        messages=[{"role": "user", "content": "What is the weather in Paris?"}],
+        tools=[_WEATHER_TOOL],
+        client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(_converse_tool_call_reply(sent)))),
+        aws_access_key_id="testing",
+        aws_secret_access_key="testing",
+        aws_region_name="us-west-2",
+    )
+
+    tool_config: Final = json.loads(sent[0].content)["toolConfig"]
+    assert [tool["toolSpec"]["name"] for tool in tool_config["tools"]] == ["get_weather"]
+
+
+def test_explicit_converse_route_to_an_unlisted_model_still_drops_tools_under_drop_params():
+    sent: Final[list[httpx.Request]] = []
+
+    completion(
+        model="bedrock/converse/us.newvendor.model-1",
+        messages=[{"role": "user", "content": "What is the weather in Paris?"}],
+        tools=[_WEATHER_TOOL],
+        drop_params=True,
+        client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(_converse_tool_call_reply(sent)))),
+        aws_access_key_id="testing",
+        aws_secret_access_key="testing",
+        aws_region_name="us-west-2",
+    )
+
+    assert "toolConfig" not in json.loads(sent[0].content)
+
+
+def test_unknown_model_gets_reasoning_effort_as_sent():
+    sent: Final[list[httpx.Request]] = []
+
+    completion(
+        model="bedrock/us.newvendor.model-1",
+        messages=[{"role": "user", "content": "What is the weather in Paris?"}],
+        reasoning_effort="high",
+        client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(_converse_tool_call_reply(sent)))),
+        aws_access_key_id="testing",
+        aws_secret_access_key="testing",
+        aws_region_name="us-west-2",
+    )
+
+    assert json.loads(sent[0].content)["additionalModelRequestFields"] == {"reasoning_effort": "high"}
+
+
+def test_mapped_model_without_function_calling_still_rejects_tools():
+    model: Final = "bedrock/converse/meta.llama3-8b-instruct-v1:0"
+    assert "meta.llama3-8b-instruct-v1:0" in litellm.model_cost
+    assert not litellm.supports_function_calling(model=model)
+    sent: Final[list[httpx.Request]] = []
+
+    with pytest.raises(litellm.UnsupportedParamsError):
+        completion(
+            model=model,
+            messages=[{"role": "user", "content": "What is the weather in Paris?"}],
+            tools=[_WEATHER_TOOL],
+            client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(_converse_tool_call_reply(sent)))),
+            aws_access_key_id="testing",
+            aws_secret_access_key="testing",
+            aws_region_name="us-west-2",
+        )
+
+    assert sent == []
+
 
 @pytest.mark.parametrize(
     "model, expected_base_model",
@@ -10800,6 +11097,52 @@ def test_a_deployment_with_a_batch_control_plane_endpoint_keeps_it_out_of_chat_r
     assert "aws_bedrock_control_plane_endpoint" not in route.calls[0].request.content.decode()
 
 
+def _warnings_naming(caplog: pytest.LogCaptureFixture, param: str) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage() for r in caplog.records if r.levelno == logging.WARNING and f"Dropping {param}=" in r.getMessage()
+    )
+
+
+_DEEPSEEK_R1_PROFILE_ARN: Final = "arn:aws:bedrock:us-east-1:123456789012:inference-profile/us.deepseek.r1-v1:0"
+
+
+@pytest.mark.parametrize(
+    "param, value", (("thinking", {"type": "enabled", "budget_tokens": 1024}), ("reasoning_effort", "high"))
+)
+def test_bedrock_deepseek_arn_reasoning_drop_warns_once(
+    param: str, value: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        optional_params: Final = AmazonConverseConfig().map_openai_params(
+            non_default_params={param: value, "max_tokens": 100},
+            optional_params={},
+            model=_DEEPSEEK_R1_PROFILE_ARN,
+            drop_params=False,
+        )
+
+    warnings: Final = _warnings_naming(caplog, param)
+    assert param not in optional_params
+    assert len(warnings) == 1
+    assert _DEEPSEEK_R1_PROFILE_ARN in warnings[0]
+
+
+@pytest.mark.parametrize(
+    "param, value", (("thinking", {"type": "enabled", "budget_tokens": 1024}), ("reasoning_effort", "high"))
+)
+def test_bedrock_deepseek_r1_drop_of_an_unadvertised_param_does_not_warn(
+    param: str, value: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        AmazonConverseConfig().map_openai_params(
+            non_default_params={param: value, "max_tokens": 100},
+            optional_params={},
+            model="us.deepseek.r1-v1:0",
+            drop_params=False,
+        )
+
+    assert _warnings_naming(caplog, param) == ()
+
+
 def _converse_bound_thinking_request(
     headers: dict[str, str] | None, body_betas: tuple[str, ...] = (), drop_params: bool = True
 ) -> dict[str, object]:
diff --git a/tests/unit/llms/bedrock/test_bedrock_common_utils.py b/tests/unit/llms/bedrock/test_bedrock_common_utils.py
index dd89d9c46b6..20c0e10cb81 100644
--- a/tests/unit/llms/bedrock/test_bedrock_common_utils.py
+++ b/tests/unit/llms/bedrock/test_bedrock_common_utils.py
@@ -214,24 +214,17 @@ def test_system_defined_inference_profile_arn_still_routes_to_converse():
     assert route == "converse"
 
 
-def test_other_opaque_arn_types_still_route_to_invoke():
-    """
-    Only application-inference-profile ARNs are auto-routed to converse. Other
-    opaque ARNs (provisioned-model, imported-model, custom-model-deployment)
-    also yield no invoke provider, but they are frequently invoke-only with
-    provider-specific body formats, so routing them to converse could break
-    them. Guards the deliberate scope against an over-broad "any opaque ARN ->
-    converse" generalization.
-    """
-    for arn_segment in (
-        "provisioned-model/abcdefgh1234",
-        "imported-model/abcdefgh1234",
-        "custom-model-deployment/abcdefgh1234",
-    ):
-        route = BedrockModelInfo.get_bedrock_route(
-            model=f"bedrock/arn:aws:bedrock:us-east-1:123412341234:{arn_segment}"
-        )
-        assert route == "invoke", f"{arn_segment} should stay on invoke route"
+@pytest.mark.parametrize(
+    "arn_segment",
+    ["provisioned-model/abcdefgh1234", "imported-model/abcdefgh1234", "custom-model-deployment/abcdefgh1234"],
+)
+def test_bare_opaque_arn_with_no_invoke_provider_routes_to_converse(arn_segment: str):
+    from litellm.llms.bedrock.base_aws_llm import BaseAWSLLM
+
+    model: Final = f"bedrock/arn:aws:bedrock:us-east-1:123412341234:{arn_segment}"
+    assert BaseAWSLLM.get_bedrock_invoke_provider(model) is None
+    assert BedrockModelInfo.get_bedrock_route(model) == "converse"
+    assert BedrockModelInfo.get_bedrock_route(f"bedrock/llama/arn:aws:bedrock:us-east-1:123412341234:{arn_segment}") == "invoke"
 
 
 def test_govcloud_cross_region_inference_prefix():
@@ -1098,6 +1091,84 @@ def test_unmapped_openai_family_model_routes_to_converse():
     assert BedrockModelInfo.get_bedrock_route(imported) == "openai"
 
 
+@pytest.mark.parametrize(
+    "unmapped",
+    [
+        "bedrock/minimax.minimax-m99-unmapped",
+        "bedrock/us.nvidia.nemotron-99b-unmapped",
+        "bedrock/writer.palmyra-x99-unmapped",
+        "bedrock/zai.glm-99-unmapped",
+        "bedrock/google.gemma-99-unmapped",
+        "bedrock/global.xai.grok-99-unmapped",
+    ],
+)
+def test_unmapped_converse_only_family_model_routes_to_converse(unmapped: str):
+    import litellm
+
+    assert BedrockModelInfo.get_base_model(unmapped) not in litellm.bedrock_converse_models
+    assert BedrockModelInfo.get_bedrock_route(unmapped) == "converse"
+
+
+def test_unmapped_model_of_family_with_invoke_handler_still_routes_to_invoke():
+    from typing import Final
+
+    import litellm
+
+    unmapped: Final = "bedrock/meta.llama99-unmapped-v1:0"
+    assert BedrockModelInfo.get_base_model(unmapped) not in litellm.bedrock_converse_models
+    assert BedrockModelInfo.get_bedrock_route(unmapped) == "invoke"
+
+
+@pytest.mark.parametrize(
+    ("model", "model_path", "response_json"),
+    [
+        (
+            "bedrock/us.newvendor.model-1",
+            b"/model/us.newvendor.model-1/converse",
+            {
+                "output": {"message": {"role": "assistant", "content": [{"text": "ok"}]}},
+                "stopReason": "end_turn",
+                "usage": {"inputTokens": 1, "outputTokens": 1, "totalTokens": 2},
+            },
+        ),
+        (
+            "bedrock/mistral.mistral-99-unmapped-v1:0",
+            b"/model/mistral.mistral-99-unmapped-v1:0/invoke",
+            {"outputs": [{"text": "ok", "stop_reason": "stop"}]},
+        ),
+    ],
+)
+def test_completion_on_unmapped_model_posts_converse_unless_its_id_names_an_invoke_provider(
+    model: str, model_path: bytes, response_json: dict[str, object]
+):
+    import httpx
+
+    from litellm.llms.custom_httpx.http_handler import HTTPHandler
+
+    assert BedrockModelInfo.get_base_model(model) not in litellm.bedrock_converse_models
+    sent: Final[list[httpx.Request]] = []
+
+    def respond(request: httpx.Request) -> httpx.Response:
+        sent.append(request)
+        return httpx.Response(
+            200,
+            json=response_json,
+            headers={"x-amzn-bedrock-input-token-count": "1", "x-amzn-bedrock-output-token-count": "1"},
+        )
+
+    response: Final = litellm.completion(
+        model=model,
+        messages=[{"role": "user", "content": "hello"}],
+        client=HTTPHandler(client=httpx.Client(transport=httpx.MockTransport(respond))),
+        aws_access_key_id="testing",
+        aws_secret_access_key="testing",
+        aws_region_name="us-west-2",
+    )
+
+    assert response.choices[0].message.content == "ok"
+    assert [request.url.raw_path for request in sent] == [model_path]
+
+
 @pytest.mark.parametrize(
     ("model", "expected"),
     [
diff --git a/tests/unit/llms/bedrock/test_nova_imported_models.py b/tests/unit/llms/bedrock/test_nova_imported_models.py
index e3677aaf9e6..231f3097dcd 100644
--- a/tests/unit/llms/bedrock/test_nova_imported_models.py
+++ b/tests/unit/llms/bedrock/test_nova_imported_models.py
@@ -24,10 +24,8 @@ class TestGetBedrockRoute:
     def test_nova2_prefix_routes_to_converse(self):
         assert BedrockModelInfo.get_bedrock_route(NOVA2_MODEL) == "converse"
 
-    def test_plain_arn_routes_to_invoke(self):
-        # Without spec prefix, ARN doesn't match converse models
-        result = BedrockModelInfo.get_bedrock_route(f"bedrock/{NOVA_ARN}")
-        assert result == "invoke"
+    def test_plain_arn_without_an_invoke_provider_routes_to_converse(self):
+        assert BedrockModelInfo.get_bedrock_route(f"bedrock/{NOVA_ARN}") == "converse"
 
 
 class TestGetBedrockBaseModel:
diff --git a/tests/unit/llms/deepseek/chat/test_deepseek_chat_transformation.py b/tests/unit/llms/deepseek/chat/test_deepseek_chat_transformation.py
index 3fbb12881da..56af47aeebe 100644
--- a/tests/unit/llms/deepseek/chat/test_deepseek_chat_transformation.py
+++ b/tests/unit/llms/deepseek/chat/test_deepseek_chat_transformation.py
@@ -1,4 +1,5 @@
 import json
+import logging
 from collections.abc import Iterator
 from typing import Final
 
@@ -6,6 +7,7 @@ import httpx
 import litellm
 import pytest
 import respx
+from litellm._logging import verbose_logger
 from litellm.caching.llm_caching_handler import LLMClientCache
 from litellm.llms.deepseek.chat.transformation import DeepSeekChatConfig
 
@@ -951,3 +953,42 @@ def test_get_complete_url_ignores_a_trailing_slash_on_api_base(api_base: str):
         )
         == "https://gateway.example.com/deepseek/chat/completions"
     )
+
+
+def _budget_warnings(caplog: pytest.LogCaptureFixture) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage()
+        for r in caplog.records
+        if r.levelno == logging.WARNING and "Dropping thinking.budget_tokens=" in r.getMessage()
+    )
+
+
+def test_enabled_thinking_budget_dropped_for_deepseek_warns_once(caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = DeepSeekChatConfig().map_openai_params(
+            non_default_params={"thinking": {"type": "enabled", "budget_tokens": 4000}},
+            optional_params={},
+            model="deepseek-reasoner",
+            drop_params=False,
+        )
+
+    warnings: Final = _budget_warnings(caplog)
+    assert result["thinking"] == {"type": "enabled"}
+    assert len(warnings) == 1
+    assert "budget_tokens=4000" in warnings[0]
+    assert "deepseek-reasoner" in warnings[0]
+
+
+@pytest.mark.parametrize(
+    "thinking", ({"type": "enabled"}, {"type": "disabled", "budget_tokens": 4000}), ids=("no-budget", "disabled")
+)
+def test_deepseek_thinking_without_a_requested_budget_does_not_warn(
+    thinking: dict[str, object], caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = DeepSeekChatConfig().map_openai_params(
+            non_default_params={"thinking": thinking}, optional_params={}, model="deepseek-reasoner", drop_params=False
+        )
+
+    assert result["thinking"] == {"type": thinking["type"]}
+    assert _budget_warnings(caplog) == ()
diff --git a/tests/unit/llms/fal_ai/chat/test_fal_ai_chat_transformation.py b/tests/unit/llms/fal_ai/chat/test_fal_ai_chat_transformation.py
index b7a79f03f8d..f4a7455ff27 100644
--- a/tests/unit/llms/fal_ai/chat/test_fal_ai_chat_transformation.py
+++ b/tests/unit/llms/fal_ai/chat/test_fal_ai_chat_transformation.py
@@ -1,3 +1,6 @@
+import logging
+from typing import Final
+
 import httpx
 import pytest
 
@@ -242,11 +245,33 @@ def test_map_openai_params_maps_reasoning_effort(effort, expected):
     assert mapped["reasoning"] is expected
 
 
-def test_map_openai_params_drops_unknown_reasoning_effort_when_dropping():
-    mapped = FalAIChatConfig().map_openai_params(
-        non_default_params={"reasoning_effort": "extreme"}, optional_params={}, model=MODEL, drop_params=True
-    )
+@pytest.mark.parametrize("drop_globally", [False, True])
+def test_map_openai_params_drops_unknown_reasoning_effort_with_one_warning(
+    drop_globally: bool, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    monkeypatch.setattr(litellm, "drop_params", drop_globally)
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        mapped: Final = FalAIChatConfig().map_openai_params(
+            non_default_params={"reasoning_effort": "xhigh"},
+            optional_params={},
+            model=MODEL,
+            drop_params=not drop_globally,
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
     assert "reasoning" not in mapped
+    assert len(drop_warnings) == 1
+    assert all(fragment in drop_warnings[0] for fragment in ("reasoning_effort='xhigh'", MODEL, "(drop_params=True)"))
+
+
+def test_map_openai_params_rejects_unknown_reasoning_effort_without_drop_params(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(litellm, "drop_params", False)
+    with pytest.raises(FalAIError) as exc_info:
+        FalAIChatConfig().map_openai_params(
+            non_default_params={"reasoning_effort": "xhigh"}, optional_params={}, model=MODEL, drop_params=False
+        )
+    assert exc_info.value.status_code == 400
 
 
 @pytest.mark.parametrize("effort", [{"level": "low"}, ["low"], 1])
diff --git a/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py b/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py
index 28f4fdead9e..ed166d206c8 100644
--- a/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py
+++ b/tests/unit/llms/fireworks_ai/chat/test_fireworks_ai_chat_transformation.py
@@ -1,4 +1,5 @@
 import json
+import logging
 from collections.abc import Callable
 from typing import Final
 from unittest.mock import MagicMock, patch
@@ -9,6 +10,7 @@ import respx
 from pydantic import ValidationError
 
 import litellm
+from litellm._logging import verbose_logger
 from litellm.constants import SESSION_ID_GENERATED_METADATA_KEY
 from litellm.litellm_core_utils.get_supported_openai_params import get_supported_openai_params
 from litellm.llms.custom_httpx.http_handler import HTTPHandler
@@ -2361,6 +2363,39 @@ def test_global_disable_flag_with_transform_messages_helper(
     assert json.loads(route.calls.last.request.content)["messages"] == [{"role": "user", "content": content}]
 
 
+def _warnings_naming(caplog: pytest.LogCaptureFixture, param: str) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage() for r in caplog.records if r.levelno == logging.WARNING and f"Dropping {param}=" in r.getMessage()
+    )
+
+
+def test_chat_template_kwargs_effort_dropped_for_non_reasoning_model_warns_once(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        FireworksAIConfig().map_extra_body_params(
+            {"extra_body": {"chat_template_kwargs": {"reasoning_budget": 512}}},
+            _NON_REASONING_MODEL,
+        )
+
+    warnings: Final = _warnings_naming(caplog, "chat_template_kwargs")
+    assert len(warnings) == 1
+    assert "'reasoning_budget': 512" in warnings[0]
+    assert "llama-v3-70b-instruct" in warnings[0]
+
+
+def test_chat_template_kwargs_thinking_off_for_non_reasoning_model_does_not_warn(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        FireworksAIConfig().map_extra_body_params(
+            {"extra_body": {"chat_template_kwargs": {"enable_thinking": False}}},
+            _NON_REASONING_MODEL,
+        )
+
+    assert _warnings_naming(caplog, "chat_template_kwargs") == ()
+
+
 _CODEX_DEVELOPER_MESSAGE_AFTER_A_USER_TURN: Final = (
     {"role": "system", "content": "You are Codex"},
     {"role": "user", "content": "Hi there"},
diff --git a/tests/unit/llms/fireworks_ai/completion/test_fireworks_ai_text_completion_transformation.py b/tests/unit/llms/fireworks_ai/completion/test_fireworks_ai_text_completion_transformation.py
index e5a77aa8d41..d35442d4095 100644
--- a/tests/unit/llms/fireworks_ai/completion/test_fireworks_ai_text_completion_transformation.py
+++ b/tests/unit/llms/fireworks_ai/completion/test_fireworks_ai_text_completion_transformation.py
@@ -1,7 +1,11 @@
 
+import logging
+from typing import Final
+
 import pytest
 
 import litellm
+from litellm._logging import verbose_logger
 
 
 from litellm.llms.fireworks_ai.completion.transformation import (
@@ -204,3 +208,36 @@ def test_transform_text_completion_request_keeps_sdk_rejected_keys_in_extra_body
     assert "chat_template_kwargs" not in data["extra_body"]
     assert "best_of" not in data["extra_body"]
     assert "response_format" not in data
+
+
+def _warnings_naming(caplog: pytest.LogCaptureFixture, param: str) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage() for r in caplog.records if r.levelno == logging.WARNING and f"Dropping {param}=" in r.getMessage()
+    )
+
+
+def test_chat_template_kwargs_effort_dropped_for_non_reasoning_model_warns_once(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        FireworksAITextCompletionConfig().map_extra_body_params(
+            {"extra_body": {"chat_template_kwargs": {"reasoning_budget": 512}}},
+            _NON_REASONING_MODEL,
+        )
+
+    warnings: Final = _warnings_naming(caplog, "chat_template_kwargs")
+    assert len(warnings) == 1
+    assert "'reasoning_budget': 512" in warnings[0]
+    assert "llama-v3-70b-instruct" in warnings[0]
+
+
+def test_chat_template_kwargs_thinking_off_for_non_reasoning_model_does_not_warn(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        FireworksAITextCompletionConfig().map_extra_body_params(
+            {"extra_body": {"chat_template_kwargs": {"enable_thinking": False}}},
+            _NON_REASONING_MODEL,
+        )
+
+    assert _warnings_naming(caplog, "chat_template_kwargs") == ()
diff --git a/tests/unit/llms/mistral/test_mistral_chat_transformation.py b/tests/unit/llms/mistral/test_mistral_chat_transformation.py
index c340f77c317..720a1b4f458 100644
--- a/tests/unit/llms/mistral/test_mistral_chat_transformation.py
+++ b/tests/unit/llms/mistral/test_mistral_chat_transformation.py
@@ -1,4 +1,5 @@
 import json
+import logging
 from collections.abc import Mapping
 from typing import Final, List, cast
 from unittest.mock import MagicMock, patch
@@ -9,6 +10,7 @@ import pytest
 import respx
 from openai import AsyncOpenAI
 
+from litellm._logging import verbose_logger
 from litellm.litellm_core_utils.prompt_templates.common_utils import TOOL_RESULT_IMAGE_BOUNDARY
 from litellm.llms.mistral.chat.transformation import (
     MistralChatResponseIterator,
@@ -1670,6 +1672,109 @@ def test_mistral_transform_request_drops_an_empty_tool_message_whose_call_id_is_
     assert [m.get("role") for m in request["messages"]] == ["user", "assistant"]
 
 
+def _warnings_naming(caplog: pytest.LogCaptureFixture, param: str) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage() for r in caplog.records if r.levelno == logging.WARNING and f"Dropping {param}=" in r.getMessage()
+    )
+
+
+@pytest.mark.parametrize(
+    "param, value",
+    (
+        ("reasoning_effort", "none"),
+        ("reasoning_effort", "xhigh"),
+        ("thinking", {"type": "disabled"}),
+        ("thinking", {"type": ["enabled"]}),
+    ),
+)
+def test_magistral_reasoning_request_replaced_by_prompt_warns_once(
+    param: str, value: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = MistralConfig().map_openai_params(
+            non_default_params={param: value},
+            optional_params={},
+            model="magistral-medium-latest",
+            drop_params=False,
+        )
+
+    warnings: Final = _warnings_naming(caplog, param)
+    assert result["_add_reasoning_prompt"] is True
+    assert len(warnings) == 1
+    assert "magistral-medium-latest" in warnings[0]
+
+
+@pytest.mark.parametrize(
+    "param, value",
+    (
+        ("reasoning_effort", "low"),
+        ("reasoning_effort", "medium"),
+        ("reasoning_effort", "high"),
+        ("thinking", {"type": "enabled", "budget_tokens": 1024}),
+    ),
+)
+def test_magistral_reasoning_request_the_prompt_honors_does_not_warn(
+    param: str, value: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = MistralConfig().map_openai_params(
+            non_default_params={param: value},
+            optional_params={},
+            model="magistral-medium-latest",
+            drop_params=False,
+        )
+
+    assert result["_add_reasoning_prompt"] is True
+    assert _warnings_naming(caplog, param) == ()
+
+
+def test_non_magistral_reasoning_effort_is_sent_without_warning(caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = MistralConfig().map_openai_params(
+            non_default_params={"reasoning_effort": "high"},
+            optional_params={},
+            model="mistral-medium-latest",
+            drop_params=False,
+        )
+
+    assert result["reasoning_effort"] == "high"
+    assert _warnings_naming(caplog, "reasoning_effort") == ()
+
+
+@pytest.mark.parametrize("reasoning_effort", [5, {"effort": 5}, {"effort": 5, "summary": "auto"}])
+def test_mistral_warns_once_when_drop_params_drops_a_level_it_cannot_send(
+    caplog: pytest.LogCaptureFixture, reasoning_effort: object
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        result: Final = MistralConfig().map_openai_params(
+            non_default_params={"reasoning_effort": reasoning_effort},
+            optional_params={},
+            model="mistral-medium-latest",
+            drop_params=True,
+        )
+
+    assert "reasoning_effort" not in result
+    warnings: Final = _warnings_naming(caplog, "reasoning_effort")
+    assert len(warnings) == 1
+    assert "model='mistral-medium-latest'" in warnings[0]
+    assert "(drop_params=True)" in warnings[0]
+
+
+@pytest.mark.parametrize("reasoning_effort", [{"summary": "auto"}, {"effort": "high", "summary": "auto"}])
+def test_mistral_stays_quiet_under_drop_params_when_no_level_is_lost(
+    caplog: pytest.LogCaptureFixture, reasoning_effort: object
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        MistralConfig().map_openai_params(
+            non_default_params={"reasoning_effort": reasoning_effort},
+            optional_params={},
+            model="mistral-medium-latest",
+            drop_params=True,
+        )
+
+    assert _warnings_naming(caplog, "reasoning_effort") == ()
+
+
 @pytest.mark.parametrize(
     ("model", "custom_llm_provider"),
     [
diff --git a/tests/unit/llms/oci/chat/test_oci_chat_transformation.py b/tests/unit/llms/oci/chat/test_oci_chat_transformation.py
index 0535279d177..f22b5e32593 100644
--- a/tests/unit/llms/oci/chat/test_oci_chat_transformation.py
+++ b/tests/unit/llms/oci/chat/test_oci_chat_transformation.py
@@ -1,4 +1,5 @@
 import datetime
+import logging
 from typing import Final
 import httpx
 import pytest
@@ -1103,19 +1104,25 @@ class TestOCIReasoningEffort:
         )
         assert chat_request.get("reasoningEffort") == "HIGH"
 
-    def test_reasoning_effort_unsupported_on_cohere_dropped(self):
-        """drop_params=True → silently drop reasoning_effort for Cohere."""
+    def test_reasoning_effort_unsupported_on_cohere_dropped_with_one_warning(self, caplog):
         from litellm.llms.oci.chat.transformation import OCIChatConfig
 
         config = OCIChatConfig()
-        result = config.map_openai_params(
-            non_default_params={"reasoning_effort": "low"},
-            optional_params={},
-            model="cohere.command-latest",
-            drop_params=True,
-        )
+        with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+            result = config.map_openai_params(
+                non_default_params={"reasoning_effort": "low"},
+                optional_params={},
+                model="cohere.command-latest",
+                drop_params=True,
+            )
+        drop_warnings = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
         assert "reasoning_effort" not in result
         assert "reasoningEffort" not in result
+        assert len(drop_warnings) == 1
+        assert all(
+            fragment in drop_warnings[0]
+            for fragment in ("reasoning_effort='low'", "cohere.command-latest", "(drop_params=True)")
+        )
 
     def test_reasoning_effort_unsupported_on_cohere_raises(self):
         """drop_params=False → raise rather than ship a payload Cohere will reject."""
@@ -2110,16 +2117,20 @@ class TestReasoningEffortGating:
         assert "reasoning_effort" not in OCIChatConfig().get_supported_openai_params("meta.llama-3.3-70b-instruct")
 
     @pytest.mark.parametrize("model", SERVED_GROK_4_20_MODELS)
-    def test_reasoning_effort_dropped_under_drop_params(self, local_model_cost_map, model):
-        result = OCIChatConfig().map_openai_params(
-            non_default_params={"reasoning_effort": "low", "temperature": 0.1},
-            optional_params={},
-            model=model,
-            drop_params=True,
-        )
+    def test_reasoning_effort_dropped_under_drop_params_with_one_warning(self, local_model_cost_map, model, caplog):
+        with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+            result = OCIChatConfig().map_openai_params(
+                non_default_params={"reasoning_effort": "low", "temperature": 0.1},
+                optional_params={},
+                model=model,
+                drop_params=True,
+            )
+        drop_warnings = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
         assert "reasoningEffort" not in result
         assert "reasoning_effort" not in result
         assert result["temperature"] == 0.1
+        assert len(drop_warnings) == 1
+        assert all(fragment in drop_warnings[0] for fragment in ("reasoning_effort='low'", model, "(drop_params=True)"))
 
     def test_reasoning_effort_raises_without_drop_params_for_gated_grok(self, local_model_cost_map, monkeypatch):
         monkeypatch.setattr(litellm, "drop_params", False)
diff --git a/tests/unit/llms/ollama/test_ollama_chat_transformation.py b/tests/unit/llms/ollama/test_ollama_chat_transformation.py
index df9f5fd9d14..af1b85cf325 100644
--- a/tests/unit/llms/ollama/test_ollama_chat_transformation.py
+++ b/tests/unit/llms/ollama/test_ollama_chat_transformation.py
@@ -1,5 +1,6 @@
 import asyncio
 import inspect
+import logging
 import os
 import sys
 from typing import Final, cast
@@ -23,6 +24,7 @@ import json
 from unittest.mock import ANY, MagicMock, patch
 
 import litellm
+from litellm._logging import verbose_logger
 from litellm.types.utils import Choices, EmbeddingResponse, Message, ModelResponse, ModelResponseStream
 from unittest import mock
 
@@ -1114,3 +1116,36 @@ def test_get_complete_url_ignores_a_trailing_slash_on_api_base(api_base: str):
         )
         == "http://gateway.example.com/ollama/api/chat"
     )
+
+
+def _warnings_naming(caplog: pytest.LogCaptureFixture, param: str) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage() for r in caplog.records if r.levelno == logging.WARNING and f"Dropping {param}=" in r.getMessage()
+    )
+
+
+@pytest.mark.parametrize("effort", ("minimal", "xhigh"))
+def test_reasoning_effort_mapped_to_think_off_warns_once(effort: str, caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = OllamaChatConfig().map_openai_params(
+            non_default_params={"reasoning_effort": effort}, optional_params={}, model="qwen3", drop_params=False
+        )
+
+    warnings: Final = _warnings_naming(caplog, "reasoning_effort")
+    assert result["think"] is False
+    assert len(warnings) == 1
+    assert f"reasoning_effort={effort!r}" in warnings[0]
+    assert "qwen3" in warnings[0]
+
+
+@pytest.mark.parametrize("effort, think", (("none", False), ("low", True), ("high", True)))
+def test_reasoning_effort_with_a_matching_think_value_does_not_warn(
+    effort: str, think: bool, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = OllamaChatConfig().map_openai_params(
+            non_default_params={"reasoning_effort": effort}, optional_params={}, model="qwen3", drop_params=False
+        )
+
+    assert result["think"] is think
+    assert _warnings_naming(caplog, "reasoning_effort") == ()
diff --git a/tests/unit/llms/ollama/test_ollama_completion_transformation.py b/tests/unit/llms/ollama/test_ollama_completion_transformation.py
index 248e745ebff..edea39bb10c 100644
--- a/tests/unit/llms/ollama/test_ollama_completion_transformation.py
+++ b/tests/unit/llms/ollama/test_ollama_completion_transformation.py
@@ -1,6 +1,7 @@
 import base64
 import io
 import json
+import logging
 import sys
 from typing import Final
 from unittest.mock import MagicMock, patch
@@ -10,6 +11,7 @@ import pytest
 import respx
 
 import litellm
+from litellm._logging import verbose_logger
 from litellm._uuid import uuid
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.llms.ollama.completion.transformation import (
@@ -990,3 +992,40 @@ def test_get_complete_url_ignores_a_trailing_slash_on_api_base(api_base: str):
         )
         == "http://gateway.example.com/ollama/api/generate"
     )
+
+def _reasoning_effort_warnings(caplog: pytest.LogCaptureFixture) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage()
+        for r in caplog.records
+        if r.levelno == logging.WARNING and "Dropping reasoning_effort=" in r.getMessage()
+    )
+
+
+@pytest.mark.parametrize("effort", ("minimal", "xhigh"))
+def test_reasoning_effort_mapped_to_think_off_warns_once(effort: str, caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = OllamaConfig().map_openai_params(
+            non_default_params={"reasoning_effort": effort}, optional_params={}, model="qwen3:0.6b", drop_params=False
+        )
+
+    warnings: Final = _reasoning_effort_warnings(caplog)
+    assert result["think"] is False
+    assert len(warnings) == 1
+    assert f"reasoning_effort={effort!r}" in warnings[0]
+    assert "qwen3:0.6b" in warnings[0]
+
+
+@pytest.mark.parametrize(
+    "model, effort, think",
+    (("qwen3:0.6b", "none", False), ("qwen3:0.6b", "high", True), ("gpt-oss:20b", "xhigh", "xhigh")),
+)
+def test_reasoning_effort_ollama_honors_does_not_warn(
+    model: str, effort: str, think: object, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = OllamaConfig().map_openai_params(
+            non_default_params={"reasoning_effort": effort}, optional_params={}, model=model, drop_params=False
+        )
+
+    assert result["think"] == think
+    assert _reasoning_effort_warnings(caplog) == ()
diff --git a/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py b/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py
index 673e880a1c0..d732d922375 100644
--- a/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py
+++ b/tests/unit/llms/openai/responses/test_openai_responses_guardrail_handler.py
@@ -724,16 +724,23 @@ class TestToolResultItemsReachTextsGuardrails:
         assert blocked.value.status_code == 400
 
     @pytest.mark.asyncio
-    @pytest.mark.parametrize("empty_output", ["", None], ids=["empty_string", "null"])
-    async def test_empty_tool_output_sends_no_text_and_stays_as_sent(self, empty_output: str | None) -> None:
+    @pytest.mark.parametrize(("call_item", "output_type"), _TOOL_TURNS, ids=["function", "custom"])
+    @pytest.mark.parametrize(
+        "empty_output",
+        ["", None, [], *[[{"type": kind, "text": ""}] for kind in ("input_text", "output_text", "text")]],
+        ids=["empty_string", "null", "empty_list", "input_text", "output_text", "text"],
+    )
+    async def test_empty_tool_output_sends_no_text_and_stays_as_sent(
+        self, call_item: dict[str, str], output_type: str, empty_output: object
+    ) -> None:
         guardrail: Final = RecordingMaskingGuardrail(guardrail_name="test")
-        call_item, output_type = _TOOL_TURNS[0]
 
         result: Final = await OpenAIResponsesHandler().process_input_messages(
             _tool_result_request(call_item, output_type, empty_output), guardrail
         )
 
         assert guardrail.seen_texts == [["Weather?"]]
+        assert guardrail.seen_message_contents == [["Weather?", None]]
         assert result["input"][2] == {"type": output_type, "call_id": "call_1", "output": empty_output}
 
     @pytest.mark.asyncio
@@ -1103,7 +1110,6 @@ class TestToolResultItemsReachTextsGuardrails:
                 ["visible"],
                 id="non_dict_part",
             ),
-            pytest.param([], ["[]"], id="empty"),
             pytest.param({"result": "SECRET forecast"}, ['{"result": "SECRET forecast"}'], id="dict"),
             pytest.param(
                 [{"type": "input_image", "file_id": "file-map"}],
diff --git a/tests/unit/llms/openai/test_openai_common_utils.py b/tests/unit/llms/openai/test_openai_common_utils.py
index 46c14fcfd8f..f0865cca7f9 100644
--- a/tests/unit/llms/openai/test_openai_common_utils.py
+++ b/tests/unit/llms/openai/test_openai_common_utils.py
@@ -1,4 +1,6 @@
 import asyncio
+import json
+import logging
 from typing import Final
 from unittest.mock import MagicMock, patch
 
@@ -9,7 +11,11 @@ import respx
 
 import litellm
 from litellm.litellm_core_utils.token_counter import token_counter
-from litellm.llms.openai.common_utils import BaseOpenAILLM, is_openai_backed_api_base
+from litellm.llms.openai.common_utils import (
+    BaseOpenAILLM,
+    drop_params_from_unprocessable_entity_error,
+    is_openai_backed_api_base,
+)
 
 # Test parameters for different API functions
 API_FUNCTION_PARAMS = [
@@ -319,6 +325,104 @@ def _completion_kwargs(provider: str, client, **overrides) -> dict:
     }
 
 
+_REASONING_EFFORT_422: Final = {
+    "error": {
+        "message": json.dumps(
+            {"detail": [{"loc": ["body", "reasoning_effort"], "msg": "Extra inputs are not permitted"}]}
+        )
+    }
+}
+_CHAT_COMPLETION: Final = {
+    "id": "chatcmpl-1",
+    "object": "chat.completion",
+    "created": 1,
+    "model": "gpt-6.1-sol",
+    "choices": [{"index": 0, "message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop"}],
+    "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+}
+_CHAT_COMPLETION_STREAM: Final = (
+    'data: {"id":"chatcmpl-1","object":"chat.completion.chunk","created":1,"model":"gpt-6.1-sol",'
+    '"choices":[{"index":0,"delta":{"role":"assistant","content":"ok"},"finish_reason":"stop"}]}\n\n'
+    "data: [DONE]\n\n"
+)
+
+
+def _answer_422_while_reasoning_effort_is_sent(request: httpx.Request) -> httpx.Response:
+    body: Final = json.loads(request.content)
+    if "reasoning_effort" in body:
+        return httpx.Response(422, json=_REASONING_EFFORT_422)
+    if body.get("stream"):
+        return httpx.Response(200, text=_CHAT_COMPLETION_STREAM, headers={"content-type": "text/event-stream"})
+    return httpx.Response(200, json=_CHAT_COMPLETION)
+
+
+async def _complete_through_the_422_retry(call_shape: str) -> str:
+    transport: Final = httpx.MockTransport(_answer_422_while_reasoning_effort_is_sent)
+    kwargs: Final = {
+        "model": "gpt-6.1-sol",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "high",
+    }
+    if call_shape == "sync":
+        sync_client: Final = openai.OpenAI(api_key="sk-not-a-real-key", http_client=httpx.Client(transport=transport))
+        return litellm.completion(**kwargs, client=sync_client).choices[0].message.content
+    async_client: Final = openai.AsyncOpenAI(
+        api_key="sk-not-a-real-key", http_client=httpx.AsyncClient(transport=transport)
+    )
+    if call_shape == "async":
+        return (await litellm.acompletion(**kwargs, client=async_client)).choices[0].message.content
+    stream: Final = await litellm.acompletion(**kwargs, client=async_client, stream=True)
+    return "".join([chunk.choices[0].delta.content or "" async for chunk in stream])
+
+
+@pytest.mark.parametrize("call_shape", ["sync", "async", "async_stream"])
+def test_a_422_naming_reasoning_effort_drops_it_with_one_warning(
+    call_shape: str, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    monkeypatch.setattr(litellm, "drop_params", True)
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        content: Final = asyncio.run(_complete_through_the_422_retry(call_shape))
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+
+    assert content == "ok"
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0]
+        for fragment in ("reasoning_effort='high'", "gpt-6.1-sol", "(drop_params=True)", "422")
+    )
+
+
+def test_a_422_with_an_unhashable_loc_still_drops_reasoning_effort_with_one_warning(
+    monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    detail: Final = [
+        {"loc": ["body", ["messages", 0]], "msg": "Invalid"},
+        {"loc": ["body", "reasoning_effort"], "msg": "Extra inputs are not permitted"},
+    ]
+
+    def answer(request: httpx.Request) -> httpx.Response:
+        if "reasoning_effort" in json.loads(request.content):
+            return httpx.Response(422, json={"error": {"message": json.dumps({"detail": detail})}})
+        return httpx.Response(200, json=_CHAT_COMPLETION)
+
+    monkeypatch.setattr(litellm, "drop_params", True)
+    client: Final = openai.OpenAI(
+        api_key="sk-not-a-real-key", http_client=httpx.Client(transport=httpx.MockTransport(answer))
+    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        response: Final = litellm.completion(
+            model="gpt-6.1-sol",
+            messages=[{"role": "user", "content": "hi"}],
+            reasoning_effort="high",
+            client=client,
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+
+    assert response.choices[0].message.content == "ok"
+    assert len(drop_warnings) == 1
+    assert "reasoning_effort='high'" in drop_warnings[0]
+
+
 @pytest.mark.parametrize("provider", ["openai", "azure"])
 def test_sync_output_limit_400_maps_to_length_truncated_response(provider):
     response = litellm.completion(
@@ -588,3 +692,24 @@ async def test_azure_gateway_and_image_variations_use_the_callers_async_session(
         )
         assert response.data[0].url == "https://example.com/image.png"
         assert not session.is_closed
+
+
+
+def test_reasoning_drop_warning_caps_a_large_caller_value(caplog: pytest.LogCaptureFixture) -> None:
+    error: Final = httpx.HTTPStatusError(
+        message="422",
+        request=httpx.Request("POST", "https://example.invalid/v1/chat/completions"),
+        response=httpx.Response(422, json=_REASONING_EFFORT_422),
+    )
+    data: Final[dict[str, object]] = {"model": "gpt-6.1-sol", "messages": [], "reasoning_effort": "x" * 5000}
+
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        retried: Final = drop_params_from_unprocessable_entity_error(
+            error, data, model="gpt-6.1-sol", drop_params_gated=True
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+
+    assert "reasoning_effort" not in retried
+    assert len(drop_warnings) == 1
+    assert len(drop_warnings[0]) < 300
+    assert all(fragment in drop_warnings[0] for fragment in ("reasoning_effort='xxx", "'gpt-6.1-sol'", "422"))
diff --git a/tests/unit/llms/openai_like/test_aiand_provider.py b/tests/unit/llms/openai_like/test_aiand_provider.py
index 804f3a3b6eb..0274b58f19a 100644
--- a/tests/unit/llms/openai_like/test_aiand_provider.py
+++ b/tests/unit/llms/openai_like/test_aiand_provider.py
@@ -1,4 +1,6 @@
+import datetime
 import json
+import time
 from typing import Final
 
 import httpx
@@ -8,6 +10,8 @@ import respx
 import litellm
 from litellm.caching.llm_caching_handler import LLMClientCache
 from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
+from litellm.litellm_core_utils.health_check_helpers import wildcard_health_check_models
+from litellm.litellm_core_utils.model_retirement import is_past_deprecation_date
 from litellm.llms.openai_like.json_loader import JSONProviderRegistry
 from litellm.proxy.auth.model_checks import get_known_models_from_wildcard
 from litellm.utils import ProviderConfigManager
@@ -89,11 +93,99 @@ def _aiand_catalog() -> frozenset[str]:
     return frozenset(name for name, info in litellm.model_cost.items() if info.get("litellm_provider") == "aiand")
 
 
-def test_aiand_wildcard_lists_its_priced_models():
-    catalog: Final = _aiand_catalog()
+def _utc_today() -> datetime.date:
+    return datetime.datetime.now(datetime.timezone.utc).date()
 
-    assert catalog
-    assert frozenset(get_known_models_from_wildcard("aiand/*")) == catalog
+
+def test_aiand_wildcard_lists_only_models_not_yet_retired():
+    catalog: Final = _aiand_catalog()
+    retired: Final = frozenset(
+        name
+        for name in catalog
+        if (retired_on := litellm.model_cost[name].get("deprecation_date")) is not None
+        and datetime.date.fromisoformat(retired_on) <= _utc_today()
+    )
+
+    assert catalog - retired
+    assert frozenset(get_known_models_from_wildcard("aiand/*")) == catalog - retired
+
+
+def test_aiand_wildcard_drops_a_model_whose_retirement_date_passes_while_running(monkeypatch: pytest.MonkeyPatch):
+    model: Final = "aiand/acme/retires-while-running"
+    monkeypatch.setitem(litellm.model_cost, model, {"litellm_provider": "aiand", "deprecation_date": "2999-01-01"})
+    try:
+        litellm.add_known_models({model: litellm.model_cost[model]})
+        assert model in get_known_models_from_wildcard("aiand/*")
+
+        monkeypatch.setitem(litellm.model_cost, model, {"litellm_provider": "aiand", "deprecation_date": "2000-01-01"})
+
+        assert model not in get_known_models_from_wildcard("aiand/*")
+    finally:
+        litellm.aiand_models.discard(model)
+        litellm.add_known_models({})
+
+
+def test_aiand_models_by_provider_leaves_out_models_retired_at_load():
+    retired: Final = frozenset(
+        name
+        for name, row in litellm.model_cost.items()
+        if row.get("litellm_provider") == "aiand" and is_past_deprecation_date(row)
+    )
+
+    assert retired
+    assert retired.isdisjoint(litellm.models_by_provider["aiand"])
+
+
+def test_aiand_wildcard_health_check_skips_a_model_whose_retirement_date_passes_while_running(
+    monkeypatch: pytest.MonkeyPatch,
+):
+    model: Final = "aiand/acme/free-and-retiring"
+    live_row: Final = {
+        "litellm_provider": "aiand",
+        "mode": "chat",
+        "input_cost_per_token": 0.0,
+        "output_cost_per_token": 0.0,
+        "deprecation_date": "2999-01-01",
+    }
+    monkeypatch.setitem(litellm.model_cost, model, live_row)
+    try:
+        litellm.add_known_models({model: live_row})
+        assert model in wildcard_health_check_models(wildcard="aiand/*", custom_llm_provider="aiand")
+
+        monkeypatch.setitem(litellm.model_cost, model, {**live_row, "deprecation_date": "2000-01-01"})
+
+        assert model not in wildcard_health_check_models(wildcard="aiand/*", custom_llm_provider="aiand")
+    finally:
+        litellm.aiand_models.discard(model)
+        litellm.add_known_models({})
+
+
+@pytest.mark.parametrize("host_zone", ["Etc/GMT+12", "Etc/GMT-14"])
+def test_aiand_models_retire_on_the_utc_date_whatever_the_host_zone(monkeypatch: pytest.MonkeyPatch, host_zone: str):
+    today: Final = _utc_today()
+    rows: Final = {
+        "aiand/acme/retires-today": {"litellm_provider": "aiand", "deprecation_date": today.isoformat()},
+        "aiand/acme/retires-tomorrow": {
+            "litellm_provider": "aiand",
+            "deprecation_date": (today + datetime.timedelta(days=1)).isoformat(),
+        },
+    }
+    for name, row in rows.items():
+        monkeypatch.setitem(litellm.model_cost, name, row)
+    monkeypatch.setenv("TZ", host_zone)
+    time.tzset()
+    try:
+        litellm.add_known_models(rows)
+        listed: Final = frozenset(get_known_models_from_wildcard("aiand/*"))
+
+        assert "aiand/acme/retires-today" not in listed
+        assert "aiand/acme/retires-tomorrow" in listed
+    finally:
+        monkeypatch.undo()
+        time.tzset()
+        for name in rows:
+            litellm.aiand_models.discard(name)
+        litellm.add_known_models({})
 
 
 def test_aiand_calls_are_billed_from_their_cost_rows():
diff --git a/tests/unit/llms/openrouter/chat/test_openrouter_chat_transformation.py b/tests/unit/llms/openrouter/chat/test_openrouter_chat_transformation.py
index 59355dfabcb..888c47505a4 100644
--- a/tests/unit/llms/openrouter/chat/test_openrouter_chat_transformation.py
+++ b/tests/unit/llms/openrouter/chat/test_openrouter_chat_transformation.py
@@ -1,6 +1,7 @@
 
 import json
 from typing import Final
+from unittest.mock import MagicMock
 
 import httpx
 import pytest
@@ -464,6 +465,34 @@ def test_openrouter_cost_tracking_non_streaming():
     )
 
 
+
+@pytest.mark.parametrize("cost", [float("nan"), float("inf")])
+def test_openrouter_chat_leaves_a_non_finite_provider_cost_out_of_the_response_headers(cost: float) -> None:
+    body: Final = {
+        "id": "gen-123",
+        "object": "chat.completion",
+        "created": 1234567890,
+        "model": "openai/gpt-5.6-luna",
+        "choices": [{"message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop", "index": 0}],
+        "usage": {"prompt_tokens": 10, "completion_tokens": 1, "total_tokens": 11, "cost": cost},
+    }
+
+    result: Final = OpenrouterConfig().transform_response(
+        model="openrouter/openai/gpt-5.6-luna",
+        raw_response=httpx.Response(
+            200, content=json.dumps(body).encode(), headers={"content-type": "application/json"}
+        ),
+        model_response=litellm.ModelResponse(),
+        logging_obj=MagicMock(),
+        request_data={},
+        messages=[{"role": "user", "content": "Reply with ok"}],
+        optional_params={},
+        litellm_params={},
+        encoding=None,
+    )
+
+    assert "llm_provider-x-litellm-response-cost" not in result._hidden_params.get("additional_headers", {})
+
 def test_openrouter_cost_tracking_streaming():
     """
     Test OpenRouter cost tracking for streaming completions.
diff --git a/tests/unit/llms/openrouter/responses/test_openrouter_responses_transformation.py b/tests/unit/llms/openrouter/responses/test_openrouter_responses_transformation.py
index 19517e58b31..78d7161c388 100644
--- a/tests/unit/llms/openrouter/responses/test_openrouter_responses_transformation.py
+++ b/tests/unit/llms/openrouter/responses/test_openrouter_responses_transformation.py
@@ -9,6 +9,8 @@ reasoning.encrypted_content for multi-turn stateless workflows.
 Related issue: https://github.com/BerriAI/litellm/issues/22189
 """
 
+import json
+from typing import Final
 from unittest.mock import MagicMock
 
 import httpx
@@ -157,6 +159,29 @@ def test_openrouter_responses_returns_provider_reported_cost(cost):
     assert get_response_cost_from_hidden_params(response.hidden_params) == cost
 
 
+@pytest.mark.parametrize("cost", [float("nan"), float("inf")])
+def test_openrouter_responses_drops_a_non_finite_provider_cost(cost: float) -> None:
+    body: Final = {
+        "id": "resp_test",
+        "created_at": 1,
+        "model": "unmapped-model",
+        "object": "response",
+        "output": [],
+        "status": "completed",
+        "usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5, "cost": cost},
+    }
+    response: Final = OpenRouterResponsesAPIConfig().transform_response_api_response(
+        model="openrouter/unmapped-model",
+        raw_response=httpx.Response(
+            200, content=json.dumps(body).encode(), headers={"content-type": "application/json"}
+        ),
+        logging_obj=MagicMock(),
+    )
+
+    assert get_response_cost_from_hidden_params(response.hidden_params) is None
+    assert json.loads(json.dumps(response.model_dump(), allow_nan=False, default=str))["usage"]["cost"] is None
+
+
 @pytest.mark.parametrize(
     "event_type",
     ["response.completed", "response.incomplete", "response.failed"],
diff --git a/tests/unit/llms/perplexity/test_perplexity_cost_calculator.py b/tests/unit/llms/perplexity/test_perplexity_cost_calculator.py
index 83c71479311..380f85445e5 100644
--- a/tests/unit/llms/perplexity/test_perplexity_cost_calculator.py
+++ b/tests/unit/llms/perplexity/test_perplexity_cost_calculator.py
@@ -6,9 +6,11 @@ search queries, and reasoning tokens.
 """
 
 import json
+import logging
 import math
 import os
 from datetime import datetime, timezone
+from typing import Final
 from unittest.mock import patch
 
 import pytest
@@ -140,6 +142,26 @@ class TestPerplexityCostCalculator:
         assert prompt_cost == 0.0
         assert completion_cost == 0.008
 
+    @pytest.mark.parametrize(
+        "reported_cost",
+        [float("nan"), float("inf"), {"total_cost": float("nan")}],
+        ids=["nan", "inf", "nan-total-cost-dict"],
+    )
+    def test_a_non_finite_perplexity_cost_is_priced_like_no_reported_cost_with_a_warning(
+        self, reported_cost: float | dict, caplog: pytest.LogCaptureFixture
+    ):
+        unreported: Final = Usage(prompt_tokens=100, completion_tokens=50, total_tokens=150)
+        reported: Final = Usage(prompt_tokens=100, completion_tokens=50, total_tokens=150)
+        reported.cost = reported_cost
+
+        token_priced: Final = perplexity_cost_per_token(model="sonar-pro", usage=unreported)
+        with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+            reported_priced: Final = perplexity_cost_per_token(model="sonar-pro", usage=reported)
+
+        assert sum(token_priced) > 0
+        assert reported_priced == token_priced
+        assert [record for record in caplog.records if "non-finite provider-reported cost" in record.getMessage()]
+
     OFF_PEAK_MODEL = "sonar-off-peak-test"
     OFF_PEAK_WINDOW = "14:00-00:00"
     INSIDE_WINDOW = datetime(2026, 9, 3, 17, 25, tzinfo=timezone.utc)
diff --git a/tests/unit/llms/tencent/chat/test_tencent_chat_transformation.py b/tests/unit/llms/tencent/chat/test_tencent_chat_transformation.py
index 4d6d252ae6e..1bf646fc2ad 100644
--- a/tests/unit/llms/tencent/chat/test_tencent_chat_transformation.py
+++ b/tests/unit/llms/tencent/chat/test_tencent_chat_transformation.py
@@ -1,5 +1,10 @@
+import logging
+from typing import Final
 from unittest.mock import patch
 
+import pytest
+
+from litellm._logging import verbose_logger
 from litellm.llms.tencent.chat.transformation import TencentChatConfig
 
 
@@ -208,6 +213,27 @@ class TestAdaptiveThinkingCoercion:
 
         assert result["extra_body"]["thinking"] == {"type": "adaptive", "budget_tokens": 4096}
 
+    @pytest.mark.parametrize("budget, warned", (("high", 1), (4096, 0)), ids=("non-integer", "integer"))
+    def test_enabled_thinking_on_adaptive_only_model_warns_only_when_the_budget_is_dropped(
+        self, local_model_cost_map, budget: object, warned: int, caplog: pytest.LogCaptureFixture
+    ):
+        with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+            result: Final = TencentChatConfig().map_openai_params(
+                non_default_params={"thinking": {"type": "enabled", "budget_tokens": budget}},
+                optional_params={},
+                model="tencent/minimax-m3",
+                drop_params=False,
+            )
+
+        warnings: Final = tuple(
+            r.getMessage()
+            for r in caplog.records
+            if r.levelno == logging.WARNING and f"Dropping thinking.budget_tokens={budget!r}" in r.getMessage()
+        )
+        assert result["extra_body"]["thinking"]["type"] == "adaptive"
+        assert result["extra_body"]["thinking"].get("budget_tokens") == (None if warned else budget)
+        assert len(warnings) == warned
+
     def test_disabled_thinking_kept_for_adaptive_only_model(self, local_model_cost_map):
         config = TencentChatConfig()
         result = config.map_openai_params(
diff --git a/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py b/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
index 67c78b62151..98d1b8f1300 100644
--- a/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
+++ b/tests/unit/llms/vertex_ai/gemini/test_vertex_and_google_ai_studio_gemini.py
@@ -1693,6 +1693,78 @@ def test_vertex_ai_map_thinking_param_without_budget_tokens_for_gemini_3():
     assert result["thinkingConfig"] == {"includeThoughts": True}
 
 
+def _budget_drop_warnings(caplog: pytest.LogCaptureFixture) -> tuple[str, ...]:
+    return tuple(
+        r.getMessage()
+        for r in caplog.records
+        if r.levelno == logging.WARNING and "thinking.budget_tokens" in r.getMessage()
+    )
+
+
+@pytest.mark.parametrize("budget", ("high", 1024.5, {"tokens": 1024}))
+def test_gemini_non_integer_thinking_budget_drop_warns_once(budget: object, caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = VertexGeminiConfig().map_openai_params(
+            non_default_params={"thinking": {"type": "enabled", "budget_tokens": budget}},
+            optional_params={},
+            model="gemini-2.5-flash",
+            drop_params=False,
+        )
+
+    warnings: Final = _budget_drop_warnings(caplog)
+    assert "thinkingBudget" not in result["thinkingConfig"]
+    assert len(warnings) == 1
+    assert f"thinking.budget_tokens={budget!r}" in warnings[0]
+    assert "gemini-2.5-flash" in warnings[0]
+
+
+def test_gemini_integer_thinking_budget_is_sent_without_warning(caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = VertexGeminiConfig().map_openai_params(
+            non_default_params={"thinking": {"type": "enabled", "budget_tokens": 2048}},
+            optional_params={},
+            model="gemini-2.5-flash",
+            drop_params=False,
+        )
+
+    assert result["thinkingConfig"]["thinkingBudget"] == 2048
+    assert _budget_drop_warnings(caplog) == ()
+
+
+def test_gemini_3_thinking_budget_drop_warns_once(caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        result: Final = VertexGeminiConfig().map_openai_params(
+            non_default_params={"thinking": {"type": "enabled", "budget_tokens": 2048}},
+            optional_params={},
+            model="gemini-3-pro-preview",
+            drop_params=False,
+        )
+
+    warnings: Final = _budget_drop_warnings(caplog)
+    assert "thinkingBudget" not in result["thinkingConfig"]
+    assert len(warnings) == 1
+    assert "thinking.budget_tokens=2048" in warnings[0]
+    assert "gemini-3-pro-preview" in warnings[0]
+
+
+@pytest.mark.parametrize(
+    "thinking",
+    ({"type": "enabled"}, {"type": "enabled", "budget_tokens": 0}, {"type": "disabled", "budget_tokens": 2048}),
+)
+def test_gemini_3_thinking_without_a_dropped_budget_does_not_warn(
+    thinking: dict[str, object], caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
+        VertexGeminiConfig().map_openai_params(
+            non_default_params={"thinking": thinking},
+            optional_params={},
+            model="gemini-3-pro-preview",
+            drop_params=False,
+        )
+
+    assert _budget_drop_warnings(caplog) == ()
+
+
 def test_vertex_ai_map_tools():
     v = VertexGeminiConfig()
     optional_params = {}
diff --git a/tests/unit/llms/vertex_ai/test_vertex_ai_common_utils.py b/tests/unit/llms/vertex_ai/test_vertex_ai_common_utils.py
index 152ab2ffc13..3b222be6e5e 100644
--- a/tests/unit/llms/vertex_ai/test_vertex_ai_common_utils.py
+++ b/tests/unit/llms/vertex_ai/test_vertex_ai_common_utils.py
@@ -1293,6 +1293,9 @@ def test_get_vertex_model_id_from_url():
     model_id = get_vertex_model_id_from_url(url)
     assert model_id == "gemini-pro"
 
+    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro?key=provider-secret#frag"
+    assert get_vertex_model_id_from_url(url) == "gemini-pro"
+
     # Test with invalid URL
     url = "https://invalid-url.com"
     model_id = get_vertex_model_id_from_url(url)
diff --git a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
index 7f16957ddc4..fc57dd13302 100644
--- a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
+++ b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
@@ -8,11 +8,13 @@ from threading import get_ident
 from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
 
+import httpx
 import pytest
 import requests
 import responses
 
 import litellm
+from litellm.anthropic_beta_headers_manager import update_headers_with_filtered_beta
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.messages.transformation import (
     VertexAIPartnerModelsAnthropicMessagesConfig,
@@ -115,7 +117,11 @@ def _vertex_client() -> MagicMock:
 
 async def _send_to_vertex(client: MagicMock, caller_headers: Mapping[str, str], drop_params: bool) -> None:
     with responses.RequestsMock(assert_all_requests_are_fired=False) as oauth:
-        oauth.add(responses.POST, "https://oauth2.googleapis.com/token", json={"access_token": "vertex-token", "expires_in": 3600})
+        oauth.add(
+            responses.POST,
+            "https://oauth2.googleapis.com/token",
+            json={"access_token": "vertex-token", "expires_in": 3600},
+        )
         await litellm.anthropic.messages.acreate(
             model="vertex_ai/claude-sonnet-5",
             messages=[{"role": "user", "content": "hi"}],
@@ -289,7 +295,12 @@ def test_no_safeguards_leaves_dangerous_tool_use_beta_header_out():
     assert "dangerous-tool-use-2026-09-03" not in updated_headers.get("anthropic-beta", "")
 
 
-def _validate_vertex_headers(client_headers, messages, thinking: Mapping[str, object] | None = None):
+def _validate_vertex_headers(
+    client_headers: dict[str, str],
+    messages: list[object],
+    optional_params: dict[str, object] | None = None,
+    thinking: Mapping[str, object] | None = None,
+) -> dict[str, str]:
     config = VertexAIPartnerModelsAnthropicMessagesConfig()
     litellm_params = {
         "vertex_ai_project": "test-project",
@@ -305,7 +316,10 @@ def _validate_vertex_headers(client_headers, messages, thinking: Mapping[str, ob
             headers=client_headers,
             model="claude-opus-5-5",
             messages=messages,
-            optional_params={"max_tokens": 64, **({"thinking": thinking} if thinking is not None else {})},
+            optional_params={
+                **(optional_params or {"max_tokens": 64}),
+                **({"thinking": thinking} if thinking is not None else {}),
+            },
             litellm_params=litellm_params,
             api_base=None,
         )
@@ -1040,3 +1054,178 @@ def test_vertex_claude_4_8_plus_cost_map_entries_carry_mid_conversation_system_f
         and info.get("supports_mid_conversation_system") is not True
     ]
     assert missing == []
+
+
+_SIGNED_COMPACTION_BLOCK: Final = {"type": "compaction", "content": "summary so far", "signature": "sig"}
+
+
+@pytest.mark.parametrize(
+    "client_headers",
+    [{"anthropic-beta": "compact-2026-09-04"}, {}],
+    ids=["client_sends_beta", "client_omits_beta"],
+)
+@pytest.mark.parametrize(
+    "optional_params,messages",
+    [
+        ({"max_tokens": 64, "compaction": {"type": "summarize"}}, [{"role": "user", "content": "Hello"}]),
+        (
+            {"max_tokens": 64},
+            [{"role": "assistant", "content": [_SIGNED_COMPACTION_BLOCK]}, {"role": "user", "content": "Go on"}],
+        ),
+    ],
+    ids=["compaction_param", "signed_compaction_block"],
+)
+def test_native_compaction_reaches_vertex_with_compact_2026_09_04_beta(
+    local_beta_headers_config: None,
+    client_headers: dict[str, str],
+    optional_params: dict[str, object],
+    messages: list[object],
+) -> None:
+    """Vertex serves on-demand compaction only behind compact-2026-09-04 (Google Cloud: beta on
+    https://platform.claude.com/docs/en/build-with-claude/compaction-on-demand, read 2026-10-05)
+    and answers 400 "compaction: Extra inputs are not permitted" without it, so the beta rides
+    along with the `compaction` param or a signed compaction block exactly once, whether or not
+    the client sent it, and survives the Vertex beta filter."""
+    headers: Final = _validate_vertex_headers(client_headers, messages, optional_params)
+
+    filtered: Final = update_headers_with_filtered_beta(headers=headers, provider="vertex_ai")
+
+    assert filtered["anthropic-beta"].split(",").count("compact-2026-09-04") == 1
+
+
+def test_no_compaction_signal_leaves_compact_2026_09_04_beta_out() -> None:
+    headers: Final = _validate_vertex_headers({}, [{"role": "user", "content": "Hello"}])
+
+    assert "compact-2026-09-04" not in headers.get("anthropic-beta", "")
+
+
+_VERTEX_MESSAGE_RESPONSE: Final = {
+    "id": "msg_vrtx_test",
+    "type": "message",
+    "role": "assistant",
+    "model": "claude-sonnet-4-6",
+    "content": [{"type": "text", "text": "pong"}],
+    "stop_reason": "end_turn",
+    "stop_sequence": None,
+    "usage": {"input_tokens": 5, "output_tokens": 1},
+}
+
+
+@pytest.mark.asyncio
+async def test_vertex_messages_request_sends_compact_2026_09_04_beta_on_the_wire(
+    local_beta_headers_config: None,
+) -> None:
+    """A /v1/messages compaction request to a Vertex Claude deployment reaches Vertex with the beta in the
+    anthropic-beta request header and never in the body, the shape Vertex accepts (live, 2026-10-05)."""
+    mock_response: Final = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = json.dumps(_VERTEX_MESSAGE_RESPONSE)
+    mock_response.headers = httpx.Headers({})
+    mock_response.json.return_value = _VERTEX_MESSAGE_RESPONSE
+
+    client: Final = MagicMock(spec=AsyncHTTPHandler)
+    client.post = AsyncMock(return_value=mock_response)
+
+    with patch(
+        "litellm.llms.vertex_ai.vertex_llm_base.VertexBase._ensure_access_token_async",
+        AsyncMock(return_value=("token", "test-project")),
+    ):
+        await litellm.anthropic.messages.acreate(
+            model="vertex_ai/claude-sonnet-4-6",
+            max_tokens=64,
+            messages=[{"role": "user", "content": "Reply with the single word: pong"}],
+            compaction={"type": "summarize"},
+            vertex_project="test-project",
+            vertex_location="us-east5",
+            client=client,
+        )
+
+    sent: Final = client.post.call_args.kwargs
+    sent_body: Final = sent["json"] if "json" in sent else json.loads(sent["data"])
+    assert sent["headers"]["anthropic-beta"].split(",").count("compact-2026-09-04") == 1
+    assert sent_body["compaction"] == {"type": "summarize"}
+    assert "anthropic_beta" not in sent_body
+
+
+@pytest.mark.usefixtures("local_model_cost_map", "local_beta_headers_config")
+@pytest.mark.parametrize("feature", ("thinking", "output_config", "tool_addition", "tool_removal", "none"))
+@pytest.mark.parametrize("explicit_beta", (False, True))
+def test_messages_feature_beta_headers(feature: str, explicit_beta: bool) -> None:
+    from typing import Final
+    from unittest.mock import patch
+
+    from google.oauth2.credentials import Credentials
+
+    from litellm.anthropic_beta_headers_manager import update_headers_with_filtered_beta
+    from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.messages.transformation import (
+        VertexAIPartnerModelsAnthropicMessagesConfig,
+    )
+    from litellm.types.llms.anthropic import (
+        ANTHROPIC_BETA_HEADER_VALUES,
+        ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER,
+        ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER,
+    )
+
+    beta: Final = (
+        ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+        if feature == "thinking"
+        else ANTHROPIC_BETA_HEADER_VALUES.PER_TURN_CONTROL_2026_07_01.value
+        if feature == "output_config"
+        else ANTHROPIC_MID_CONVERSATION_TOOL_CHANGES_BETA_HEADER
+    )
+    message: Final = (
+        {"role": "system", "content": [], "output_config": {"effort": "high"}}
+        if feature == "output_config"
+        else {"role": "system", "content": [{"type": feature, "tool": {"type": "tool_reference", "name": "ping"}}]}
+        if feature in ("tool_addition", "tool_removal")
+        else {"role": "user", "content": "Reply with OK"}
+    )
+    with patch(
+        "google.auth.default",
+        return_value=(MagicMock(spec=Credentials, token="test-token", expired=False), "test-project"),
+    ):
+        headers, _ = VertexAIPartnerModelsAnthropicMessagesConfig().validate_anthropic_messages_environment(
+            headers={"anthropic-beta": f"existing-beta,{beta}" if explicit_beta else "existing-beta"},
+            model="claude-fable-5-1",
+            messages=[{"role": "user", "content": "Hello"}, message],
+            optional_params={"thinking": {"type": "adaptive", "display": "updates"}} if feature == "thinking" else {},
+            litellm_params={"vertex_ai_project": "test-project", "vertex_ai_location": "us-east5"},
+            api_key="test-key",
+            api_base="https://example.com/anthropic",
+        )
+
+    betas: Final = headers["anthropic-beta"].split(",")
+    assert betas.count(beta) == int(feature != "none" or explicit_beta)
+    assert betas.count("existing-beta") == 1
+
+    if feature in ("tool_addition", "tool_removal"):
+        filtered_headers: Final = update_headers_with_filtered_beta(headers=headers, provider="vertex_ai")
+        assert filtered_headers.get("anthropic-beta", "").split(",").count(beta) == 1
+
+
+@pytest.mark.parametrize("thinking", ("enabled", {"type": "bogus"}, {"type": "adaptive", "display": "future-mode"}))
+def test_beta_detection_preserves_unrecognized_thinking(thinking: object) -> None:
+    from typing import Final
+    from unittest.mock import patch
+
+    from google.oauth2.credentials import Credentials
+
+    from litellm.types.llms.anthropic import ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+
+    params: Final = {"thinking": thinking}
+    with patch(
+        "google.auth.default",
+        return_value=(MagicMock(spec=Credentials, token="test-token", expired=False), "test-project"),
+    ):
+        headers, _ = VertexAIPartnerModelsAnthropicMessagesConfig().validate_anthropic_messages_environment(
+            headers={},
+            model="claude-fable-5-1",
+            messages=[],
+            optional_params=params,
+            litellm_params={"vertex_ai_project": "test-project", "vertex_ai_location": "us-east5"},
+            api_key="test-key",
+            api_base="https://example.com/anthropic",
+        )
+
+    assert params["thinking"] == thinking
+    assert ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER not in headers.get("anthropic-beta", "").split(",")
diff --git a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py
index 3ae208bb3a8..0a582c95749 100644
--- a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py
+++ b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py
@@ -4,7 +4,7 @@ import copy
 import json
 from collections.abc import Mapping
 from typing import Final
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 import httpx
 import pytest
@@ -12,10 +12,12 @@ import respx
 from google.oauth2.credentials import Credentials
 
 import litellm
+from litellm.llms.custom_httpx.http_handler import HTTPHandler
 from litellm.anthropic_beta_headers_manager import (
     update_headers_with_filtered_beta,
     update_request_with_filtered_beta,
 )
+from litellm.llms.anthropic.common_utils import AnthropicError
 from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation import (
     VertexAIAnthropicConfig,
 )
@@ -475,8 +477,10 @@ def test_vertex_ai_anthropic_extra_headers_beta_propagation():
 
 def test_vertex_ai_anthropic_inline_tools_beta_survives_the_chat_beta_filter(local_beta_headers_config: None) -> None:
     """The chat path runs the Vertex beta filter over both the header and the `anthropic_beta` body field right
-    before the request goes out, so inline-tools-2026-09-15 must survive both (source and date in
-    tests/unit/test_anthropic_beta_headers_filtering.py)."""
+    before the request goes out, so inline-tools-2026-09-15 must survive it as the header (source and date in
+    tests/unit/test_anthropic_beta_headers_filtering.py) and stay out of the body field, which Vertex rejects
+    with 400 "Unexpected value(s) `inline-tools-2026-09-15` for the `anthropic_beta` parameter" (live, global,
+    claude-sonnet-5-5, 2026-10-20)."""
     config: Final = VertexAIAnthropicConfig()
     headers: Final[dict[str, str]] = {}
     optional_params: Final[dict[str, object]] = {
@@ -497,7 +501,7 @@ def test_vertex_ai_anthropic_inline_tools_beta_survives_the_chat_beta_filter(loc
     )
 
     assert filtered_headers["anthropic-beta"].split(",").count("inline-tools-2026-09-15") == 1
-    assert "inline-tools-2026-09-15" in filtered_request["anthropic_beta"]
+    assert "inline-tools-2026-09-15" not in filtered_request.get("anthropic_beta", [])
 
 
 def test_vertex_ai_anthropic_extra_headers_beta_merged_with_auto_betas():
@@ -1232,3 +1236,293 @@ def test_refusal_stop_details_kept_through_vertex_anthropic_transform():
     provider_fields: Final = result.choices[0].message.provider_specific_fields
     assert provider_fields["stop_reason"] == "refusal"
     assert provider_fields["stop_details"] == ANTHROPIC_DOCS_REFUSAL_MESSAGE["stop_details"]
+
+
+_SIGNED_COMPACTION_BLOCK: Final = {"type": "compaction", "content": "summary so far", "signature": "sig"}
+_CLEAR_TOOL_USES: Final = {"edits": [{"type": "clear_tool_uses_20250919"}]}
+
+
+def _vertex_request(optional_params: dict[str, object], headers: dict[str, str], litellm_params: dict[str, object] | None = None) -> dict:
+    return VertexAIAnthropicConfig().transform_request(
+        model="claude-opus-4-6",
+        messages=[{"role": "user", "content": "Hello"}],
+        optional_params={"max_tokens": 100, "is_vertex_request": True, **optional_params},
+        litellm_params=litellm_params or {},
+        headers=headers,
+    )
+
+
+@pytest.mark.parametrize(
+    "optional_params,messages",
+    [
+        (
+            {"max_tokens": 100, "is_vertex_request": True, "compaction": {"type": "summarize"}},
+            [{"role": "user", "content": "Hello"}],
+        ),
+        (
+            {"max_tokens": 100, "is_vertex_request": True},
+            [
+                {
+                    "role": "assistant",
+                    "content": "",
+                    "provider_specific_fields": {"compaction_blocks": [_SIGNED_COMPACTION_BLOCK]},
+                },
+                {"role": "user", "content": "Go on"},
+            ],
+        ),
+    ],
+    ids=["compaction_param", "signed_compaction_block_sent_back"],
+)
+def test_vertex_ai_anthropic_native_compaction_adds_compact_2026_09_04_beta(
+    local_beta_headers_config: None, optional_params: dict[str, object], messages: list[dict[str, object]]
+) -> None:
+    """The chat path skips the Anthropic beta injection for Vertex requests, so the Vertex config
+    adds compact-2026-09-04 itself (Google Cloud: beta on
+    https://platform.claude.com/docs/en/build-with-claude/compaction-on-demand, read 2026-10-05)
+    as the HTTP header only, since Vertex answered 400 "Unexpected value(s) `compact-2026-09-04`
+    for the `anthropic_beta` parameter" with the name in the body field (us-east5,
+    claude-sonnet-4-6, 2026-10-05), and the header must survive the Vertex beta filter."""
+    headers: Final[dict[str, str]] = {}
+
+    result: Final = VertexAIAnthropicConfig().transform_request(
+        model="claude-opus-4-6",
+        messages=messages,
+        optional_params=optional_params,
+        litellm_params={},
+        headers=headers,
+    )
+    filtered_headers, filtered_body = update_request_with_filtered_beta(
+        headers=headers, request_data=result, provider="vertex_ai"
+    )
+
+    assert filtered_headers["anthropic-beta"].split(",").count("compact-2026-09-04") == 1
+    assert "compact-2026-09-04" not in filtered_body.get("anthropic_beta", [])
+
+
+def test_vertex_ai_anthropic_no_compaction_signal_leaves_compact_2026_09_04_beta_out() -> None:
+    headers: Final[dict[str, str]] = {}
+
+    result: Final = _vertex_request({}, headers)
+
+    assert "compact-2026-09-04" not in result.get("anthropic_beta", [])
+    assert "compact-2026-09-04" not in headers.get("anthropic-beta", "")
+
+
+def test_vertex_ai_anthropic_client_sent_compact_2026_09_04_stays_out_of_the_body_field(
+    local_beta_headers_config: None,
+) -> None:
+    headers: Final[dict[str, str]] = {}
+
+    result: Final = _vertex_request(
+        {
+            "compaction": {"type": "summarize"},
+            "extra_headers": {"anthropic-beta": "compact-2026-09-04,interleaved-thinking-2025-05-14"},
+        },
+        headers,
+    )
+
+    assert headers["anthropic-beta"].split(",").count("compact-2026-09-04") == 1
+    assert result["anthropic_beta"] == ["interleaved-thinking-2025-05-14"]
+
+
+def test_vertex_ai_anthropic_compaction_keeps_the_betas_the_client_sent_as_headers(
+    local_beta_headers_config: None,
+) -> None:
+    headers: Final = {"anthropic-beta": "context-1m-2025-08-07"}
+
+    result: Final = _vertex_request({"compaction": {"type": "summarize"}}, headers)
+
+    assert sorted(headers["anthropic-beta"].split(",")) == ["compact-2026-09-04", "context-1m-2025-08-07"]
+    assert "anthropic_beta" not in result
+
+
+@pytest.mark.parametrize("header_only_beta", ["compact-2026-09-04", "inline-tools-2026-09-15"])
+def test_vertex_ai_anthropic_client_sent_body_header_only_beta_moves_to_the_header(
+    local_beta_headers_config: None, header_only_beta: str
+) -> None:
+    """Vertex rejects these betas inside the body `anthropic_beta` field with 400 "Unexpected value(s)" and
+    accepts them as the header (live, global, claude-sonnet-5-5, 2026-10-20), so a client that opts in through that field still
+    gets the beta as a header and keeps its other betas in the body."""
+    headers: Final[dict[str, str]] = {}
+
+    result: Final = _vertex_request(
+        {"anthropic_beta": [header_only_beta, "interleaved-thinking-2025-05-14"]}, headers
+    )
+
+    assert headers["anthropic-beta"] == header_only_beta
+    assert result["anthropic_beta"] == ["interleaved-thinking-2025-05-14"]
+
+
+@pytest.mark.parametrize(
+    "client_beta,body,header",
+    [
+        (
+            "context-1m-2025-08-07",
+            ["context-1m-2025-08-07", "context-management-2025-06-27"],
+            "context-management-2025-06-27",
+        ),
+        (
+            "inline-tools-2026-09-15",
+            ["context-management-2025-06-27"],
+            "context-management-2025-06-27,inline-tools-2026-09-15",
+        ),
+    ],
+    ids=["body_beta", "header_only_beta"],
+)
+def test_vertex_ai_anthropic_litellm_betas_merge_with_the_client_body_betas(
+    local_beta_headers_config: None, client_beta: str, body: list[str], header: str
+) -> None:
+    headers: Final[dict[str, str]] = {}
+
+    result: Final = _vertex_request({"context_management": _CLEAR_TOOL_USES, "anthropic_beta": [client_beta]}, headers)
+
+    assert result["anthropic_beta"] == body
+    assert headers["anthropic-beta"] == header
+
+
+@pytest.mark.parametrize(
+    "anthropic_beta",
+    [["interleaved-thinking-2025-05-14"], ("interleaved-thinking-2025-05-14",)],
+    ids=["list", "sdk_tuple"],
+)
+def test_vertex_ai_anthropic_client_sent_body_betas_stay_out_of_the_header(anthropic_beta: object) -> None:
+    headers: Final[dict[str, str]] = {}
+
+    result: Final = _vertex_request({"anthropic_beta": anthropic_beta}, headers)
+
+    assert result["anthropic_beta"] == ["interleaved-thinking-2025-05-14"]
+    assert "anthropic-beta" not in headers
+
+
+_MALFORMED_BETAS: Final = pytest.mark.parametrize(
+    "malformed", [5, [1, 2], {"beta": "x"}], ids=["int", "list_of_ints", "dict"]
+)
+_MALFORMED_BETA_SOURCES: Final = pytest.mark.parametrize(
+    "source,field",
+    [("anthropic_beta", "anthropic_beta"), ("extra_headers", "The anthropic-beta header")],
+    ids=["body_field", "extra_header"],
+)
+
+
+def _malformed_beta_params(source: str, malformed: object) -> dict[str, object]:
+    if source == "extra_headers":
+        return {"extra_headers": {"anthropic-beta": malformed}}
+    return {"anthropic_beta": malformed}
+
+
+@_MALFORMED_BETAS
+@_MALFORMED_BETA_SOURCES
+def test_vertex_ai_anthropic_malformed_anthropic_beta_answers_400_naming_its_field(
+    malformed: object, source: str, field: str
+) -> None:
+    with pytest.raises(AnthropicError) as excinfo:
+        _vertex_request(_malformed_beta_params(source, malformed), {})
+
+    assert excinfo.value.status_code == 400
+    assert excinfo.value.message.startswith(f"{field} must be")
+
+
+@_MALFORMED_BETAS
+@_MALFORMED_BETA_SOURCES
+@pytest.mark.parametrize("auto_beta", [False, True], ids=["alone", "next_to_litellm_beta"])
+def test_vertex_ai_anthropic_malformed_anthropic_beta_is_dropped_under_drop_params(
+    local_beta_headers_config: None, malformed: object, source: str, field: str, auto_beta: bool
+) -> None:
+    headers: Final[dict[str, str]] = {}
+    params: Final = {**_malformed_beta_params(source, malformed), **({"context_management": _CLEAR_TOOL_USES} if auto_beta else {})}
+
+    result: Final = _vertex_request(params, headers, litellm_params={"drop_params": True})
+
+    assert result.get("anthropic_beta") == (["context-management-2025-06-27"] if auto_beta else None)
+    assert headers.get("anthropic-beta") == ("context-management-2025-06-27" if auto_beta else None)
+
+
+_VERTEX_MESSAGE_RESPONSE: Final = {
+    "id": "msg_vrtx_test",
+    "type": "message",
+    "role": "assistant",
+    "model": "claude-sonnet-4-6",
+    "content": [{"type": "text", "text": "pong"}],
+    "stop_reason": "end_turn",
+    "stop_sequence": None,
+    "usage": {"input_tokens": 5, "output_tokens": 1},
+}
+
+
+def test_vertex_ai_anthropic_completion_sends_compact_2026_09_04_beta_on_the_wire(local_beta_headers_config: None) -> None:
+    """A chat completion with `compaction` on a Vertex Claude deployment reaches Vertex with the beta in the
+    anthropic-beta request header and never in the body field, the shape Vertex accepts (live, 2026-10-05)."""
+    mock_response: Final = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = json.dumps(_VERTEX_MESSAGE_RESPONSE)
+    mock_response.headers = {}
+    mock_response.json.return_value = _VERTEX_MESSAGE_RESPONSE
+    client: Final = MagicMock(spec=HTTPHandler)
+    client.post.return_value = mock_response
+
+    with patch(
+        "litellm.llms.vertex_ai.vertex_llm_base.VertexBase._ensure_access_token",
+        return_value=("token", "test-project"),
+    ):
+        litellm.completion(
+            model="vertex_ai/claude-sonnet-4-6",
+            messages=[{"role": "user", "content": "Reply with the single word: pong"}],
+            compaction={"type": "summarize"},
+            vertex_project="test-project",
+            vertex_location="us-east5",
+            client=client,
+        )
+
+    sent: Final = client.post.call_args.kwargs
+    sent_body: Final = sent["json"] if "json" in sent else json.loads(sent["data"])
+    assert sent["headers"]["anthropic-beta"].split(",").count("compact-2026-09-04") == 1
+    assert sent_body["compaction"] == {"type": "summarize"}
+    assert "anthropic_beta" not in sent_body
+
+
+@pytest.mark.usefixtures("local_model_cost_map")
+@pytest.mark.parametrize("thinking_type", ("adaptive", "enabled"))
+@pytest.mark.parametrize("display", ("summarized", "omitted", "updates"))
+def test_chat_preserves_thinking_display_and_beta(thinking_type: str, display: str) -> None:
+    from typing import Final
+
+    from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation import VertexAIAnthropicConfig
+    from litellm.types.llms.anthropic import ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+
+    config: Final = VertexAIAnthropicConfig()
+    optional_params: Final = config.map_openai_params(
+        non_default_params={"thinking": {"type": thinking_type, "display": display, "budget_tokens": 2048}},
+        optional_params={},
+        model="claude-fable-5-1",
+        drop_params=False,
+    )
+    optional_params["extra_headers"] = {"anthropic-beta": "existing-beta"}
+    headers: Final = {}
+    result: Final = config.transform_request(
+        model="claude-fable-5-1",
+        messages=[{"role": "user", "content": "Reply with OK"}],
+        optional_params=optional_params,
+        litellm_params={},
+        headers=headers,
+    )
+
+    assert result["thinking"]["type"] == "adaptive"
+    assert result["thinking"]["display"] == display
+    assert (ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER in headers["anthropic-beta"].split(",")) == (display == "updates")
+    assert "existing-beta" in headers["anthropic-beta"].split(",")
+
+
+@pytest.mark.parametrize("thinking", ("enabled", {"type": "bogus"}, {"type": "adaptive", "display": "future-mode"}))
+def test_beta_detection_preserves_unrecognized_thinking(thinking: object) -> None:
+    from typing import Final
+
+    from litellm.types.llms.anthropic import ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER
+
+    headers: Final = {}
+    result: Final = VertexAIAnthropicConfig().transform_request(
+        model="claude-fable-5-1", messages=[{"role": "user", "content": "Hello"}],
+        optional_params={"thinking": thinking}, litellm_params={}, headers=headers,
+    )
+
+    assert result["thinking"] == thinking
+    assert ANTHROPIC_THINKING_DISPLAY_UPDATES_BETA_HEADER not in headers.get("anthropic-beta", "").split(",")
diff --git a/tests/unit/llms/vertex_ai/vertex_ai_partner_models/count_tokens/test_handler.py b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/count_tokens/test_handler.py
new file mode 100644
index 00000000000..c03f08ab610
--- /dev/null
+++ b/tests/unit/llms/vertex_ai/vertex_ai_partner_models/count_tokens/test_handler.py
@@ -0,0 +1,60 @@
+from typing import Final
+
+import pytest
+
+from litellm.llms.vertex_ai.vertex_ai_partner_models.count_tokens.handler import count_tokens_headers
+
+_HISTORY: Final = ({"role": "user", "content": "Hello"},)
+
+
+@pytest.mark.parametrize(
+    "request_data",
+    [
+        {"messages": [{"role": "assistant", "content": [{"type": "compaction", "content": "so far", "signature": "sig"}]}]},
+        {"messages": list(_HISTORY), "compaction": {"type": "summarize"}},
+    ],
+    ids=["signed_compaction_block", "compaction_param"],
+)
+def test_count_tokens_on_a_compaction_request_sends_the_compact_beta(request_data: dict[str, object]) -> None:
+    assert count_tokens_headers("token", request_data) == {
+        "Authorization": "Bearer token",
+        "anthropic-beta": "compact-2026-09-04",
+    }
+
+
+@pytest.mark.parametrize(
+    "request_data",
+    [
+        {"messages": list(_HISTORY)},
+        {"messages": [{"role": "assistant", "content": [{"type": "compaction", "content": "so far", "signature": ""}]}]},
+    ],
+    ids=["plain", "unsigned_compaction_block"],
+)
+def test_count_tokens_without_compaction_sends_no_beta(request_data: dict[str, object]) -> None:
+    assert count_tokens_headers("token", request_data) == {"Authorization": "Bearer token"}
+
+
+_TOOL_ADDITION: Final = {
+    "role": "system",
+    "content": [{"type": "tool_addition", "tool": {"type": "tool_reference", "name": "ping"}}],
+}
+
+
+@pytest.mark.parametrize(
+    ("request_data", "expected_beta"),
+    [
+        ({"messages": [*_HISTORY, _TOOL_ADDITION]}, "mid-conversation-tool-changes-2026-07-01"),
+        (
+            {"messages": [*_HISTORY, _TOOL_ADDITION], "compaction": {"type": "summarize"}},
+            "compact-2026-09-04,mid-conversation-tool-changes-2026-07-01",
+        ),
+    ],
+    ids=["tool_addition", "tool_addition_with_compaction"],
+)
+def test_count_tokens_on_a_tool_change_request_sends_the_tool_change_beta(
+    request_data: dict[str, object], expected_beta: str
+) -> None:
+    assert count_tokens_headers("token", request_data) == {
+        "Authorization": "Bearer token",
+        "anthropic-beta": expected_beta,
+    }
diff --git a/tests/unit/passthrough/test_main.py b/tests/unit/passthrough/test_main.py
index 78fa83d126b..4997d736d0a 100644
--- a/tests/unit/passthrough/test_main.py
+++ b/tests/unit/passthrough/test_main.py
@@ -51,3 +51,178 @@ async def test_allm_passthrough_route_hosted_vllm_sends_normalized_model(respx_m
     outbound: Final = json.loads(route.calls[0].request.content)
     assert outbound["model"] == "my-deployment"
     assert outbound["messages"] == [{"role": "user", "content": "Hello"}]
+
+
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_hosted_vllm_sends_deployment_api_key(respx_mock: respx.MockRouter) -> None:
+    route: Final = respx_mock.post(f"{_API_BASE}/v1/chat/completions").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint="v1/chat/completions",
+        model="hosted_vllm/my-deployment",
+        api_base=_API_BASE,
+        api_key="sk-upstream",
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert route.calls[0].request.headers["authorization"] == "Bearer sk-upstream"
+    assert "x-api-key" not in route.calls[0].request.headers
+
+
+@pytest.mark.parametrize("endpoint", ["v1/chat/completions", "chat/completions"])
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_hosted_vllm_reaches_v1_paths_under_an_api_base_ending_in_v1(
+    respx_mock: respx.MockRouter, endpoint: str
+) -> None:
+    route: Final = respx_mock.post(f"{_API_BASE}/v1/chat/completions").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint=endpoint,
+        model="hosted_vllm/my-deployment",
+        api_base=f"{_API_BASE}/v1",
+        api_key="sk-upstream",
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert route.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_hosted_vllm_sends_no_auth_for_a_keyless_deployment(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("VLLM_API_KEY", "sk-vllm-route-only")
+    monkeypatch.delenv("HOSTED_VLLM_API_KEY", raising=False)
+    route: Final = respx_mock.post(f"{_API_BASE}/v1/chat/completions").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint="v1/chat/completions",
+        model="hosted_vllm/my-deployment",
+        api_base=_API_BASE,
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert "authorization" not in route.calls[0].request.headers
+    assert "x-api-key" not in route.calls[0].request.headers
+
+
+@pytest.mark.parametrize(
+    ("vllm_api_key", "expected_authorization"),
+    [("sk-vllm-env", "Bearer sk-vllm-env"), ("oidc/env/VLLM_OIDC_TOKEN", "Bearer sk-vllm-oidc")],
+)
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_keyless_hosted_vllm_without_api_base_sends_the_vllm_api_base_key(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, vllm_api_key: str, expected_authorization: str
+) -> None:
+    monkeypatch.setenv("VLLM_API_BASE", _API_BASE)
+    monkeypatch.setenv("VLLM_API_KEY", vllm_api_key)
+    monkeypatch.setenv("VLLM_OIDC_TOKEN", "sk-vllm-oidc")
+    monkeypatch.delenv("HOSTED_VLLM_API_BASE", raising=False)
+    monkeypatch.delenv("HOSTED_VLLM_API_KEY", raising=False)
+    route: Final = respx_mock.post(f"{_API_BASE}/v1/chat/completions").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint="v1/chat/completions",
+        model="hosted_vllm/my-deployment",
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert route.calls[0].request.headers["authorization"] == expected_authorization
+
+
+@pytest.mark.parametrize(
+    ("model_api_base", "vllm_api_base"), [(f"{_API_BASE}/", _API_BASE), (_API_BASE, f"{_API_BASE}/")]
+)
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_keyless_hosted_vllm_matches_the_vllm_api_base_across_a_trailing_slash(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, model_api_base: str, vllm_api_base: str
+) -> None:
+    monkeypatch.setenv("VLLM_API_BASE", vllm_api_base)
+    monkeypatch.setenv("VLLM_API_KEY", "sk-vllm-env")
+    monkeypatch.delenv("HOSTED_VLLM_API_BASE", raising=False)
+    monkeypatch.delenv("HOSTED_VLLM_API_KEY", raising=False)
+    route: Final = respx_mock.post(url__regex=rf"^{_API_BASE}/+v1/chat/completions$").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint="v1/chat/completions",
+        model="hosted_vllm/my-deployment",
+        api_base=model_api_base,
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert route.calls[0].request.headers["authorization"] == "Bearer sk-vllm-env"
+
+
+@pytest.mark.parametrize("vllm_api_key", ["", "oidc/google/audience"])
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_unusable_vllm_api_key_sends_no_authorization_header(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, vllm_api_key: str
+) -> None:
+    monkeypatch.setenv("VLLM_API_BASE", _API_BASE)
+    monkeypatch.setenv("VLLM_API_KEY", vllm_api_key)
+    monkeypatch.delenv("HOSTED_VLLM_API_BASE", raising=False)
+    monkeypatch.delenv("HOSTED_VLLM_API_KEY", raising=False)
+    route: Final = respx_mock.post(f"{_API_BASE}/v1/chat/completions").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint="v1/chat/completions",
+        model="hosted_vllm/my-deployment",
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert "authorization" not in route.calls[0].request.headers
+
+
+@pytest.mark.parametrize(
+    ("api_base", "api_key", "expected_authorization"),
+    [
+        (None, "sk-upstream", "Bearer sk-upstream"),
+        (None, "sk-hosted-env", "Bearer sk-hosted-env"),
+        (_API_BASE, "sk-hosted-env", "Bearer sk-hosted-env"),
+        (None, None, "Bearer sk-hosted-env"),
+    ],
+)
+@pytest.mark.asyncio
+async def test_allm_passthrough_route_hosted_vllm_on_the_vllm_api_base_sends_its_own_resolved_key(
+    respx_mock: respx.MockRouter,
+    monkeypatch: pytest.MonkeyPatch,
+    api_base: str | None,
+    api_key: str | None,
+    expected_authorization: str,
+) -> None:
+    monkeypatch.setenv("VLLM_API_BASE", _API_BASE)
+    monkeypatch.setenv("VLLM_API_KEY", "sk-vllm-env")
+    monkeypatch.delenv("HOSTED_VLLM_API_BASE", raising=False)
+    monkeypatch.setenv("HOSTED_VLLM_API_KEY", "sk-hosted-env")
+    route: Final = respx_mock.post(f"{_API_BASE}/v1/chat/completions").mock(
+        return_value=httpx.Response(200, json={"ok": True})
+    )
+    response: Final = await allm_passthrough_route(
+        method="POST",
+        endpoint="v1/chat/completions",
+        model="hosted_vllm/my-deployment",
+        api_base=api_base,
+        api_key=api_key,
+        json={"model": "anything", "messages": [{"role": "user", "content": "Hello"}]},
+        client=AsyncHTTPHandler(),
+    )
+    assert response.status_code == 200
+    assert route.calls[0].request.headers["authorization"] == expected_authorization
diff --git a/tests/unit/proxy/auth/test_auth_checks.py b/tests/unit/proxy/auth/test_auth_checks.py
index e783f01769e..9d4fe67614e 100644
--- a/tests/unit/proxy/auth/test_auth_checks.py
+++ b/tests/unit/proxy/auth/test_auth_checks.py
@@ -46,7 +46,7 @@ from litellm.proxy.auth.auth_checks import (
     _team_soft_budget_check,
     common_checks,
 )
-from litellm.proxy.utils import ProxyLogging
+from litellm.proxy.utils import InternalUsageCache, ProxyLogging
 from litellm.proxy.utils import CallInfo
 from litellm.types.passthrough_endpoints.pass_through_endpoints import LITELLM_PASS_THROUGH_ENDPOINT_MARKER
 
@@ -2425,3 +2425,51 @@ async def test_bulk_eviction_clears_the_redis_copies_before_waiting_on_a_wedged_
 
     assert refilled == []
     assert redis.entries == {}
+
+
+class _SignallingPublishRedisClient(_SlowPublishRedisClient):
+    def __init__(self) -> None:
+        super().__init__()
+        self.sent = asyncio.Event()
+
+    async def _send(self, messages: Sequence[str]) -> None:
+        await super()._send(messages)
+        self.sent.set()
+
+
+class _DeleteAfterBroadcastRedisCache(_AuthRedisCache):
+    def __init__(self, broadcast_sent: asyncio.Event) -> None:
+        super().__init__({})
+        self._broadcast_sent = broadcast_sent
+        self.finished = False
+
+    async def delete_cache_keys(self, keys: Sequence[str]) -> None:
+        await self._broadcast_sent.wait()
+        self.finished = True
+
+
+@pytest.mark.asyncio
+async def test_bulk_eviction_broadcasts_while_the_usage_cache_redis_is_wedged(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(pubsub_module, "_in_flight_publishes", asyncio.Semaphore(16))
+    monkeypatch.setattr(pubsub_module, "_pending_publishes", set())
+    client: Final = _SignallingPublishRedisClient()
+    usage_redis: Final = _DeleteAfterBroadcastRedisCache(broadcast_sent=client.sent)
+    proxy_logging_obj: Final = ProxyLogging(user_api_key_cache=None)
+    proxy_logging_obj.internal_usage_cache = InternalUsageCache(
+        dual_cache=DualCache(redis_cache=usage_redis)  # pyright: ignore[reportArgumentType]  # a dict-backed fake of the Redis layer
+    )
+    hashed_tokens: Final = ("token-a", "token-b")
+
+    with patch(
+        "litellm.proxy.common_utils.auth_cache_invalidation_pubsub.coordination_redis_cache",
+        return_value=_PubSubRedisCache(client),
+    ):
+        await delete_cache_key_objects(
+            hashed_tokens=hashed_tokens, user_api_key_cache=UserApiKeyCache(), proxy_logging_obj=proxy_logging_obj
+        )
+        await _drain_publishes()
+
+    assert usage_redis.finished
+    assert {json.loads(message)["cache_key"] for message in client.published} == set(hashed_tokens)
diff --git a/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py b/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py
index 0bdc5f1910a..6b59f6d40dc 100644
--- a/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py
+++ b/tests/unit/proxy/auth/test_auth_checks_object_access_and_lookup.py
@@ -47,6 +47,7 @@ from litellm.proxy.auth.auth_checks import (
     can_object_call_model,
     _can_object_call_vector_stores,
     _check_agent_access_group_model_access,
+    agent_model_grants,
     check_end_user_budget,
     _check_team_member_budget,
     personal_key_owner_teams,
@@ -11294,6 +11295,15 @@ async def test_agent_access_groups_naming_no_model_deny_every_model():
     assert exc_info.value.type == ProxyErrorTypes.agent_model_access_denied
 
 
+@pytest.mark.asyncio
+async def test_agent_model_grants_names_every_model_the_agents_access_groups_allow():
+    agent_key: Final = UserAPIKeyAuth(token="agent-token", agent_id="agent-1", models=[])
+    resolve, asked = _agent_model_ceiling_resolver(frozenset({"gpt-5", "openai/gpt-5.6"}))
+
+    assert await agent_model_grants(agent_key, resolve) == frozenset({"gpt-5", "openai/gpt-5.6"})
+    assert asked == ["agent-1"]
+
+
 @pytest.mark.asyncio
 async def test_agent_without_access_groups_adds_no_model_ceiling():
     agent_key: Final = UserAPIKeyAuth(token="agent-token", agent_id="agent-1", models=["gpt-5", "claude-sonnet"])
diff --git a/tests/unit/proxy/common_utils/test_openai_error_payload.py b/tests/unit/proxy/common_utils/test_openai_error_payload.py
index acefc4c1e2c..d4ab811d505 100644
--- a/tests/unit/proxy/common_utils/test_openai_error_payload.py
+++ b/tests/unit/proxy/common_utils/test_openai_error_payload.py
@@ -111,10 +111,13 @@ def test_the_default_status_stands_when_the_exception_carries_none(default: int)
     assert error_status_code(ValueError("boom"), default) == default
 
 
-@pytest.mark.parametrize("carried_status", [True, False, "429", None, 429.0])
-def test_a_non_int_carried_status_falls_back_to_the_default(carried_status: object):
-    """True is an int in Python but not an HTTP status, and a stringified one would break
-    every caller that compares the code numerically."""
+@pytest.mark.parametrize(
+    "carried_status",
+    [True, False, "slow down", "", None, 429.0, 200, 1301, 0, "200", "1301", "0", "0429", " 429", "\u0664\u0662\u0669", "4" * 5000],
+)
+def test_a_carried_status_that_is_not_an_error_status_falls_back_to_the_default(carried_status: object):
+    """True is an int in Python but not an HTTP status, and answering a 200 or a 1301 either reads
+    as success or makes uvicorn drop the connection."""
 
     class _Carrier(Exception):
         status_code = carried_status
@@ -122,6 +125,22 @@ def test_a_non_int_carried_status_falls_back_to_the_default(carried_status: obje
     assert error_status_code(_Carrier("boom"), 500) == 500
 
 
+def test_a_status_carried_as_a_decimal_string_is_answered_as_that_status():
+    """Provider stream-error chunks pass the vendor's code through as a string ``status_code``,
+    and the shared handler used to answer it as is, so dropping it turned a rate limit into a 500."""
+
+    class _Carrier(Exception):
+        status_code = "429"
+
+    assert error_status_code(_Carrier("slow down"), 500) == 429
+    assert proxy_exception_for(_Carrier("slow down"), default_status_code=500).to_dict() == {
+        "message": "slow down",
+        "type": "rate_limit_error",
+        "param": None,
+        "code": "429",
+    }
+
+
 def test_a_proxy_exception_keeps_the_status_it_was_raised_with():
     """ProxyException stores its status as the string ``code`` rather than ``status_code``,
     so a route tail that rewraps one used to answer a 4xx rejection as a 500."""
@@ -130,8 +149,8 @@ def test_a_proxy_exception_keeps_the_status_it_was_raised_with():
     assert error_status_code(rejection, 500) == 400
 
 
-@pytest.mark.parametrize("carried_code", [None, "None", "", "rate_limited", "4xx", 404])
-def test_a_code_that_is_not_a_decimal_string_falls_back_to_the_default(carried_code: object):
+@pytest.mark.parametrize("carried_code", [None, "None", "", "rate_limited", "4xx", 404, "200", "1301"])
+def test_a_code_that_is_not_a_stringified_error_status_falls_back_to_the_default(carried_code: object):
     """Only ProxyException's stringified status is a status; ``code`` on anything else
     (OpenAI's ``invalid_api_key``, a stray int) says nothing about the HTTP answer."""
 
diff --git a/tests/unit/proxy/credential_endpoints/test_endpoints.py b/tests/unit/proxy/credential_endpoints/test_endpoints.py
index 47dd6d561b3..3d8e92988d9 100644
--- a/tests/unit/proxy/credential_endpoints/test_endpoints.py
+++ b/tests/unit/proxy/credential_endpoints/test_endpoints.py
@@ -3277,6 +3277,23 @@ class TestCredentialDisplayName:
         assert listed["openai-prod"]["credential_values"]["api_key"] != "sk-old"
 
 
+def test_looking_up_a_missing_credential_is_labelled_a_client_error_not_a_gateway_failure(
+    restore_credential_list: None,
+):
+    """Naming a credential that does not exist is the caller's own mistake, and the shared
+    handler used to label every one of these internal_server_error, so an SDK branching on
+    the type read a 404 it can never retry past as a gateway outage and backed off forever."""
+    response: Final = _call_as("GET", "/credentials/by_name/definitely-not-there")
+
+    assert response.status_code == 404, f"lookup answered {response.status_code}: {response.text}"
+    assert response.json()["error"] == {
+        "message": "Credential not found. Got credential name: definitely-not-there",
+        "type": "invalid_request_error",
+        "param": None,
+        "code": "404",
+    }
+
+
 def test_get_credential_by_model_masks_the_deployment_credentials(monkeypatch):
     import asyncio
 
diff --git a/tests/unit/proxy/db/db_transaction_queue/test_redis_update_buffer.py b/tests/unit/proxy/db/db_transaction_queue/test_redis_update_buffer.py
index 24c12e06c9c..65da5630f33 100644
--- a/tests/unit/proxy/db/db_transaction_queue/test_redis_update_buffer.py
+++ b/tests/unit/proxy/db/db_transaction_queue/test_redis_update_buffer.py
@@ -1,10 +1,12 @@
 import json
+import logging
 from datetime import datetime, timezone
 from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
+from litellm._logging import verbose_proxy_logger
 from litellm.constants import REDIS_DAILY_TAG_SPEND_UPDATE_BUFFER_KEY
 from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
 from litellm.proxy._types import DailyTagSpendTransaction
@@ -379,6 +381,104 @@ async def test_org_member_spend_is_summed_across_pods_and_restored_on_rpush_fail
     assert restored_spend["org_member_list_transactions"] == {member_key: 1.5}
 
 
+@pytest.mark.asyncio
+async def test_a_single_parked_batch_with_a_nan_spend_drains_as_zero(
+    redis_update_buffer: RedisUpdateBuffer, mock_redis_cache: AsyncMock
+):
+    mock_redis_cache.async_lpop = AsyncMock(
+        return_value=json.dumps({"key_list_transactions": {"nan-key": float("nan"), "ok-key": 0.5}}, allow_nan=True)
+    )
+
+    drained: Final = await redis_update_buffer.get_all_update_transactions_from_redis_buffer()
+
+    assert drained is not None
+    assert drained["key_list_transactions"] == {"nan-key": 0.0, "ok-key": 0.5}
+
+
+PARKED_DAILY_KEY: Final = "user-1_2025-01-15_api-key-123_gpt-4o_openai_/chat/completions"
+
+
+def _parked_daily_batch(spend: float) -> str:
+    return json.dumps(
+        {
+            PARKED_DAILY_KEY: {
+                "spend": spend,
+                "prompt_tokens": 12,
+                "completion_tokens": 7,
+                "api_requests": 1,
+                "successful_requests": 1,
+                "failed_requests": 0,
+            }
+        },
+        allow_nan=True,
+    )
+
+
+@pytest.mark.asyncio
+async def test_a_nan_spend_parked_by_an_older_version_drains_from_the_pipeline_as_zero(
+    redis_update_buffer: RedisUpdateBuffer, mock_redis_cache: AsyncMock
+):
+    entity_batch: Final = json.dumps({"key_list_transactions": {"hashed-key": float("nan")}}, allow_nan=True)
+    window_batches: Final = tuple(
+        json.dumps(
+            [
+                {
+                    "entity_type": "key",
+                    "entity_id": "hashed-key",
+                    "window_duration": "30d",
+                    "window_start": "2026-08-01T00:00:00.000000",
+                    "spend": spend,
+                    "started_at": None,
+                }
+            ],
+            allow_nan=True,
+        )
+        for spend in (float("nan"), 3.0)
+    )
+    mock_redis_cache.async_lpop_pipeline = AsyncMock(
+        return_value=[
+            [entity_batch],
+            [_parked_daily_batch(float("nan")), _parked_daily_batch(0.0042)],
+            None,
+            None,
+            None,
+            None,
+            list(window_batches),
+        ]
+    )
+
+    (
+        db_spend,
+        daily_user,
+        *_rest,
+        window_spend,
+    ) = await redis_update_buffer.get_all_transactions_from_redis_buffer_pipeline()
+
+    assert db_spend is not None
+    assert db_spend["key_list_transactions"] == {"hashed-key": 0}
+    assert daily_user is not None
+    assert daily_user[PARKED_DAILY_KEY]["spend"] == 0.0042
+    assert daily_user[PARKED_DAILY_KEY]["api_requests"] == 2
+    assert window_spend is not None
+    assert [transaction["spend"] for transaction in window_spend] == [3.0]
+
+
+@pytest.mark.asyncio
+async def test_a_nan_spend_parked_by_an_older_version_drains_from_a_daily_key_as_zero(
+    redis_update_buffer: RedisUpdateBuffer, mock_redis_cache: AsyncMock, caplog: pytest.LogCaptureFixture
+):
+    mock_redis_cache.async_lpop = AsyncMock(
+        return_value=[_parked_daily_batch(float("inf")), _parked_daily_batch(0.0042)]
+    )
+
+    with caplog.at_level(logging.WARNING, logger=verbose_proxy_logger.name):
+        daily_tag: Final = await redis_update_buffer.get_all_daily_tag_spend_update_transactions_from_redis_buffer()
+
+    assert daily_tag is not None
+    assert daily_tag[PARKED_DAILY_KEY]["spend"] == 0.0042
+    assert [record.getMessage() for record in caplog.records if "Infinity" in record.getMessage()] != []
+
+
 @pytest.mark.asyncio
 async def test_get_all_transactions_from_redis_buffer_pipeline_no_redis():
     """When redis_cache is None, should return all Nones"""
@@ -724,6 +824,10 @@ class _ListRedis:
     def __init__(self) -> None:
         self.rows: list[str] = []
 
+    async def async_rpush(self, key: str, values: list[str]) -> int:
+        self.rows.extend(values)
+        return len(self.rows)
+
     async def async_rpush_and_trim(self, key: str, values: list[str], max_len: int) -> int:
         self.rows.extend(values)
         pushed_len = len(self.rows)
@@ -752,6 +856,32 @@ async def test_store_spend_logs_in_redis_drops_oldest_rows_past_the_cap():
     assert await buffer.get_spend_logs_from_redis_buffer(limit=10) == ()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("spend", [float("nan"), float("inf")])
+async def test_a_non_finite_daily_spend_buffered_in_redis_drains_as_zero(spend: float):
+    buffer: Final = RedisUpdateBuffer(redis_cache=_ListRedis())
+    queue: Final = DailySpendUpdateQueue()
+    await queue.add_update(json.loads(_parked_daily_batch(spend)))
+    await queue.add_update(json.loads(_parked_daily_batch(0.0042)))
+
+    await buffer.store_in_memory_daily_tag_spend_updates_in_redis(queue)
+    drained: Final = await buffer.get_all_daily_tag_spend_update_transactions_from_redis_buffer()
+
+    assert drained is not None
+    assert drained[PARKED_DAILY_KEY]["spend"] == 0.0
+    assert drained[PARKED_DAILY_KEY]["api_requests"] == 2
+
+
+@pytest.mark.asyncio
+async def test_a_spend_log_row_parked_with_a_nan_spend_is_read_back_with_zero_spend():
+    buffer: Final = RedisUpdateBuffer(redis_cache=_ListRedis())
+    buffer.should_commit_spend_updates_to_redis = MagicMock(return_value=True)
+
+    assert await buffer.store_spend_logs_in_redis([{"request_id": "nan-row", "spend": float("nan")}]) is True
+
+    assert await buffer.get_spend_logs_from_redis_buffer(limit=10) == ({"request_id": "nan-row", "spend": 0.0},)
+
+
 @pytest.mark.asyncio
 async def test_store_spend_logs_in_redis_reports_failure_without_redis():
     buffer = RedisUpdateBuffer(redis_cache=None)
diff --git a/tests/unit/proxy/db/test_db_spend_update_writer.py b/tests/unit/proxy/db/test_db_spend_update_writer.py
index c3a93fd89be..298b153f621 100644
--- a/tests/unit/proxy/db/test_db_spend_update_writer.py
+++ b/tests/unit/proxy/db/test_db_spend_update_writer.py
@@ -2226,6 +2226,60 @@ async def test_shutdown_drain_finishes_the_rollups_update_database_started():
     assert (team_row["api_requests"], team_row["spend"]) == (1, 0.1)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("response_cost", [float("nan"), float("inf"), float("-inf")])
+async def test_update_database_records_a_non_finite_response_cost_as_zero(response_cost: float) -> None:
+    db_writer: Final = DBSpendUpdateWriter()
+    prisma: Final = _tool_usage_prisma()
+    prisma.get_request_status = MagicMock(return_value="success")
+    response: Final = litellm.ModelResponse(
+        model="gpt-5.6-luna",
+        usage=litellm.Usage(prompt_tokens=10, completion_tokens=5, total_tokens=15),
+    )
+    with (
+        patch("litellm.proxy.proxy_server.disable_spend_logs", False),
+        patch("litellm.proxy.proxy_server.prisma_client", prisma),
+        patch("litellm.proxy.proxy_server.user_api_key_cache", MagicMock()),
+        patch("litellm.proxy.proxy_server.litellm_proxy_budget_name", "test-budget"),
+    ):
+        await db_writer.update_database(
+            token="test-token",
+            user_id="test-user",
+            end_user_id=None,
+            team_id="test-team",
+            org_id=None,
+            kwargs={
+                "model": "gpt-5.6-luna",
+                "custom_llm_provider": "openai",
+                "call_type": "acompletion",
+                "litellm_call_id": "req-non-finite-cost",
+                "response_cost": response_cost,
+                "litellm_params": {"metadata": {"user_api_key": "hashed-key", "user_api_key_team_id": "test-team"}},
+            },
+            completion_response=response,
+            start_time=datetime.now(timezone.utc),
+            end_time=datetime.now(timezone.utc),
+            response_cost=response_cost,
+        )
+        await drain_logging_tasks()
+
+    assert [row["spend"] for row in prisma.spend_log_transactions] == [0]
+    spend: Final = await db_writer.spend_update_queue.flush_and_get_aggregated_db_spend_update_transactions()
+    assert spend["key_list_transactions"] == {"test-token": 0}
+    assert spend["team_list_transactions"] == {"test-team": 0}
+    daily_user: Final = (
+        await db_writer.daily_spend_update_queue.flush_and_get_aggregated_daily_spend_update_transactions()
+    )
+    daily_team: Final = (
+        await db_writer.daily_team_spend_update_queue.flush_and_get_aggregated_daily_spend_update_transactions()
+    )
+    assert daily_user is not None and daily_team is not None
+    (user_row,) = daily_user.values()
+    (team_row,) = daily_team.values()
+    assert (user_row["api_requests"], user_row["spend"]) == (1, 0)
+    assert (team_row["api_requests"], team_row["spend"]) == (1, 0)
+
+
 @pytest.mark.asyncio
 async def test_shutdown_drain_waits_for_an_in_flight_rollup_enqueue():
     """
diff --git a/tests/unit/proxy/guardrails/test_guardrail_endpoints.py b/tests/unit/proxy/guardrails/test_guardrail_endpoints.py
index 6807a4fb569..7d912478877 100644
--- a/tests/unit/proxy/guardrails/test_guardrail_endpoints.py
+++ b/tests/unit/proxy/guardrails/test_guardrail_endpoints.py
@@ -13,7 +13,7 @@ import yaml
 from fastapi import HTTPException
 
 from litellm.integrations.custom_guardrail import CustomGuardrail
-from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
+from litellm.proxy._types import LitellmUserRoles, ProxyException, UserAPIKeyAuth
 from litellm.proxy.guardrails.guardrail_endpoints import (
     CreateGuardrailRequest,
     ListGuardrailsResponse,
@@ -2198,6 +2198,39 @@ def _patch_apply_guardrail_env(mocker, guardrail_result):
     return mock_guardrail
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("vendor_status", "expected_type"),
+    [(401, "authentication_error"), (403, "permission_error")],
+)
+async def test_a_guardrail_vendors_rejection_is_labelled_the_way_chat_labels_it(
+    mocker, vendor_status: int, expected_type: str
+):
+    """A vendor refusing the guardrail's own credentials is not the caller's key being rejected,
+    so it must not read as the proxy's auth_error the way a 401 the proxy raises does."""
+    mock_guardrail: Final = _patch_apply_guardrail_env(mocker, None)
+    mock_guardrail.apply_guardrail.side_effect = HTTPException(
+        status_code=vendor_status, detail="vendor refused the request"
+    )
+    mocker.patch(
+        "litellm.proxy.proxy_server.proxy_logging_obj.post_call_failure_hook", AsyncMock(return_value=None)
+    )
+
+    with pytest.raises(ProxyException) as raised:
+        await apply_guardrail(
+            fastapi_request=mocker.Mock(),
+            request=ApplyGuardrailRequest(guardrail_name="test-guardrail", text="hello"),
+            user_api_key_dict=UserAPIKeyAuth(),
+        )
+
+    assert raised.value.to_dict() == {
+        "message": "vendor refused the request",
+        "type": expected_type,
+        "param": None,
+        "code": str(vendor_status),
+    }
+
+
 @pytest.mark.asyncio
 async def test_apply_guardrail_forwards_metadata_to_guardrail(mocker):
     """Client-supplied metadata must reach apply_guardrail via request_data so
diff --git a/tests/unit/proxy/health_endpoints/test_health_endpoints.py b/tests/unit/proxy/health_endpoints/test_health_endpoints.py
index 9847787efce..2258eb95fb8 100644
--- a/tests/unit/proxy/health_endpoints/test_health_endpoints.py
+++ b/tests/unit/proxy/health_endpoints/test_health_endpoints.py
@@ -1,8 +1,9 @@
 import asyncio
 import copy
+import itertools
 import json
 import time
-from collections.abc import Awaitable, Iterator, Mapping, Sequence
+from collections.abc import Awaitable, Callable, Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from datetime import datetime, timedelta
 from importlib import import_module
@@ -22,7 +23,7 @@ import litellm
 import litellm.proxy.health_endpoints._health_endpoints as _health_endpoints_module
 from litellm.litellm_core_utils.health_check_helpers import TEST_IMAGE_BASE64
 from litellm.models.credentials import CredentialItem
-from litellm.proxy._types import LitellmUserRoles, ProxyException, UserAPIKeyAuth
+from litellm.proxy._types import LiteLLM_UserTable, LitellmUserRoles, ProxyErrorTypes, ProxyException, UserAPIKeyAuth
 from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
 from litellm.proxy.health_endpoints._health_endpoints import (
     _db_health_readiness_check,
@@ -35,6 +36,7 @@ from litellm.proxy.health_endpoints._health_endpoints import (
     test_model_connection as health_test_model_connection,
 )
 from litellm.router import Router
+from litellm.types.router import RouterModelGroupAliasItem
 from litellm.types.utils import oauth_token_exchange_litellm_params
 from litellm.types.workload_identity import (
     ANTHROPIC_WIF_KWARGS_KEYS,
@@ -925,7 +927,11 @@ async def test_test_model_connection_stored_audio_base_model_follows_the_stored_
     deployment: Final = MappingProxyType(
         {
             "model_name": "custom-name-audio",
-            "litellm_params": {**deployment_params, "api_key": "fake-azure-key", "api_base": "https://x.openai.azure.com"},
+            "litellm_params": {
+                **deployment_params,
+                "api_key": "fake-azure-key",
+                "api_base": "https://x.openai.azure.com",
+            },
             "model_info": deployment_model_info,
         }
     )
@@ -1948,7 +1954,6 @@ def test_health_liveness_endpoint(proxy_client):
     assert duration_ms < 100, f"Health check took {duration_ms:.2f}ms, expected < 100ms for a simple endpoint"
 
 
-
 def test_proxy_client_serves_full_proxy_routes_after_gateway_import(monkeypatch: pytest.MonkeyPatch) -> None:
     from litellm.proxy.proxy_server import app
 
@@ -2472,6 +2477,7 @@ def _proxy_health_globals(
     llm_router: object,
     use_background_health_checks: bool = False,
     health_check_results: Mapping[str, object] | None = None,
+    prisma_client: object = None,
 ) -> Iterator[None]:
     with (
         patch(  # test-quality-ok: proxy module global, no injection seam
@@ -2481,7 +2487,7 @@ def _proxy_health_globals(
             "litellm.proxy.proxy_server.llm_router", llm_router
         ),
         patch(  # test-quality-ok: proxy module global, no injection seam
-            "litellm.proxy.proxy_server.prisma_client", None
+            "litellm.proxy.proxy_server.prisma_client", prisma_client
         ),
         patch(  # test-quality-ok: proxy module global, no injection seam
             "litellm.proxy.proxy_server.use_background_health_checks", use_background_health_checks
@@ -3812,7 +3818,11 @@ def test_clean_endpoint_data_never_displays_credential_fields(credential_field,
 
 
 async def _live_probed_model_ids(
-    model_list: Sequence[Mapping[str, object]], user_api_key_dict: UserAPIKeyAuth, model: str | None = None
+    model_list: Sequence[Mapping[str, object]],
+    user_api_key_dict: UserAPIKeyAuth,
+    model: str | None = None,
+    llm_router: Router | None = None,
+    prisma_client: object = None,
 ) -> set[str]:
     from fastapi import Response
 
@@ -3825,7 +3835,7 @@ async def _live_probed_model_ids(
         return {"healthy_endpoints": [], "unhealthy_endpoints": [], "healthy_count": 0, "unhealthy_count": 0}
 
     with (
-        _proxy_health_globals(model_list, _router_for(model_list)),
+        _proxy_health_globals(model_list, llm_router or _router_for(model_list), prisma_client=prisma_client),
         patch(  # test-quality-ok: the model list handed to the probe is the assertion; no injection seam
             "litellm.proxy.health_endpoints._health_endpoints._perform_health_check_and_save",
             side_effect=fake_perform,
@@ -4120,6 +4130,7 @@ async def _live_narrowed_model_ids(
     user_api_key_dict: UserAPIKeyAuth,
     model: str | None = None,
     model_id: str | None = None,
+    llm_router: Router | None = None,
 ) -> set[str]:
     from fastapi import Response
 
@@ -4130,7 +4141,7 @@ async def _live_narrowed_model_ids(
         return probed, [], {}
 
     with (
-        _proxy_health_globals(model_list, _router_for(model_list)),
+        _proxy_health_globals(model_list, llm_router or _router_for(model_list)),
         patch(  # test-quality-ok: the probe is the provider edge; which deployments reach it is the assertion
             "litellm.proxy.health_check._perform_health_check", side_effect=fake_probe
         ),
@@ -4289,6 +4300,699 @@ async def test_health_endpoint_keeps_a_team_only_public_name_off_a_team_less_key
     probe.assert_not_awaited()
 
 
+_PROVIDER_PREFIXED_MODEL_LIST: Final = [
+    {
+        "model_name": "openai/gpt-5.4-nano",
+        "litellm_params": {"model": "openai/gpt-5.4-nano"},
+        "model_info": {"id": "id-prefixed-nano"},
+    },
+    {
+        "model_name": "gpt-5.4-mini",
+        "litellm_params": {"model": "openai/gpt-5.4-mini"},
+        "model_info": {"id": "id-mini"},
+    },
+    {
+        "model_name": "claude-haiku-5-5",
+        "litellm_params": {"model": "anthropic/claude-haiku-5-5"},
+        "model_info": {"id": "id-haiku"},
+    },
+]
+_PROVIDER_PREFIXED_CACHED_RESULTS: Final = {
+    "healthy_endpoints": [
+        {"model": "openai/gpt-5.4-nano", "model_id": "id-prefixed-nano"},
+        {"model": "openai/gpt-5.4-mini", "model_id": "id-mini"},
+        {"model": "anthropic/claude-haiku-5-5", "model_id": "id-haiku"},
+    ],
+    "unhealthy_endpoints": [],
+    "healthy_count": 3,
+    "unhealthy_count": 0,
+}
+_PROVIDER_WILDCARD_KEY: Final = UserAPIKeyAuth(api_key="hashed-test-key", models=["openai/*"])
+_RESTRICTED_TEAM_KEY: Final = UserAPIKeyAuth(
+    api_key="hashed-test-key", models=[], team_id="team-a", team_models=["gpt-5.4-mini"]
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("caller", "expected_ids"),
+    [(_PROVIDER_WILDCARD_KEY, {"id-prefixed-nano", "id-mini"}), (_RESTRICTED_TEAM_KEY, {"id-mini"})],
+)
+async def test_health_endpoint_probes_the_deployments_auth_lets_the_key_request(
+    caller: UserAPIKeyAuth, expected_ids: set[str]
+):
+    probed: Final = await _live_probed_model_ids(_PROVIDER_PREFIXED_MODEL_LIST, caller)
+
+    assert probed == expected_ids
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("caller", "expected_ids"),
+    [(_PROVIDER_WILDCARD_KEY, ["id-prefixed-nano", "id-mini"]), (_RESTRICTED_TEAM_KEY, ["id-mini"])],
+)
+async def test_health_endpoint_returns_the_deployments_auth_lets_the_key_request_on_background_cache_path(
+    caller: UserAPIKeyAuth, expected_ids: list[str]
+):
+    from fastapi import Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    with _proxy_health_globals(
+        _PROVIDER_PREFIXED_MODEL_LIST,
+        _router_for(_PROVIDER_PREFIXED_MODEL_LIST),
+        use_background_health_checks=True,
+        health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
+    ):
+        result: Final = await health_endpoint(response=Response(), user_api_key_dict=caller, model=None, model_id=None)
+
+    assert [ep["model_id"] for ep in result["healthy_endpoints"]] == expected_ids
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("use_background_health_checks", [False, True])
+async def test_health_endpoint_refuses_a_deployment_the_team_allowlist_forbids(use_background_health_checks: bool):
+    from fastapi import HTTPException, Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    with (
+        _proxy_health_globals(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            _router_for(_PROVIDER_PREFIXED_MODEL_LIST),
+            use_background_health_checks=use_background_health_checks,
+            health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
+        ),
+        patch(  # test-quality-ok: the probe must never run; the endpoint has no injection seam for it
+            "litellm.proxy.health_endpoints._health_endpoints._perform_health_check_and_save", new_callable=AsyncMock
+        ) as probe,
+        pytest.raises(HTTPException) as refused,
+    ):
+        await health_endpoint(
+            response=Response(), user_api_key_dict=_RESTRICTED_TEAM_KEY, model=None, model_id="id-prefixed-nano"
+        )
+
+    assert refused.value.status_code == 403
+    probe.assert_not_awaited()
+
+
+_KEY_ALIASED_AWAY_FROM_HAIKU: Final = UserAPIKeyAuth(
+    api_key="hashed-test-key", models=["gpt-5.4-mini"], aliases={"claude-haiku-5-5": "gpt-5.4-mini"}
+)
+_TEAM_ALIASED_AWAY_FROM_HAIKU: Final = UserAPIKeyAuth(
+    api_key="hashed-test-key",
+    models=["claude-haiku-5-5"],
+    team_id="team-a",
+    team_model_aliases={"claude-haiku-5-5": "gpt-5.4-mini"},
+)
+_MINI_ONLY_KEY: Final = UserAPIKeyAuth(api_key="hashed-test-key", models=["gpt-5.4-mini"])
+_ALIAS_SHADOW_CASES: Final = [
+    pytest.param(_KEY_ALIASED_AWAY_FROM_HAIKU, {}, id="key-alias"),
+    pytest.param(_TEAM_ALIASED_AWAY_FROM_HAIKU, {}, id="team-alias"),
+    pytest.param(_MINI_ONLY_KEY, {"claude-haiku-5-5": "gpt-5.4-mini"}, id="router-alias"),
+]
+
+
+def _router_with_aliases(model_group_alias: Mapping[str, str]) -> Router:
+    return Router(model_list=copy.deepcopy(_PROVIDER_PREFIXED_MODEL_LIST), model_group_alias=dict(model_group_alias))
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
+async def test_health_endpoint_probes_the_deployment_an_alias_sends_the_key_to_not_the_one_it_shadows(
+    caller: UserAPIKeyAuth, model_group_alias: Mapping[str, str]
+):
+    probed: Final = await _live_probed_model_ids(
+        _PROVIDER_PREFIXED_MODEL_LIST, caller, llm_router=_router_with_aliases(model_group_alias)
+    )
+
+    assert probed == {"id-mini"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
+async def test_health_endpoint_returns_the_deployment_an_alias_sends_the_key_to_on_background_cache_path(
+    caller: UserAPIKeyAuth, model_group_alias: Mapping[str, str]
+):
+    from fastapi import Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    with _proxy_health_globals(
+        _PROVIDER_PREFIXED_MODEL_LIST,
+        _router_with_aliases(model_group_alias),
+        use_background_health_checks=True,
+        health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
+    ):
+        result: Final = await health_endpoint(response=Response(), user_api_key_dict=caller, model=None, model_id=None)
+
+    assert [ep["model_id"] for ep in result["healthy_endpoints"]] == ["id-mini"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("use_background_health_checks", [False, True])
+async def test_health_endpoint_refuses_the_deployment_a_key_alias_shadows(use_background_health_checks: bool):
+    from fastapi import HTTPException, Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    with (
+        _proxy_health_globals(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            _router_for(_PROVIDER_PREFIXED_MODEL_LIST),
+            use_background_health_checks=use_background_health_checks,
+            health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
+        ),
+        patch(  # test-quality-ok: the probe must never run; the endpoint has no injection seam for it
+            "litellm.proxy.health_endpoints._health_endpoints._perform_health_check_and_save", new_callable=AsyncMock
+        ) as probe,
+        pytest.raises(HTTPException) as refused,
+    ):
+        await health_endpoint(
+            response=Response(), user_api_key_dict=_KEY_ALIASED_AWAY_FROM_HAIKU, model=None, model_id="id-haiku"
+        )
+
+    assert refused.value.status_code == 403
+    probe.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
+async def test_health_endpoint_targets_the_deployment_an_alias_name_sends_the_key_to(
+    caller: UserAPIKeyAuth, model_group_alias: Mapping[str, str]
+):
+    probed: Final = await _live_narrowed_model_ids(
+        _PROVIDER_PREFIXED_MODEL_LIST,
+        caller,
+        model="claude-haiku-5-5",
+        llm_router=_router_with_aliases(model_group_alias),
+    )
+
+    assert probed == {"id-mini"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
+async def test_health_endpoint_records_an_alias_check_under_the_name_the_caller_asked_for(
+    caller: UserAPIKeyAuth, model_group_alias: Mapping[str, str]
+):
+    from fastapi import Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    async def fake_probe(model_list, details=True, max_concurrency=None, instrumentation_context=None):
+        return [{"model": m["litellm_params"]["model"], "model_id": m["model_info"]["id"]} for m in model_list], [], {}
+
+    with (
+        _proxy_health_globals(
+            _PROVIDER_PREFIXED_MODEL_LIST, _router_with_aliases(model_group_alias), prisma_client=MagicMock()
+        ),
+        patch(  # test-quality-ok: the probe is the provider edge; the endpoint has no injection seam for it
+            "litellm.proxy.health_check._perform_health_check", side_effect=fake_probe
+        ),
+        patch(  # test-quality-ok: the history row is the assertion; the endpoint has no injection seam for its writer
+            "litellm.proxy.health_endpoints._health_endpoints._save_health_check_to_db", new_callable=AsyncMock
+        ) as save,
+    ):
+        result: Final = await health_endpoint(
+            response=Response(), user_api_key_dict=caller, model="claude-haiku-5-5", model_id=None
+        )
+
+    assert [ep["model_id"] for ep in result["healthy_endpoints"]] == ["id-mini"]
+    assert save.call_args.args[1] == "claude-haiku-5-5"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("caller", "model_group_alias"), _ALIAS_SHADOW_CASES)
+async def test_health_endpoint_targets_the_deployment_an_alias_name_sends_the_key_to_on_background_cache_path(
+    caller: UserAPIKeyAuth, model_group_alias: Mapping[str, str]
+):
+    from fastapi import Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    with _proxy_health_globals(
+        _PROVIDER_PREFIXED_MODEL_LIST,
+        _router_with_aliases(model_group_alias),
+        use_background_health_checks=True,
+        health_check_results=_PROVIDER_PREFIXED_CACHED_RESULTS,
+    ):
+        result: Final = await health_endpoint(
+            response=Response(), user_api_key_dict=caller, model="claude-haiku-5-5", model_id=None
+        )
+
+    assert [ep["model_id"] for ep in result["healthy_endpoints"]] == ["id-mini"]
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_never_probes_a_deployment_without_a_model_name_for_a_restricted_key():
+    nameless_deployment: Final = {
+        "litellm_params": {"model": "openai/gpt-5.4-mini"},
+        "model_info": {"id": "id-nameless"},
+    }
+
+    probed: Final = await _live_probed_model_ids(
+        [*_PROVIDER_PREFIXED_MODEL_LIST, nameless_deployment],
+        _MINI_ONLY_KEY,
+        llm_router=_router_for(_PROVIDER_PREFIXED_MODEL_LIST),
+    )
+
+    assert probed == {"id-mini"}
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_never_probes_the_deployment_a_keys_router_alias_sends_it_to_but_forbids():
+    caller: Final = UserAPIKeyAuth(
+        api_key="hashed-test-key",
+        models=["gpt-5.4-mini", "openai/gpt-5.4-nano"],
+        router_settings={"model_group_alias": {"gpt-5.4-mini": "claude-haiku-5-5"}},
+    )
+
+    probed: Final = await _live_probed_model_ids(_PROVIDER_PREFIXED_MODEL_LIST, caller)
+
+    assert probed == {"id-prefixed-nano"}
+
+
+_WILDCARD_DEPLOYMENT: Final = {
+    "model_name": "openai/*",
+    "litellm_params": {"model": "openai/*"},
+    "model_info": {"id": "id-wild"},
+}
+_CATCH_ALL_DEPLOYMENT: Final = {"model_name": "*", "litellm_params": {"model": "*"}, "model_info": {"id": "id-star"}}
+_TEAM_WILDCARD_DEPLOYMENT: Final = {
+    "model_name": "openai-wild_team-a_7c1e",
+    "litellm_params": {"model": "openai/*"},
+    "model_info": {"id": "id-team-wild", "team_id": "team-a", "team_public_model_name": "openai/*"},
+}
+
+
+def _team_key(team_models: list[str], team_model_aliases: Mapping[str, str] | None = None) -> UserAPIKeyAuth:
+    return UserAPIKeyAuth(
+        api_key="hashed-test-key",
+        models=[],
+        team_id="team-a",
+        team_models=team_models,
+        team_model_aliases=dict(team_model_aliases) if team_model_aliases is not None else None,
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("model_list", "model_group_alias", "caller", "expected_ids"),
+    [
+        pytest.param(
+            [_WILDCARD_DEPLOYMENT, _PROVIDER_PREFIXED_MODEL_LIST[2]],
+            {},
+            _team_key(["openai/gpt-5.4-nano"]),
+            {"id-wild"},
+            id="team-name-served-by-provider-wildcard",
+        ),
+        pytest.param(
+            [_TEAM_WILDCARD_DEPLOYMENT, _PROVIDER_PREFIXED_MODEL_LIST[2]],
+            {},
+            _team_key(["openai/gpt-5.4-nano"]),
+            {"id-team-wild"},
+            id="team-name-served-by-teams-own-wildcard",
+        ),
+        pytest.param(
+            [_CATCH_ALL_DEPLOYMENT],
+            {},
+            _team_key(["gpt-5.4-mini"]),
+            {"id-star"},
+            id="team-name-served-by-catch-all",
+        ),
+        pytest.param(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            {"gpt-4": "gpt-5.4-mini"},
+            _team_key(["gpt-4"]),
+            {"id-mini"},
+            id="team-allows-router-alias",
+        ),
+        pytest.param(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            {},
+            _team_key(["my-alias"], {"my-alias": "gpt-5.4-mini"}),
+            {"id-mini"},
+            id="team-allows-team-alias",
+        ),
+        pytest.param(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            {"friendly-mini": RouterModelGroupAliasItem(model="gpt-5.4-mini", hidden=True)},
+            UserAPIKeyAuth(api_key="hashed-test-key", models=["friendly-*"]),
+            {"id-mini"},
+            id="wildcard-key-allows-hidden-router-alias",
+        ),
+        pytest.param(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            {},
+            _team_key(["friendly-*"], {"friendly-mini": "gpt-5.4-mini"}),
+            {"id-mini"},
+            id="wildcard-team-allows-team-alias",
+        ),
+        pytest.param(
+            _PROVIDER_PREFIXED_MODEL_LIST,
+            {"claude-haiku-5-5": "gpt-5.4-mini"},
+            UserAPIKeyAuth(api_key="hashed-test-key", models=[]),
+            {"id-prefixed-nano", "id-mini", "id-haiku"},
+            id="unrestricted-key-calls-shadowed-deployment-by-id",
+        ),
+    ],
+)
+async def test_health_endpoint_probes_every_deployment_the_callers_allowed_names_route_to(
+    model_list: Sequence[Mapping[str, object]],
+    model_group_alias: Mapping[str, str | RouterModelGroupAliasItem],
+    caller: UserAPIKeyAuth,
+    expected_ids: set[str],
+):
+    llm_router: Final = Router(
+        model_list=copy.deepcopy([dict(deployment) for deployment in model_list]),
+        model_group_alias=dict(model_group_alias),
+    )
+
+    probed: Final = await _live_probed_model_ids(llm_router.get_model_list() or [], caller, llm_router=llm_router)
+
+    assert probed == expected_ids
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "caller",
+    [
+        pytest.param(
+            UserAPIKeyAuth(api_key="hashed-test-key", models=["gpt-5.4-mini", "gpt-4-retired"]), id="key-grant"
+        ),
+        pytest.param(_team_key(["gpt-5.4-mini", "gpt-4-retired"]), id="team-grant"),
+    ],
+)
+async def test_health_endpoint_never_probes_the_default_fallback_for_a_granted_name_no_deployment_serves(
+    caller: UserAPIKeyAuth,
+) -> None:
+    llm_router: Final = Router(
+        model_list=copy.deepcopy(_PROVIDER_PREFIXED_MODEL_LIST), default_fallbacks=["claude-haiku-5-5"]
+    )
+
+    probed: Final = await _live_probed_model_ids(_PROVIDER_PREFIXED_MODEL_LIST, caller, llm_router=llm_router)
+
+    assert probed == {"id-mini"}
+
+
+def _personal_key_whose_owner_may_call(models: list[str]) -> UserAPIKeyAuth:
+    from litellm.proxy.proxy_server import user_api_key_cache
+
+    owner_id: Final = "health-scope-owner-" + "-".join(models)
+    user_api_key_cache.set_cache(key=owner_id, value=LiteLLM_UserTable(user_id=owner_id, models=models))
+    return UserAPIKeyAuth(api_key="hashed-test-key", models=[], user_id=owner_id)
+
+
+def _managed_agent_key_granted(models: list[str]) -> UserAPIKeyAuth:
+    from litellm.types.agents import AgentResponse
+
+    policy: Final = AgentResponse(
+        agent_id="managed", agent_name="Managed", agent_card_params={}, object_permission={"models": models}
+    )
+    return UserAPIKeyAuth(api_key="hashed-test-key", models=[]).model_copy(update={"managed_agent_policy": policy})
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("make_caller", "models", "expected_ids"),
+    [
+        pytest.param(_personal_key_whose_owner_may_call, ["gpt-5.4-mini"], {"id-mini"}, id="key-owners-models"),
+        pytest.param(_managed_agent_key_granted, ["gpt-5.4-mini"], {"id-mini"}, id="managed-agents-models"),
+        pytest.param(_managed_agent_key_granted, [], set(), id="managed-agent-without-model-grants"),
+    ],
+)
+async def test_health_endpoint_probes_only_the_models_the_keys_user_or_agent_may_call(
+    make_caller: Callable[[list[str]], UserAPIKeyAuth], models: list[str], expected_ids: set[str]
+):
+    probed: Final = await _live_probed_model_ids(_PROVIDER_PREFIXED_MODEL_LIST, make_caller(models))
+
+    assert probed == expected_ids
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_refuses_a_model_id_the_keys_owner_may_not_call():
+    from fastapi import Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    with (
+        _proxy_health_globals(_PROVIDER_PREFIXED_MODEL_LIST, _router_for(_PROVIDER_PREFIXED_MODEL_LIST)),
+        patch(  # test-quality-ok: the probe must never run; the endpoint has no injection seam for it
+            "litellm.proxy.health_endpoints._health_endpoints._perform_health_check_and_save", new_callable=AsyncMock
+        ) as probe,
+        pytest.raises(HTTPException) as refused,
+    ):
+        await health_endpoint(
+            response=Response(),
+            user_api_key_dict=_personal_key_whose_owner_may_call(["gpt-5.4-mini"]),
+            model=None,
+            model_id="id-prefixed-nano",
+        )
+
+    assert refused.value.status_code == 403
+    probe.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "make_caller",
+    [
+        pytest.param(_personal_key_whose_owner_may_call, id="key-owner"),
+        pytest.param(_managed_agent_key_granted, id="managed-agent"),
+    ],
+)
+async def test_health_endpoint_keeps_the_wildcard_serving_a_name_the_keys_user_or_agent_may_call(
+    make_caller: Callable[[list[str]], UserAPIKeyAuth],
+):
+    model_list: Final = [_WILDCARD_DEPLOYMENT, *_PROVIDER_PREFIXED_MODEL_LIST]
+
+    probed: Final = await _live_probed_model_ids(model_list, make_caller(["openai/gpt-5.6"]))
+
+    assert probed == {"id-wild"}
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_answers_an_agent_key_acting_for_an_unknown_user_the_way_chat_does():
+    from litellm.types.agents import AgentCaller
+
+    users_table: Final = MagicMock()
+    users_table.db.litellm_usertable.find_unique = AsyncMock(return_value=None)
+    agent_key: Final = UserAPIKeyAuth(api_key="hashed-test-key", models=["gpt-5.4-mini"]).model_copy(
+        update={"agent_caller": AgentCaller(user_id="user-deleted-before-this-request")}
+    )
+
+    with pytest.raises(ProxyException) as failed:
+        await _live_probed_model_ids(_PROVIDER_PREFIXED_MODEL_LIST, agent_key, prisma_client=users_table)
+
+    assert (failed.value.code, failed.value.type) == ("401", ProxyErrorTypes.auth_error)
+    assert "user-deleted-before-this-request" in failed.value.message
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_lets_other_requests_run_while_it_scopes_a_large_model_list():
+    model_list: Final = [
+        {"model_name": f"model-{n}", "litellm_params": {"model": f"openai/model-{n}"}, "model_info": {"id": f"id-{n}"}}
+        for n in range(50)
+    ]
+    other_request_turns: Final = itertools.count()
+    scoping_done: Final = asyncio.Event()
+
+    async def scope() -> set[str]:
+        try:
+            return await _live_probed_model_ids(
+                model_list, UserAPIKeyAuth(api_key="hashed-test-key", models=["model-0"])
+            )
+        finally:
+            scoping_done.set()
+
+    async def other_request() -> None:
+        while not scoping_done.is_set():
+            next(other_request_turns)
+            await asyncio.sleep(0)
+
+    probed, _ = await asyncio.gather(scope(), other_request())
+
+    assert probed == {"id-0"}
+    assert next(other_request_turns) >= len(model_list)
+
+
+_WILDCARD_CACHED_RESULTS: Final = {
+    "healthy_endpoints": [
+        {"model": "openai/gpt-5.6", "model_id": "id-wild"},
+        {"model": "openai/gpt-5.6", "model_id": "id-team-wild"},
+        {"model": "anthropic/claude-haiku-5-5", "model_id": "id-haiku"},
+    ],
+    "unhealthy_endpoints": [],
+    "healthy_count": 3,
+    "unhealthy_count": 0,
+}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("use_background_health_checks", [False, True])
+@pytest.mark.parametrize(
+    ("wildcard_deployment", "expected_id"),
+    [
+        pytest.param(_WILDCARD_DEPLOYMENT, "id-wild", id="proxy-wildcard"),
+        pytest.param(_TEAM_WILDCARD_DEPLOYMENT, "id-team-wild", id="teams-own-wildcard"),
+    ],
+)
+async def test_health_endpoint_model_param_reaches_the_wildcard_serving_a_team_allowed_name(
+    wildcard_deployment: Mapping[str, object], expected_id: str, use_background_health_checks: bool
+):
+    from fastapi import Response
+
+    from litellm.proxy.health_endpoints._health_endpoints import health_endpoint
+
+    model_list: Final = [wildcard_deployment, _PROVIDER_PREFIXED_MODEL_LIST[2]]
+
+    async def fake_probe(model_list, details=True, max_concurrency=None, instrumentation_context=None):
+        return [{"model": m["litellm_params"]["model"], "model_id": m["model_info"]["id"]} for m in model_list], [], {}
+
+    with (
+        _proxy_health_globals(
+            model_list,
+            _router_for(model_list),
+            use_background_health_checks=use_background_health_checks,
+            health_check_results=_WILDCARD_CACHED_RESULTS,
+        ),
+        patch(  # test-quality-ok: the probe is the provider edge; which deployments reach it is the assertion
+            "litellm.proxy.health_check._perform_health_check", side_effect=fake_probe
+        ),
+    ):
+        result: Final = await health_endpoint(
+            response=Response(), user_api_key_dict=_team_key(["openai/gpt-5.6"]), model="openai/gpt-5.6", model_id=None
+        )
+
+    assert [ep["model_id"] for ep in result["healthy_endpoints"]] == [expected_id]
+
+
+_ACCESS_GROUP_SPLIT_MODEL_LIST: Final = [
+    {
+        "model_name": "gpt-5.4-mini",
+        "litellm_params": {"model": "openai/gpt-5.4-mini"},
+        "model_info": {"id": "id-mini-premium", "access_groups": ["premium"]},
+    },
+    {
+        "model_name": "gpt-5.4-mini",
+        "litellm_params": {"model": "openai/gpt-5.4-mini"},
+        "model_info": {"id": "id-mini-standard"},
+    },
+]
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_probes_only_the_access_groups_deployments_of_a_shared_name() -> None:
+    caller: Final = UserAPIKeyAuth(api_key="hashed-test-key", models=["premium"])
+
+    probed: Final = await _live_probed_model_ids(_ACCESS_GROUP_SPLIT_MODEL_LIST, caller)
+
+    assert probed == {"id-mini-premium"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("direct_grant", ["gpt-5.4-mini", "*", "all-proxy-models"])
+async def test_health_endpoint_probes_every_deployment_of_a_name_the_key_also_holds_directly(direct_grant: str) -> None:
+    caller: Final = UserAPIKeyAuth(api_key="hashed-test-key", models=["premium", direct_grant])
+
+    probed: Final = await _live_probed_model_ids(_ACCESS_GROUP_SPLIT_MODEL_LIST, caller)
+
+    assert probed == {"id-mini-premium", "id-mini-standard"}
+
+
+_ACCESS_GROUP_SPLIT_WILDCARD_MODEL_LIST: Final = [
+    {
+        "model_name": "openai/*",
+        "litellm_params": {"model": "openai/*"},
+        "model_info": {"id": "id-wild-premium", "access_groups": ["premium"]},
+    },
+    {
+        "model_name": "openai/*",
+        "litellm_params": {"model": "openai/*"},
+        "model_info": {"id": "id-wild-standard", "access_groups": ["standard"]},
+    },
+]
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_probes_only_the_access_groups_wildcard_deployments_serving_a_name() -> None:
+    caller: Final = _personal_key_whose_owner_may_call(["openai/gpt-5.4-nano"]).model_copy(
+        update={"models": ["premium"]}
+    )
+
+    probed: Final = await _live_probed_model_ids(_ACCESS_GROUP_SPLIT_WILDCARD_MODEL_LIST, caller)
+
+    assert probed == {"id-wild-premium"}
+
+
+def _team_deployment(
+    internal_name: str, public_name: str, model: str, model_id: str, access_groups: list[str]
+) -> Mapping[str, object]:
+    return {
+        "model_name": internal_name,
+        "litellm_params": {"model": model},
+        "model_info": {
+            "id": model_id,
+            "team_id": "team-a",
+            "team_public_model_name": public_name,
+            "access_groups": access_groups,
+        },
+    }
+
+
+def _team_split_model_list(public_name: str, model: str) -> list[Mapping[str, object]]:
+    return [
+        _team_deployment("model_name_team-a_7c1e4b2a", public_name, model, "id-team-premium", ["premium"]),
+        _team_deployment("model_name_team-a_9d2f6e01", public_name, model, "id-team-standard", ["standard"]),
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("public_name", "model"),
+    [
+        pytest.param("openai/*", "openai/*", id="team-wildcard"),
+        pytest.param("gpt-5.4-mini", "openai/gpt-5.4-mini", id="team-model"),
+    ],
+)
+async def test_health_endpoint_probes_only_the_access_groups_team_deployments_serving_a_name(
+    public_name: str, model: str
+) -> None:
+    probed: Final = await _live_probed_model_ids(_team_split_model_list(public_name, model), _team_key(["premium"]))
+
+    assert probed == {"id-team-premium"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("internal_name_grant", ["model_name_team-a_9d2f6e01", "model_name_team-a_*"])
+async def test_health_endpoint_probes_a_team_deployment_whose_internal_name_the_key_holds(
+    internal_name_grant: str,
+) -> None:
+    caller: Final = _team_key(["premium", internal_name_grant])
+
+    probed: Final = await _live_probed_model_ids(_team_split_model_list("gpt-5.4-mini", "openai/gpt-5.4-mini"), caller)
+
+    assert probed == {"id-team-premium", "id-team-standard"}
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint_probes_only_the_team_deployment_whose_internal_name_an_agent_holds() -> None:
+    from litellm.types.agents import AgentResponse
+
+    policy: Final = AgentResponse(
+        agent_id="managed",
+        agent_name="Managed",
+        agent_card_params={},
+        object_permission={"models": ["model_name_team-a_9d2f6e01"]},
+    )
+    caller: Final = _team_key(["gpt-5.4-mini"]).model_copy(update={"managed_agent_policy": policy})
+
+    probed: Final = await _live_probed_model_ids(_team_split_model_list("gpt-5.4-mini", "openai/gpt-5.4-mini"), caller)
+
+    assert probed == {"id-team-standard"}
+
+
 def test_resolve_targeted_model_ids_lets_model_id_win_over_model():
     resolve = _health_endpoints_module._resolve_targeted_model_ids
 
diff --git a/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py b/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py
index a0c32f2235f..c26a4bf19b8 100644
--- a/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py
+++ b/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py
@@ -7,7 +7,7 @@ from datetime import datetime, timedelta, timezone
 from types import SimpleNamespace
 from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
-from uuid import UUID
+from uuid import UUID, uuid4
 
 import pytest
 import yaml
@@ -16,6 +16,7 @@ from fastapi.testclient import TestClient
 from pydantic import JsonValue, ValidationError
 
 import litellm
+from litellm.caching.in_memory_cache import InMemoryCache
 from litellm.constants import PROXY_DB_LOOKUP_STALL_WINDOW_SECONDS
 from litellm.litellm_core_utils.duration_parser import duration_in_seconds
 from litellm.models.object_permission import LiteLLM_ObjectPermissionTable
@@ -41,12 +42,15 @@ from litellm.proxy._types import (
     RegenerateKeyRequest,
     ResetSpendRequest,
     UpdateKeyRequest,
+    hash_token,
 )
 from litellm.proxy.auth.auth_checks import (
     delete_cache_key_object,
+    get_key_object,
     jwt_key_mapping_cache_key,
 )
 from litellm.proxy.auth.user_api_key_auth import UserAPIKeyAuth
+from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import AuthCacheInvalidationSubscriber
 from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache, project_cache_key
 from litellm.proxy.db.db_lookup_gate import db_lookup_stall_tracker
 from litellm.proxy.management_endpoints.key_management_endpoints import (
@@ -5755,6 +5759,231 @@ async def test_delete_verification_tokens_evicts_jwt_key_mapping_cache(monkeypat
     )
 
 
+class _ChannelSubscription:
+    """Marks a message done when the subscriber comes back for the next one, so ``messages.join()``
+    returns once every delivered message has been applied"""
+
+    def __init__(self) -> None:
+        self.messages: asyncio.Queue[dict[str, object]] = asyncio.Queue()
+        self._holding_message = False
+
+    async def subscribe(self, *channels: str) -> None:
+        return None
+
+    async def get_message(self, *, ignore_subscribe_messages: bool, timeout: float) -> dict[str, object] | None:
+        if self._holding_message:
+            self._holding_message = False
+            self.messages.task_done()
+        try:
+            message: Final = await asyncio.wait_for(self.messages.get(), timeout)
+        except asyncio.TimeoutError:
+            return None
+        self._holding_message = True
+        return message
+
+    async def aclose(self) -> None:
+        return None
+
+
+class _ChannelPipeline:
+    def __init__(self, redis: "_SharedCoordinationRedis") -> None:
+        self._redis = redis
+        self._messages: tuple[str, ...] = ()
+
+    def publish(self, channel: str, message: str) -> "_ChannelPipeline":
+        self._messages = (*self._messages, message)
+        return self
+
+    async def execute(self) -> None:
+        for message in self._messages:
+            self._redis.deliver(message)
+
+
+class _SharedCoordinationRedis:
+    """The coordination Redis two workers share: whatever one worker publishes reaches the other's subscriber"""
+
+    namespace = None
+
+    def __init__(self) -> None:
+        self.published: tuple[str, ...] = ()
+        self._subscriptions: tuple[_ChannelSubscription, ...] = ()
+
+    def init_pubsub_client(self) -> "_SharedCoordinationRedis":
+        return self
+
+    def pubsub(self) -> _ChannelSubscription:
+        subscription: Final = _ChannelSubscription()
+        self._subscriptions = (*self._subscriptions, subscription)
+        return subscription
+
+    def pipeline(self, transaction: bool = True) -> _ChannelPipeline:
+        return _ChannelPipeline(self)
+
+    async def publish(self, channel: str, message: str) -> int:
+        self.deliver(message)
+        return 1
+
+    def deliver(self, message: str) -> None:
+        self.published = (*self.published, message)
+        for subscription in self._subscriptions:
+            subscription.messages.put_nowait({"type": "message", "data": message.encode()})
+
+    async def until_every_subscriber_applied_its_messages(self) -> None:
+        _ = await asyncio.gather(*(subscription.messages.join() for subscription in self._subscriptions))
+
+
+def _owned_key_row(hashed_token: str) -> LiteLLM_VerificationToken:
+    return LiteLLM_VerificationToken(
+        token=hashed_token,
+        user_id="user-123",
+        team_id=None,
+        key_alias="doomed-key",
+        spend=0.0,
+        max_budget=None,
+        models=[],
+        aliases={},
+        config={},
+        permissions={},
+        metadata={},
+        model_max_budget={},
+        model_spend={},
+        soft_budget_cooldown=False,
+        allowed_routes=[],
+    )
+
+
+def _prisma_with_key_row(key_row: LiteLLM_VerificationToken) -> AsyncMock:
+    prisma_client: Final = AsyncMock()
+    prisma_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[key_row])
+    prisma_client.db.litellm_jwtkeymapping = _CascadingJWTMappingTable([])
+    prisma_client.db.litellm_deletedverificationtoken.create_many = AsyncMock()
+    prisma_client.delete_data = AsyncMock(return_value=[key_row.token])
+    prisma_client.get_data = AsyncMock(return_value=None)
+    return prisma_client
+
+
+@pytest.mark.asyncio
+async def test_delete_verification_tokens_stops_the_key_on_a_peer_worker(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Auth serves key objects cache-first, so a peer worker that is not told about the delete keeps
+    authenticating the deleted key from its own copy until user_api_key_cache_ttl expires"""
+    raw_key: Final = "sk-" + uuid4().hex
+    hashed_token: Final = hash_token(raw_key)
+    deleting_worker_cache: Final = UserApiKeyCache()
+    peer_worker_cache: Final = UserApiKeyCache()
+    for cache in (deleting_worker_cache, peer_worker_cache):
+        cache.set_cache(key=hashed_token, value=UserAPIKeyAuth(token=hashed_token, user_id="user-123"))
+    coordination_redis: Final = _SharedCoordinationRedis()
+    peer_subscriber: Final = AuthCacheInvalidationSubscriber(
+        redis_cache=coordination_redis, user_api_key_cache=peer_worker_cache
+    )
+    peer_subscriber.start()
+    prisma_client: Final = _prisma_with_key_row(_owned_key_row(hashed_token))
+    monkeypatch.setattr("litellm.proxy.proxy_server.redis_usage_cache", coordination_redis)
+    monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", prisma_client)
+
+    try:
+        await delete_verification_tokens(
+            tokens=[raw_key],
+            user_api_key_cache=deleting_worker_cache,
+            user_api_key_dict=UserAPIKeyAuth(
+                user_id="admin-user", api_key="sk-admin", user_role=LitellmUserRoles.PROXY_ADMIN.value
+            ),
+        )
+        await coordination_redis.until_every_subscriber_applied_its_messages()
+    finally:
+        await peer_subscriber.stop()
+
+    assert deleting_worker_cache.get_cache(key=hashed_token) is None
+    with pytest.raises(ProxyException) as denied:
+        await get_key_object(
+            hashed_token=hashed_token, prisma_client=prisma_client, user_api_key_cache=peer_worker_cache
+        )
+    assert denied.value.code == "401"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "deleter",
+    [
+        UserAPIKeyAuth(user_id="admin-user", api_key="sk-admin", user_role=LitellmUserRoles.PROXY_ADMIN.value),
+        UserAPIKeyAuth(user_id="user-123", api_key="sk-owner", user_role=LitellmUserRoles.INTERNAL_USER.value),
+    ],
+    ids=["proxy_admin", "key_owner"],
+)
+async def test_delete_verification_tokens_evicts_a_requested_key_whose_row_is_already_gone(
+    monkeypatch: pytest.MonkeyPatch, deleter: UserAPIKeyAuth
+) -> None:
+    """A key whose row was removed outside the API stays cached on every worker, so deleting it in a
+    batch beside a live key must still stop it everywhere instead of only evicting the rows found"""
+    live_key: Final = "sk-" + uuid4().hex
+    gone_key: Final = "sk-" + uuid4().hex
+    live_token: Final = hash_token(live_key)
+    gone_token: Final = hash_token(gone_key)
+    deleting_worker_cache: Final = UserApiKeyCache()
+    peer_worker_cache: Final = UserApiKeyCache()
+    for cache in (deleting_worker_cache, peer_worker_cache):
+        for token in (live_token, gone_token):
+            cache.set_cache(key=token, value=UserAPIKeyAuth(token=token, user_id="user-123"))
+    coordination_redis: Final = _SharedCoordinationRedis()
+    peer_subscriber: Final = AuthCacheInvalidationSubscriber(
+        redis_cache=coordination_redis, user_api_key_cache=peer_worker_cache
+    )
+    peer_subscriber.start()
+    monkeypatch.setattr("litellm.proxy.proxy_server.redis_usage_cache", coordination_redis)
+    monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", _prisma_with_key_row(_owned_key_row(live_token)))
+
+    try:
+        await delete_verification_tokens(
+            tokens=[live_key, gone_key], user_api_key_cache=deleting_worker_cache, user_api_key_dict=deleter
+        )
+        await coordination_redis.until_every_subscriber_applied_its_messages()
+    finally:
+        await peer_subscriber.stop()
+
+    assert [deleting_worker_cache.get_cache(key=token) for token in (live_token, gone_token)] == [None, None]
+    assert [peer_worker_cache.get_cache(key=token) for token in (live_token, gone_token)] == [None, None]
+
+
+@pytest.mark.asyncio
+async def test_delete_verification_tokens_leaves_unowned_cache_entries_alone_on_every_worker(monkeypatch: pytest.MonkeyPatch) -> None:
+    """/key/delete accepts any string, and a name that is not a key row passes through unhashed. A key
+    owner padding the request with another team's spend counter name must not wipe that counter from
+    every worker's memory: only the rows the caller was allowed to delete are evicted and broadcast"""
+    raw_key: Final = "sk-" + uuid4().hex
+    hashed_token: Final = hash_token(raw_key)
+    other_team_counter: Final = "spend:team:other-team"
+    deleting_worker_cache: Final = UserApiKeyCache()
+    peer_worker_cache: Final = UserApiKeyCache()
+    peer_spend_counters: Final = InMemoryCache()
+    peer_spend_counters.set_cache(other_team_counter, 42.0)
+    peer_worker_cache.set_cache(key=hashed_token, value=UserAPIKeyAuth(token=hashed_token, user_id="user-123"))
+    coordination_redis: Final = _SharedCoordinationRedis()
+    peer_subscriber: Final = AuthCacheInvalidationSubscriber(
+        redis_cache=coordination_redis,
+        user_api_key_cache=peer_worker_cache,
+        additional_in_memory_caches=(peer_spend_counters,),
+    )
+    peer_subscriber.start()
+    monkeypatch.setattr("litellm.proxy.proxy_server.redis_usage_cache", coordination_redis)
+    monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", _prisma_with_key_row(_owned_key_row(hashed_token)))
+
+    try:
+        await delete_verification_tokens(
+            tokens=[other_team_counter, raw_key],
+            user_api_key_cache=deleting_worker_cache,
+            user_api_key_dict=UserAPIKeyAuth(
+                user_id="user-123", api_key="sk-owner", user_role=LitellmUserRoles.INTERNAL_USER.value
+            ),
+        )
+        await coordination_redis.until_every_subscriber_applied_its_messages()
+    finally:
+        await peer_subscriber.stop()
+
+    assert peer_worker_cache.get_cache(key=hashed_token) is None
+    assert peer_spend_counters.get_cache(other_team_counter) == 42.0
+    assert coordination_redis.published == (json.dumps({"cache_key": hashed_token}),)
+
+
 @pytest.mark.asyncio
 async def test_delete_key_fn_persists_deleted_keys(monkeypatch):
     from litellm.proxy._types import KeyRequest
@@ -18750,7 +18979,7 @@ async def test_list_keys_rejects_invalid_expires():
                 expires="expred",
             )
 
-    assert exc_info.value.code == "400"
+    assert (exc_info.value.code, exc_info.value.type) == ("400", "invalid_request_error")
     assert "Invalid expires value" in str(exc_info.value.message)
 
 
diff --git a/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_typesafe_passthrough_logging_handler.py b/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_typesafe_passthrough_logging_handler.py
index 4011bc0294a..7f8aac983f5 100644
--- a/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_typesafe_passthrough_logging_handler.py
+++ b/tests/unit/proxy/pass_through_endpoints/llm_provider_handlers/test_typesafe_passthrough_logging_handler.py
@@ -323,6 +323,35 @@ def test_openrouter_decisions_response_uses_provider_cost_without_cost_map_row(
     assert response["kwargs"]["combined_usage_object"].total_tokens == 302
 
 
+@pytest.mark.parametrize("reported_cost", [float("nan"), float("inf")])
+def test_openrouter_non_finite_cost_logs_the_token_price(monkeypatch: pytest.MonkeyPatch, reported_cost: float) -> None:
+    monkeypatch.setitem(
+        litellm.model_cost,
+        "openrouter/typesafe/jev-1.13",
+        {"input_cost_per_token": 1.0, "output_cost_per_token": 3.0, "litellm_provider": "openrouter", "mode": "chat"},
+    )
+    logging_obj: Final = _logging_obj()
+
+    result: Final = TypeSafePassthroughLoggingHandler.typesafe_passthrough_handler(
+        httpx_response=_response(),
+        response_body={
+            "model": "typesafe/jev-1.13-20260917",
+            "usage": {"input_tokens": 2, "output_tokens": 1, "cost": reported_cost},
+        },
+        logging_obj=logging_obj,
+        url_route="https://openrouter.ai/api/alpha/decisions",
+        result='{"answers": {}}',
+        start_time=datetime(2000, 1, 1),
+        end_time=datetime(2000, 1, 1),
+        cache_hit=False,
+        request_body={"model": "typesafe/jev-1.13"},
+        custom_llm_provider="openrouter",
+    )
+
+    assert result["kwargs"]["response_cost"] == pytest.approx(5.0)
+    assert logging_obj.model_call_details["response_cost"] == pytest.approx(5.0)
+
+
 def test_success_handler_dispatches_openrouter_to_the_shared_handler():
     logging_obj = _logging_obj()
     normalized = PassThroughEndpointLogging().normalize_llm_passthrough_logging_payload(
diff --git a/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py b/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py
index 806d88b2467..ff27ac54a5b 100644
--- a/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py
+++ b/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py
@@ -25,12 +25,14 @@ from starlette.datastructures import FormData
 import litellm
 from litellm.integrations.custom_guardrail import CustomGuardrail
 from litellm.integrations.custom_logger import CustomLogger
+from litellm.integrations.prometheus import PrometheusLogger
 from tests._master_key import MASTER_KEY as SHARED_MASTER_KEY
 from litellm.caching.caching import DualCache
-from litellm.types.utils import CallTypesLiteral
+from litellm.types.utils import CallTypes, CallTypesLiteral
 from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
 from litellm.exceptions import BlockedPiiEntityError, GuardrailRaisedException, ModifyResponseException
 from litellm.proxy._types import AwsErrorTypeProxyException, ProxyException
+from litellm.proxy.spend_tracking.spend_tracking_utils import get_spend_logs_id
 from litellm.proxy.utils import ProxyLogging
 from litellm.passthrough.main import raise_for_provider_status
 from litellm.llms.bedrock.common_utils import BedrockError
@@ -2759,6 +2761,68 @@ class TestVLLMProxyRoute:
         mock_factory_route.assert_awaited_once()
 
 
+@pytest.mark.parametrize(
+    ("vllm_api_base", "request_path"),
+    [
+        ("http://vllm-upstream.test:8090", "/vllm/v1/chat/completions"),
+        ("http://vllm-upstream.test:8090/v1", "/vllm/v1/chat/completions"),
+        ("http://vllm-upstream.test:8090/v1", "/vllm/chat/completions"),
+    ],
+)
+def test_vllm_provider_route_reaches_v1_paths_with_its_key_as_a_bearer(
+    monkeypatch: pytest.MonkeyPatch, vllm_api_base: str, request_path: str
+) -> None:
+    from litellm.proxy import proxy_server
+
+    monkeypatch.setenv("VLLM_API_BASE", vllm_api_base)
+    monkeypatch.setenv("VLLM_API_KEY", "sk-vllm-upstream")
+    monkeypatch.setattr(proxy_server, "llm_router", None)
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    litellm.in_memory_llm_clients_cache.flush_cache()
+    monkeypatch.setitem(
+        proxy_server.app.dependency_overrides, user_api_key_auth, lambda: UserAPIKeyAuth(api_key="sk-virtual")
+    )
+
+    with respx.mock(assert_all_called=True) as upstream:
+        route: Final = upstream.post("http://vllm-upstream.test:8090/v1/chat/completions").mock(
+            return_value=httpx.Response(200, json={"id": "chatcmpl-1"})
+        )
+        response: Final = TestClient(proxy_server.app).post(
+            request_path,
+            json={"model": "Qwen/Qwen3-0.6B", "messages": [{"role": "user", "content": "hi"}]},
+        )
+
+    assert (response.status_code, response.json()) == (200, {"id": "chatcmpl-1"})
+    assert route.calls.last.request.headers["authorization"] == "Bearer sk-vllm-upstream"
+    assert route.calls.last.request.headers["x-api-key"] == "sk-vllm-upstream"
+
+
+def test_vllm_provider_route_with_an_empty_key_sends_no_credential_headers(monkeypatch: pytest.MonkeyPatch) -> None:
+    from litellm.proxy import proxy_server
+
+    monkeypatch.setenv("VLLM_API_BASE", "http://vllm-upstream.test:8090")
+    monkeypatch.setenv("VLLM_API_KEY", "")
+    monkeypatch.setattr(proxy_server, "llm_router", None)
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    litellm.in_memory_llm_clients_cache.flush_cache()
+    monkeypatch.setitem(
+        proxy_server.app.dependency_overrides, user_api_key_auth, lambda: UserAPIKeyAuth(api_key="sk-virtual")
+    )
+
+    with respx.mock(assert_all_called=True) as upstream:
+        route: Final = upstream.post("http://vllm-upstream.test:8090/v1/chat/completions").mock(
+            return_value=httpx.Response(200, json={"id": "chatcmpl-1"})
+        )
+        response: Final = TestClient(proxy_server.app).post(
+            "/vllm/v1/chat/completions",
+            json={"model": "Qwen/Qwen3-0.6B", "messages": [{"role": "user", "content": "hi"}]},
+        )
+
+    assert (response.status_code, response.json()) == (200, {"id": "chatcmpl-1"})
+    assert "authorization" not in route.calls.last.request.headers
+    assert "x-api-key" not in route.calls.last.request.headers
+
+
 class TestGigachatProxyRoute:
     @pytest.mark.asyncio
     @patch(  # test-quality-ok: patching litellm internal for unit test isolation
@@ -6428,6 +6492,55 @@ class TestVertexAILiveWebsocketPassthrough:
         assert "default_vertex_config" in close_kwargs["reason"]
         assert len(close_kwargs["reason"].encode("utf-8")) <= 123
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("model, expected_model", [("gemini-3.8-live", "gemini-3.8-live"), (None, "")])
+    async def test_credential_failure_logs_the_named_model_under_vertex_ai(
+        self, monkeypatch: pytest.MonkeyPatch, model: str | None, expected_model: str
+    ):
+        from litellm.proxy.pass_through_endpoints import (
+            llm_passthrough_endpoints as passthrough_module,
+        )
+
+        class _FailureRecorder(CustomLogger):
+            def __init__(self) -> None:
+                super().__init__()
+                self.request_data: tuple[dict[str, object], ...] = ()
+
+            async def async_post_call_failure_hook(
+                self,
+                request_data: dict[str, object],
+                original_exception: Exception,
+                user_api_key_dict: UserAPIKeyAuth,
+                traceback_str: str | None = None,
+            ) -> None:
+                self.request_data = (*self.request_data, request_data)
+
+        recorder: Final = _FailureRecorder()
+        monkeypatch.setattr("litellm.proxy.proxy_server.llm_router", None)
+        monkeypatch.setattr(
+            "litellm.proxy.proxy_server.proxy_logging_obj", ProxyLogging(user_api_key_cache=DualCache())
+        )
+        monkeypatch.setattr(litellm, "callbacks", [recorder])
+        monkeypatch.setattr(passthrough_module.passthrough_endpoint_router, "default_vertex_config", None)
+        self._clear_vertex_env(monkeypatch)
+        ensure_token: Final = AsyncMock(side_effect=Exception("Unable to find your credentials"))
+
+        with patch.object(passthrough_module.vertex_llm_base, "ensure_access_token_async", ensure_token):
+            await passthrough_module.vertex_ai_live_websocket_passthrough(
+                websocket=self._websocket(),
+                model=model,
+                user_api_key_dict=UserAPIKeyAuth(),
+            )
+
+        assert [
+            (
+                d["model"],
+                PrometheusLogger._extract_api_provider_from_request_data(d),
+                get_spend_logs_id(CallTypes.pass_through.value, {}, d) is not None,
+            )
+            for d in recorder.request_data
+        ] == [(expected_model, "vertex_ai", True)]
+
 
 class TestAnthropicProxyRoute:
     """The /anthropic passthrough route: custom auth headers must not clobber the
diff --git a/tests/unit/proxy/pass_through_endpoints/test_pass_through_endpoints.py b/tests/unit/proxy/pass_through_endpoints/test_pass_through_endpoints.py
index 7b62853b0e9..a9098ac3d59 100644
--- a/tests/unit/proxy/pass_through_endpoints/test_pass_through_endpoints.py
+++ b/tests/unit/proxy/pass_through_endpoints/test_pass_through_endpoints.py
@@ -30,20 +30,26 @@ from starlette.datastructures import UploadFile as StarletteUploadFile
 
 import litellm
 from litellm._logging import verbose_proxy_logger
+from litellm.caching.dual_cache import DualCache
 from litellm.constants import DEFAULT_REQUEST_TIMEOUT_SECONDS
 from litellm.integrations.custom_guardrail import CustomGuardrail
 from litellm.integrations.custom_logger import CustomLogger
+from litellm.integrations.prometheus import PrometheusLogger
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.proxy._lazy_features import LazyFeature, attach_lazy_features
 from litellm.proxy._types import ProxyException, UserAPIKeyAuth
 from litellm.proxy.litellm_pre_call_utils import LiteLLMProxyRequestSetup
 from litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints import router as llm_passthrough_router
+from litellm.proxy.pass_through_endpoints.llm_provider_handlers.vertex_passthrough_logging_handler import (
+    VertexPassthroughLoggingHandler,
+)
 from litellm.proxy.pass_through_endpoints.pass_through_endpoints import (
     DEFAULT_PASS_THROUGH_REQUEST_TIMEOUT_SECONDS,
     LITELLM_PASS_THROUGH_CUSTOM_BODY_STATE_KEY,
     HttpPassThroughEndpointHelpers,
     InitPassThroughEndpointHelpers,
     SafeRouteAdder,
+    _build_passthrough_failure_request_payload,
     _registered_pass_through_routes,
     _truncate_upstream_error_body,
     _update_metadata_with_tags_in_header,
@@ -61,8 +67,11 @@ from litellm.proxy.pass_through_endpoints.success_handler import (
     PassThroughEndpointLogging,
 )
 from litellm.proxy.route_llm_request import ProxyModelNotFoundError
+from litellm.proxy.spend_tracking.spend_tracking_utils import get_spend_logs_id
+from litellm.proxy.utils import ProxyLogging
 from litellm.types import utils as types_utils
 from litellm.types.guardrails import GuardrailEventHooks
+from litellm.types.utils import CallTypes
 from litellm.types.passthrough_endpoints.pass_through_endpoints import (
     LITELLM_PASS_THROUGH_DEPLOYMENT_MODEL_INFO_STATE_KEY,
     LITELLM_PASS_THROUGH_RAW_BODY_STATE_KEY,
@@ -140,9 +149,7 @@ def test_is_multipart():
         ),
     ],
 )
-def test_get_endpoint_type_classifies_anthropic_messages_routes(
-    url: str, expected_endpoint_type: EndpointType
-) -> None:
+def test_get_endpoint_type_classifies_anthropic_messages_routes(url: str, expected_endpoint_type: EndpointType) -> None:
     assert HttpPassThroughEndpointHelpers.get_endpoint_type(url) == expected_endpoint_type
 
 
@@ -430,53 +437,18 @@ async def test_pass_through_request_failure_handler():
 
     Critical Test: When a users pass through endpoint request fails, we must log the failure code, exception in litellm spend logs.
     """
-    with patch("litellm.proxy.proxy_server.proxy_logging_obj") as mock_proxy_logging:
-        with patch("litellm.llms.custom_httpx.http_handler.get_async_httpx_client") as mock_get_client:
-            with patch(
-                "litellm.proxy.pass_through_endpoints.pass_through_endpoints.ProxyBaseLLMRequestProcessing"
-            ) as mock_processing:
-                # Setup mock for post_call_failure_hook and pre_call_hook
-                mock_proxy_logging.post_call_failure_hook = AsyncMock()
-                mock_proxy_logging.pre_call_hook = AsyncMock()
+    request_failure = httpx.HTTPError("Request failed")
+    user_api_key_dict = UserAPIKeyAuth(api_key="sk-test")
 
-                # Setup mock for httpx client
-                mock_client = MagicMock()
-                mock_client.client = MagicMock()
-                mock_client.client.request = AsyncMock(side_effect=httpx.HTTPError("Request failed"))
-                mock_get_client.return_value = mock_client
+    failure: Final = await _run_passthrough_failure(
+        "http://test.com", None, request_failure, user_api_key_dict=user_api_key_dict
+    )
 
-                # Mock headers for custom headers
-                mock_processing.get_custom_headers.return_value = {}
-
-                # Create mock request
-                mock_request = MagicMock(spec=Request)
-                mock_request.method = "POST"
-                mock_request.body = AsyncMock(return_value=b'{"test": "data"}')
-                mock_request.headers = Headers({})
-
-                # Create a simple empty QueryParams
-                mock_request.query_params = QueryParams({})
-
-                # Create mock user API key dict
-                mock_user_api_key_dict = MagicMock()
-
-                # Call the function with a target that will trigger an HTTPError
-                with pytest.raises(ProxyException):
-                    await pass_through_request(
-                        request=mock_request,
-                        target="http://test.com",
-                        custom_headers={},
-                        user_api_key_dict=mock_user_api_key_dict,
-                    )
-
-                # Assert post_call_failure_hook was called
-                mock_proxy_logging.post_call_failure_hook.assert_called_once()
-
-                # Verify the arguments to post_call_failure_hook
-                call_args = mock_proxy_logging.post_call_failure_hook.call_args[1]
-                assert call_args["user_api_key_dict"] == mock_user_api_key_dict
-                assert isinstance(call_args["original_exception"], TypeError)  # Now expecting TypeError
-                assert "traceback_str" in call_args
+    assert failure.user_api_key_dict is user_api_key_dict
+    assert failure.original_exception is request_failure
+    assert "Request failed" in (failure.traceback_str or "")
+    assert failure.request_data["contents"] == "not a list"
+    assert failure.request_data["model"] == ""
 
 
 @pytest.mark.asyncio
@@ -3656,9 +3628,7 @@ async def test_pass_through_request_preserves_target_query_without_client_query(
 
 
 @pytest.mark.asyncio
-async def test_config_pass_through_without_configured_headers_preserves_no_authorization(
-    tmp_path, monkeypatch
-):
+async def test_config_pass_through_without_configured_headers_preserves_no_authorization(tmp_path, monkeypatch):
     proxy = await _boot_db_backed_proxy(
         tmp_path,
         monkeypatch,
@@ -3725,9 +3695,7 @@ async def test_pass_through_rpm_limit_is_sequential_and_scoped_per_key(tmp_path,
     proxy = await _boot_db_backed_proxy(
         tmp_path,
         monkeypatch,
-        config_pass_through_endpoints=[
-            {"path": "/rpm-rerank", "target": "http://upstream.test/rerank", "auth": True}
-        ],
+        config_pass_through_endpoints=[{"path": "/rpm-rerank", "target": "http://upstream.test/rerank", "auth": True}],
         db_pass_through_endpoints=[],
         master_key=MASTER_KEY,
     )
@@ -4902,8 +4870,10 @@ from fastapi import HTTPException as _FastAPIHTTPException
 from litellm.exceptions import (
     BlockedPiiEntityError,
     GuardrailRaisedException,
+    ModifyResponseException,
 )
 from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER
+
 _PT_MODULE = "litellm.proxy.pass_through_endpoints.pass_through_endpoints"
 
 
@@ -8182,8 +8152,10 @@ async def test_user_defined_passthrough_is_neither_tracked_nor_enforced(metadata
         }
     )
     body: Final = {
-        "model": "upstream-only-model", metadata_slot: {
-            "model_group": "managed-model", "customer_label": "retained",
+        "model": "upstream-only-model",
+        metadata_slot: {
+            "model_group": "managed-model",
+            "customer_label": "retained",
             "user_api_key_team_model_max_budget": budget,
         },
     }
@@ -8191,48 +8163,84 @@ async def test_user_defined_passthrough_is_neither_tracked_nor_enforced(metadata
     assert await limiter.is_team_within_model_budget("shared-team", budget, None, "managed-model")
     start: Final = datetime.now()
     logging_obj: Final = LiteLLMLoggingObj(
-        model="upstream-only-model", messages=[], stream=False, call_type="pass_through_endpoint",
-        start_time=start, litellm_call_id="custom-budget", function_id="custom-budget", kwargs={},
+        model="upstream-only-model",
+        messages=[],
+        stream=False,
+        call_type="pass_through_endpoint",
+        start_time=start,
+        litellm_call_id="custom-budget",
+        function_id="custom-budget",
+        kwargs={},
         dynamic_async_success_callbacks=[limiter],
     )
     payload: Final = {
-        "url": "https://upstream.test/echo", "request_body": body, "request_method": "POST", "cost_per_request": 0.25,
+        "url": "https://upstream.test/echo",
+        "request_body": body,
+        "request_method": "POST",
+        "cost_per_request": 0.25,
     }
     kwargs: Final = HttpPassThroughEndpointHelpers._init_kwargs_for_pass_through_endpoint(
-        request=request, user_api_key_dict=auth, passthrough_logging_payload=payload, logging_obj=logging_obj,
-        _parsed_body=body, litellm_call_id="custom-budget",
+        request=request,
+        user_api_key_dict=auth,
+        passthrough_logging_payload=payload,
+        logging_obj=logging_obj,
+        _parsed_body=body,
+        litellm_call_id="custom-budget",
     )
     logging_obj.update_environment_variables(
-        model="upstream-only-model", user="unknown", optional_params={},
-        litellm_params=kwargs["litellm_params"], call_type="pass_through_endpoint",
+        model="upstream-only-model",
+        user="unknown",
+        optional_params={},
+        litellm_params=kwargs["litellm_params"],
+        call_type="pass_through_endpoint",
     )
     response: Final = httpx.Response(
-        200, request=httpx.Request("POST", "https://upstream.test/echo"), json={"ok": True},
+        200,
+        request=httpx.Request("POST", "https://upstream.test/echo"),
+        json={"ok": True},
     )
     await PassThroughEndpointLogging().pass_through_async_success_handler(
-        httpx_response=response, response_body={"ok": True}, request_body=body, logging_obj=logging_obj,
-        url_route="https://upstream.test/echo", result=response.text, start_time=start, end_time=datetime.now(),
-        cache_hit=False, **kwargs,
+        httpx_response=response,
+        response_body={"ok": True},
+        request_body=body,
+        logging_obj=logging_obj,
+        url_route="https://upstream.test/echo",
+        result=response.text,
+        start_time=start,
+        end_time=datetime.now(),
+        cache_hit=False,
+        **kwargs,
     )
     assert logging_obj.model_call_details["response_cost"] == 0.25
     assert await limiter.is_team_within_model_budget("shared-team", budget, None, "managed-model")
     metadata: Final = kwargs["litellm_params"]["metadata"]
     assert (metadata["model_group"], metadata["customer_label"]) == ("managed-model", "retained")
-    assert metadata.keys().isdisjoint({
-        "user_api_key_model_max_budget", "user_api_key_team_model_max_budget",
-        "user_api_key_user_model_max_budget", "user_api_key_end_user_model_max_budget",
-    })
+    assert metadata.keys().isdisjoint(
+        {
+            "user_api_key_model_max_budget",
+            "user_api_key_team_model_max_budget",
+            "user_api_key_user_model_max_budget",
+            "user_api_key_end_user_model_max_budget",
+        }
+    )
 
 
 @pytest.mark.parametrize("metadata_slot", ["metadata", "litellm_metadata"])
 def test_builtin_passthrough_pins_model_group_to_the_resolved_model(metadata_slot: str) -> None:
-    request: Final = Request({
-        "type": "http", "method": "POST", "path": "/gemini/v1beta/models/gemini-2.5-flash:generateContent",
-        "headers": [], "query_string": b"",
-    })
+    request: Final = Request(
+        {
+            "type": "http",
+            "method": "POST",
+            "path": "/gemini/v1beta/models/gemini-2.5-flash:generateContent",
+            "headers": [],
+            "query_string": b"",
+        }
+    )
     kwargs: Final = HttpPassThroughEndpointHelpers._init_kwargs_for_pass_through_endpoint(
-        request=request, user_api_key_dict=UserAPIKeyAuth(token="hash", user_id="u-1"),
-        passthrough_logging_payload=MagicMock(), logging_obj=MagicMock(),
+        request=request,
+        user_api_key_dict=UserAPIKeyAuth(token="hash", user_id="u-1"),
+        passthrough_logging_payload=MagicMock(),
+        logging_obj=MagicMock(),
         _parsed_body={"contents": [], metadata_slot: {"model_group": "unbounded-client-choice"}},
     )
     assert kwargs["litellm_params"]["metadata"]["model_group"] == "gemini-2.5-flash"
@@ -8591,6 +8599,581 @@ def test_passthrough_client_cannot_forge_session_id_omission(client_metadata_key
     )
 
 
+_GEMINI_FLASH_TARGET: Final = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent"
+_VERTEX_FLASH_TARGET: Final = (
+    "https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5"
+    "/publishers/google/models/gemini-3.8-flash:generateContent"
+)
+_VERTEX_CLAUDE_RAW_PREDICT_TARGET: Final = (
+    "https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5"
+    "/publishers/anthropic/models/claude-opus-5:rawPredict"
+)
+_VERTEX_SEARCH_TARGET: Final = (
+    "https://discoveryengine.googleapis.com/v1/projects/p/locations/global"
+    "/dataStores/default/servingConfigs/default:search"
+)
+_RELAYED_GEMINI_COUNT_TOKENS_TARGET: Final = "http://127.0.0.1:30732/v1beta/models/gemini-3.8-flash:countTokens"
+_TRANSLATE_TARGET: Final = "https://translate.googleapis.com/v3/projects/p/locations/global:translateText"
+_NON_GOOGLE_VERTEX_SHAPED_TARGET: Final = "https://llm.example.com/v1/projects/a/locations/b/models/my-model:predict"
+_VERTEX_LIVE_TARGET: Final = (
+    "wss://us-central1-aiplatform.googleapis.com/ws/google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent"
+)
+_VEO_OPERATION_SUFFIX: Final = "/models/veo-3.0-generate-001/operations/op-8f2c1"
+_RELAYED_VERTEX_COUNT_TOKENS_TARGET: Final = (
+    "http://127.0.0.1:30732/v1/projects/p/locations/us-east5/publishers/google/models/gemini-3.8-flash:countTokens"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _RecordedFailure:
+    request_data: dict[str, object]
+    original_exception: Exception
+    user_api_key_dict: UserAPIKeyAuth
+    traceback_str: str | None
+
+
+class _FailureHookRecorder(CustomLogger):
+    def __init__(self) -> None:
+        super().__init__()
+        self.failures: tuple[_RecordedFailure, ...] = ()
+
+    async def async_post_call_failure_hook(
+        self,
+        request_data: dict[str, object],
+        original_exception: Exception,
+        user_api_key_dict: UserAPIKeyAuth,
+        traceback_str: str | None = None,
+    ) -> None:
+        self.failures = (
+            *self.failures,
+            _RecordedFailure(request_data, original_exception, user_api_key_dict, traceback_str),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _PassthroughRun:
+    failure: _RecordedFailure
+    response: Response | None
+
+
+async def _drained_pass_through_response(
+    request: Request,
+    target: str,
+    custom_llm_provider: str | None,
+    user_api_key_dict: UserAPIKeyAuth,
+    stream: bool,
+) -> Response | None:
+    try:
+        received: Final = await pass_through_request(
+            request=request,
+            target=target,
+            custom_headers={},
+            user_api_key_dict=user_api_key_dict,
+            custom_llm_provider=custom_llm_provider,
+            stream=stream,
+        )
+        if isinstance(received, StreamingResponse):
+            async for _ in received.body_iterator:
+                pass
+    except (ProxyException, httpx.HTTPError):
+        return None
+    return received if isinstance(received, Response) else None
+
+
+async def _run_passthrough_failure(
+    target: str,
+    custom_llm_provider: str | None,
+    upstream: httpx.Response | Exception,
+    stream: bool = False,
+    user_api_key_dict: UserAPIKeyAuth | None = None,
+    dispatched_endpoint: Callable[..., object] | None = None,
+    guardrail: CustomGuardrail | None = None,
+    body: bytes = b'{"contents": "not a list"}',
+) -> _RecordedFailure:
+    run: Final = await _run_passthrough(
+        target, custom_llm_provider, upstream, stream, user_api_key_dict, dispatched_endpoint, guardrail, body
+    )
+    return run.failure
+
+
+async def _run_passthrough(
+    target: str,
+    custom_llm_provider: str | None,
+    upstream: httpx.Response | Exception,
+    stream: bool = False,
+    user_api_key_dict: UserAPIKeyAuth | None = None,
+    dispatched_endpoint: Callable[..., object] | None = None,
+    guardrail: CustomGuardrail | None = None,
+    body: bytes = b'{"contents": "not a list"}',
+) -> _PassthroughRun:
+    recorder: Final = _FailureHookRecorder()
+    with (
+        pytest.MonkeyPatch.context() as litellm_patch,
+        patch(  # test-quality-ok: proxy_logging_obj is a proxy_server module global read inside pass_through_request; there is no injection seam
+            "litellm.proxy.proxy_server.proxy_logging_obj", ProxyLogging(user_api_key_cache=DualCache())
+        ),
+        respx.mock(assert_all_called=False) as upstream_mock,
+    ):
+        litellm_patch.setattr(litellm, "disable_aiohttp_transport", True)
+        litellm_patch.setattr(litellm, "callbacks", [recorder] if guardrail is None else [guardrail, recorder])
+        litellm.in_memory_llm_clients_cache.flush_cache()
+        upstream_route: Final = upstream_mock.route(method="POST")
+        if isinstance(upstream, Exception):
+            upstream_route.mock(side_effect=upstream)
+        else:
+            upstream_route.mock(return_value=upstream)
+        mock_request: Final = MagicMock(spec=Request)
+        mock_request.method = "POST"
+        proxy_url: Final = httpx.URL(target.replace("https://", "http://test-proxy.com/"))
+        mock_request.url = proxy_url
+        mock_request.scope = {
+            "type": "http",
+            "method": "POST",
+            "path": proxy_url.path,
+            **({"endpoint": dispatched_endpoint} if dispatched_endpoint is not None else {}),
+        }
+        mock_request.body = AsyncMock(return_value=body)
+        mock_request.headers = Headers({"content-type": "application/json"})
+        mock_request.query_params = QueryParams({})
+        response: Final = await _drained_pass_through_response(
+            mock_request,
+            target,
+            custom_llm_provider,
+            user_api_key_dict or UserAPIKeyAuth(api_key="sk-test"),
+            stream,
+        )
+        await asyncio.sleep(0)
+        litellm.in_memory_llm_clients_cache.flush_cache()
+    assert len(recorder.failures) == 1
+    return _PassthroughRun(recorder.failures[0], response)
+
+
+def _upstream_400(target: str) -> httpx.Response:
+    return httpx.Response(
+        status_code=400,
+        headers={"content-type": "application/json"},
+        content=json.dumps({"error": {"code": 400, "status": "INVALID_ARGUMENT"}}).encode(),
+        request=httpx.Request("POST", target),
+    )
+
+
+def _upstream_400_as_event_stream(target: str) -> httpx.Response:
+    return httpx.Response(
+        status_code=400,
+        headers={"content-type": "text/event-stream"},
+        content=b'data: {"error": {"code": 400, "status": "INVALID_ARGUMENT"}}\n\n',
+        request=httpx.Request("POST", target),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "target, custom_llm_provider, stream, expected_provider",
+    [
+        (_GEMINI_FLASH_TARGET, "gemini", False, "gemini"),
+        (_GEMINI_FLASH_TARGET, "gemini", True, "gemini"),
+        (_VERTEX_FLASH_TARGET, None, False, "vertex_ai"),
+        (_VERTEX_FLASH_TARGET, None, True, "vertex_ai"),
+        (_GEMINI_FLASH_TARGET.replace(":generateContent", ":countTokens"), "gemini", False, "gemini"),
+        (_VERTEX_FLASH_TARGET.replace(":generateContent", ":countTokens"), None, False, "vertex_ai"),
+        (_RELAYED_GEMINI_COUNT_TOKENS_TARGET, "gemini", False, "gemini"),
+    ],
+)
+async def test_passthrough_upstream_error_logs_model_from_url(
+    target: str, custom_llm_provider: str | None, stream: bool, expected_provider: str
+):
+    failure: Final = await _run_passthrough_failure(target, custom_llm_provider, _upstream_400(target), stream=stream)
+    assert failure.request_data["model"] == "gemini-3.8-flash"
+    assert failure.request_data["custom_llm_provider"] == expected_provider
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "target",
+    [
+        _RELAYED_VERTEX_COUNT_TOKENS_TARGET,
+        _TRANSLATE_TARGET,
+        _NON_GOOGLE_VERTEX_SHAPED_TARGET,
+    ],
+)
+async def test_passthrough_upstream_error_to_a_host_outside_gemini_and_vertex_gets_no_url_attribution(target: str):
+    failure: Final = await _run_passthrough_failure(target, None, _upstream_400(target))
+    assert failure.request_data["model"] == ""
+    assert failure.request_data.get("custom_llm_provider") is None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("target", [_GEMINI_FLASH_TARGET, _VERTEX_FLASH_TARGET])
+async def test_passthrough_upstream_error_on_a_user_defined_route_to_google_gets_no_url_attribution(target: str):
+    failure: Final = await _run_passthrough_failure(
+        target, None, _upstream_400(target), dispatched_endpoint=_marked_pass_through_endpoint()
+    )
+    assert failure.request_data["model"] == ""
+    assert failure.request_data.get("custom_llm_provider") is None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "target, custom_llm_provider, expected_provider",
+    [
+        (_GEMINI_FLASH_TARGET, "gemini", "gemini"),
+        (_VERTEX_FLASH_TARGET, None, "vertex_ai"),
+    ],
+)
+async def test_passthrough_detected_stream_upstream_error_logs_model_from_url(
+    target: str, custom_llm_provider: str | None, expected_provider: str
+):
+    failure: Final = await _run_passthrough_failure(
+        target, custom_llm_provider, _upstream_400_as_event_stream(target), stream=False
+    )
+    assert failure.request_data["model"] == "gemini-3.8-flash"
+    assert failure.request_data["custom_llm_provider"] == expected_provider
+
+
+@pytest.mark.asyncio
+async def test_passthrough_internal_failure_logs_model_from_url():
+    failure: Final = await _run_passthrough_failure(
+        _GEMINI_FLASH_TARGET, "gemini", httpx.ReadTimeout("upstream timed out")
+    )
+    assert failure.request_data["model"] == "gemini-3.8-flash"
+    assert failure.request_data["custom_llm_provider"] == "gemini"
+
+
+def _upstream_dropping_stream(target: str) -> httpx.Response:
+    return httpx.Response(
+        status_code=200,
+        headers={"content-type": "text/event-stream"},
+        stream=_UpstreamDroppingMidStream(),
+        request=httpx.Request("POST", target),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("stream", [True, False])
+@pytest.mark.parametrize(
+    "target, custom_llm_provider, expected_provider",
+    [
+        (_GEMINI_FLASH_TARGET.replace(":generateContent", ":streamGenerateContent?alt=sse"), "gemini", "gemini"),
+        (_VERTEX_FLASH_TARGET.replace(":generateContent", ":streamGenerateContent?alt=sse"), None, "vertex_ai"),
+    ],
+)
+async def test_passthrough_mid_stream_drop_logs_model_from_url(
+    target: str, custom_llm_provider: str | None, expected_provider: str, stream: bool
+):
+    failure: Final = await _run_passthrough_failure(
+        target, custom_llm_provider, _upstream_dropping_stream(target), stream=stream
+    )
+    assert isinstance(failure.original_exception, httpx.ReadError)
+    assert failure.request_data["model"] == "gemini-3.8-flash"
+    assert failure.request_data["custom_llm_provider"] == expected_provider
+
+
+class _ModifyResponseOnPreCallGuardrail(CustomGuardrail):
+    async def async_pre_call_hook(
+        self,
+        user_api_key_dict: UserAPIKeyAuth,
+        cache: DualCache,
+        data: dict[str, object],
+        call_type: str,
+    ) -> None:
+        self.raise_passthrough_exception(violation_message="blocked by policy", request_data=data, detection_info=None)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "target, custom_llm_provider, body, expected_model, expected_provider",
+    [
+        (_GEMINI_FLASH_TARGET, "gemini", b'{"contents": "not a list"}', "gemini-3.8-flash", "gemini"),
+        (_VERTEX_FLASH_TARGET, None, b'{"contents": "not a list"}', "gemini-3.8-flash", "vertex_ai"),
+        (_VERTEX_FLASH_TARGET, None, b'{"custom_llm_provider": "gemini"}', "gemini-3.8-flash", "vertex_ai"),
+    ],
+)
+async def test_passthrough_guardrail_block_logs_model_from_url(
+    target: str, custom_llm_provider: str | None, body: bytes, expected_model: str, expected_provider: str
+):
+    guardrail: Final = _ModifyResponseOnPreCallGuardrail(
+        guardrail_name="block-policy", event_hook=GuardrailEventHooks.pre_call, default_on=True
+    )
+    failure: Final = await _run_passthrough_failure(
+        target, custom_llm_provider, _upstream_400(target), guardrail=guardrail, body=body
+    )
+    assert isinstance(failure.original_exception, ModifyResponseException)
+    assert failure.request_data["model"] == expected_model
+    assert failure.request_data["custom_llm_provider"] == expected_provider
+    assert PrometheusLogger._extract_api_provider_from_request_data(failure.request_data) == expected_provider
+    assert get_spend_logs_id(CallTypes.pass_through.value, {}, failure.request_data) is not None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("body", [b'{"contents": "not a list"}', b'{"litellm_call_id": "client-chosen-id"}'])
+async def test_passthrough_guardrail_block_response_names_the_call_id_of_its_spend_row(body: bytes):
+    guardrail: Final = _ModifyResponseOnPreCallGuardrail(
+        guardrail_name="block-policy", event_hook=GuardrailEventHooks.pre_call, default_on=True
+    )
+    run: Final = await _run_passthrough(
+        _GEMINI_FLASH_TARGET, "gemini", _upstream_400(_GEMINI_FLASH_TARGET), guardrail=guardrail, body=body
+    )
+    assert isinstance(run.failure.original_exception, ModifyResponseException)
+    assert run.response is not None
+    assert run.response.headers["x-litellm-call-id"] == get_spend_logs_id(
+        CallTypes.pass_through.value, {}, run.failure.request_data
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("body", [b'{"contents": "not a list"}', b'{"custom_llm_provider": "vertex_ai"}'])
+async def test_passthrough_guardrail_block_on_a_user_defined_route_gets_no_url_attribution(body: bytes):
+    guardrail: Final = _ModifyResponseOnPreCallGuardrail(
+        guardrail_name="block-policy", event_hook=GuardrailEventHooks.pre_call, default_on=True
+    )
+    failure: Final = await _run_passthrough_failure(
+        _GEMINI_FLASH_TARGET,
+        None,
+        _upstream_400(_GEMINI_FLASH_TARGET),
+        dispatched_endpoint=_marked_pass_through_endpoint(),
+        guardrail=guardrail,
+        body=body,
+    )
+    assert isinstance(failure.original_exception, ModifyResponseException)
+    assert failure.request_data["model"] == ""
+    assert "custom_llm_provider" not in failure.request_data
+
+
+def _websocket_connect_failure(kind: str) -> Exception:
+    from websockets.datastructures import Headers as WebSocketHeaders
+    from websockets.exceptions import InvalidStatus
+    from websockets.http11 import Response as WebSocketHandshakeResponse
+
+    if kind == "rejected_handshake":
+        return InvalidStatus(WebSocketHandshakeResponse(403, "Forbidden", WebSocketHeaders()))
+    return OSError("connection refused")
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("failure_kind", ["rejected_handshake", "unreachable_host"])
+@pytest.mark.parametrize(
+    "target, builtin_provider_route, expected_provider",
+    [
+        (_VERTEX_LIVE_TARGET, True, "vertex_ai"),
+        (_VERTEX_LIVE_TARGET, False, None),
+        ("wss://api.openai.com/v1/realtime?model=gpt-realtime", True, None),
+    ],
+)
+async def test_websocket_passthrough_connect_failure_logs_the_provider_of_the_upstream_url(
+    failure_kind: str, target: str, builtin_provider_route: bool, expected_provider: str | None
+):
+    failure: Final = await _run_websocket_connect_failure(failure_kind, target, builtin_provider_route)
+    assert failure.request_data.get("custom_llm_provider") == expected_provider
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("failure_kind", ["rejected_handshake", "unreachable_host"])
+@pytest.mark.parametrize("model, expected_model", [("gemini-3.8-live", "gemini-3.8-live"), (None, "")])
+async def test_websocket_passthrough_connect_failure_logs_the_model_the_caller_named(
+    failure_kind: str, model: str | None, expected_model: str
+):
+    failure: Final = await _run_websocket_connect_failure(failure_kind, _VERTEX_LIVE_TARGET, True, model=model)
+    assert failure.request_data["model"] == expected_model
+
+
+async def _run_websocket_connect_failure(
+    failure_kind: str, target: str, builtin_provider_route: bool, model: str | None = None
+) -> _RecordedFailure:
+    recorder: Final = _FailureHookRecorder()
+    with (
+        pytest.MonkeyPatch.context() as litellm_patch,
+        patch(  # test-quality-ok: proxy_logging_obj is a proxy_server module global read inside websocket_passthrough_request; there is no injection seam
+            "litellm.proxy.proxy_server.proxy_logging_obj", ProxyLogging(user_api_key_cache=DualCache())
+        ),
+        patch(
+            "litellm.proxy.pass_through_endpoints.pass_through_endpoints.connect",
+            side_effect=_websocket_connect_failure(failure_kind),
+        ),
+    ):
+        litellm_patch.setattr(litellm, "callbacks", [recorder])
+        await websocket_passthrough_request(
+            websocket=_client_websocket(_pending_receive),
+            target=target,
+            custom_headers={},
+            user_api_key_dict=UserAPIKeyAuth(api_key="sk-test"),
+            endpoint="/vertex_ai/live",
+            accept_websocket=False,
+            builtin_provider_route=builtin_provider_route,
+            model=model,
+        )
+    assert len(recorder.failures) == 1
+    return recorder.failures[0]
+
+
+@pytest.mark.parametrize(
+    "parsed_body, url, custom_llm_provider, expected_model, expected_provider",
+    [
+        ({"model": "from-body"}, _GEMINI_FLASH_TARGET, "gemini", "from-body", "gemini"),
+        ({"contents": []}, _GEMINI_FLASH_TARGET, "gemini", "gemini-3.8-flash", "gemini"),
+        ({"contents": []}, _VERTEX_FLASH_TARGET, None, "gemini-3.8-flash", "vertex_ai"),
+        ({"contents": []}, _VERTEX_FLASH_TARGET, "anthropic", "", "anthropic"),
+        ({}, "https://generativelanguage.googleapis.com/v1beta/openai/models/gemini-3.8-flash", "openai", "", "openai"),
+        ({"custom_llm_provider": "from-body"}, _VERTEX_FLASH_TARGET, None, "gemini-3.8-flash", "vertex_ai"),
+        ({"custom_llm_provider": "gemini"}, _VERTEX_FLASH_TARGET, "anthropic", "", "anthropic"),
+        ({"contents": []}, _GEMINI_FLASH_TARGET, None, "gemini-3.8-flash", "gemini"),
+        (
+            {},
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash?key=provider-secret",
+            "gemini",
+            "gemini-3.8-flash",
+            "gemini",
+        ),
+        (
+            {},
+            "https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5"
+            "/publishers/google/models/gemini-3.8-flash?key=provider-secret",
+            None,
+            "gemini-3.8-flash",
+            "vertex_ai",
+        ),
+        ({}, _VERTEX_CLAUDE_RAW_PREDICT_TARGET, None, "vertex_ai/claude-opus-5", "vertex_ai"),
+        (
+            {},
+            _VERTEX_CLAUDE_RAW_PREDICT_TARGET.replace(":rawPredict", ":streamRawPredict?alt=sse"),
+            None,
+            "claude-opus-5",
+            "vertex_ai",
+        ),
+        ({}, "https://generativelanguage.googleapis.com/v1beta/models?pageToken=/models/x", "gemini", "", "gemini"),
+        (
+            {"contents": []},
+            "https://evilaiplatform.googleapis.com/v1/projects/p/locations/l"
+            "/publishers/google/models/gemini-3.8-flash:generateContent",
+            None,
+            "",
+            None,
+        ),
+        ({}, _VERTEX_SEARCH_TARGET, None, "vertex_ai/search_api", "vertex_ai"),
+        ({}, f"{_VERTEX_FLASH_TARGET}?tag=rawPredict", None, "gemini-3.8-flash", "vertex_ai"),
+        (
+            {},
+            "https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5/batchPredictionJobs"
+            "?filter=:search",
+            None,
+            "",
+            "vertex_ai",
+        ),
+        (
+            {},
+            f"https://generativelanguage.googleapis.com/v1beta{_VEO_OPERATION_SUFFIX}",
+            "gemini",
+            "veo-3.0-generate-001",
+            "gemini",
+        ),
+        (
+            {},
+            "https://us-central1-aiplatform.googleapis.com/v1/projects/p/locations/us-central1"
+            f"/publishers/google{_VEO_OPERATION_SUFFIX}",
+            None,
+            "veo-3.0-generate-001",
+            "vertex_ai",
+        ),
+        (
+            {"contents": []},
+            "https://aiplatform.us.rep.googleapis.com/v1/projects/p/locations/us"
+            "/publishers/google/models/gemini-3.8-flash:generateContent",
+            None,
+            "gemini-3.8-flash",
+            "vertex_ai",
+        ),
+        (
+            {},
+            "https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5/batchPredictionJobs",
+            None,
+            "",
+            "vertex_ai",
+        ),
+        (
+            {"contents": []},
+            _GEMINI_FLASH_TARGET.replace(":generateContent", ":countTokens"),
+            "gemini",
+            "gemini-3.8-flash",
+            "gemini",
+        ),
+        (
+            {"contents": []},
+            _VERTEX_FLASH_TARGET.replace(":generateContent", ":countTokens"),
+            None,
+            "gemini-3.8-flash",
+            "vertex_ai",
+        ),
+        (
+            {"contents": []},
+            "https://aiplatform.googleapis.com/v1/projects/p/locations/global"
+            "/publishers/google/models/gemini-3.8-flash:countTokens",
+            None,
+            "gemini-3.8-flash",
+            "vertex_ai",
+        ),
+        (
+            {},
+            "https://us-central1-aiplatform.googleapis.com/v1/projects/p/locations/us-central1/cachedContents",
+            None,
+            "",
+            "vertex_ai",
+        ),
+        ({"contents": []}, _RELAYED_GEMINI_COUNT_TOKENS_TARGET, "gemini", "gemini-3.8-flash", "gemini"),
+        ({"contents": []}, _RELAYED_VERTEX_COUNT_TOKENS_TARGET, None, "", None),
+        ({"contents": []}, _TRANSLATE_TARGET, None, "", None),
+        ({"contents": []}, _NON_GOOGLE_VERTEX_SHAPED_TARGET, None, "", None),
+        ({"contents": []}, "https://api.example.com/v1/models/gpt-x:countTokens", None, "", None),
+        ({"contents": []}, "https://api.example.com/v1/models/gpt-x:predict", None, "", None),
+        ({"contents": []}, "https://api.example.com/v1/models/gpt-x:thing", None, "", None),
+        (None, None, None, "", None),
+    ],
+)
+def test_build_passthrough_failure_request_payload_model_and_provider_precedence(
+    parsed_body: dict | None,
+    url: str | None,
+    custom_llm_provider: str | None,
+    expected_model: str,
+    expected_provider: str | None,
+):
+    request_payload: Final = _build_passthrough_failure_request_payload(
+        parsed_body=parsed_body,
+        kwargs=None,
+        logging_obj=None,
+        custom_llm_provider=custom_llm_provider,
+        url=httpx.URL(url) if url else None,
+        builtin_provider_route=True,
+    )
+    assert request_payload["model"] == expected_model
+    assert request_payload.get("custom_llm_provider") == expected_provider
+
+
+@pytest.mark.parametrize(
+    "url_route, expected_model",
+    [
+        (_VERTEX_FLASH_TARGET, "gemini-3.8-flash"),
+        (_VERTEX_FLASH_TARGET.replace(":generateContent", ":streamGenerateContent?alt=sse"), "gemini-3.8-flash"),
+        (_VERTEX_FLASH_TARGET.replace(":generateContent", ":predict"), "gemini-3.8-flash"),
+        (_VERTEX_FLASH_TARGET.replace(":generateContent", ":embedContent"), "gemini-3.8-flash"),
+        (_VERTEX_CLAUDE_RAW_PREDICT_TARGET, "vertex_ai/claude-opus-5"),
+        (_VERTEX_CLAUDE_RAW_PREDICT_TARGET.replace(":rawPredict", ":streamRawPredict"), "vertex_ai/claude-opus-5"),
+        (
+            _VERTEX_CLAUDE_RAW_PREDICT_TARGET.replace(":rawPredict", ":streamRawPredict?alt=sse"),
+            "claude-opus-5",
+        ),
+        (_VERTEX_CLAUDE_RAW_PREDICT_TARGET.replace(":rawPredict", ":rawPredict?alt=sse"), "claude-opus-5"),
+        (f"{_VERTEX_FLASH_TARGET}?tag=rawPredict", "gemini-3.8-flash"),
+        (_VERTEX_SEARCH_TARGET, "vertex_ai/search_api"),
+        ("https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5/batchPredictionJobs", None),
+        (
+            "https://us-east5-aiplatform.googleapis.com/v1/projects/p/locations/us-east5/batchPredictionJobs"
+            "?filter=:search",
+            None,
+        ),
+    ],
+)
+def test_vertex_failure_model_name_matches_success_handler_naming(url_route: str, expected_model: str | None):
+    assert VertexPassthroughLoggingHandler.model_from_url_route(url_route) == expected_model
+
+
 @pytest.mark.parametrize("client_metadata_key", ["litellm_metadata", "metadata"])
 def test_passthrough_logs_the_resolved_deployment_model_info_over_the_request_body(client_metadata_key: str):
     """A provider route that resolved a router deployment stashes its model_info on request.state. That
@@ -8598,7 +9181,9 @@ def test_passthrough_logs_the_resolved_deployment_model_info_over_the_request_bo
     the call to (LIT-1761: passthrough successes carried model_id="")."""
     mock_request = MagicMock(spec=Request)
     mock_request.method = "POST"
-    mock_request.url = httpx.URL("http://0.0.0.0:4000/vertex_ai/v1/projects/p/locations/global/publishers/google/models/gemini-3.8-flash:generateContent")
+    mock_request.url = httpx.URL(
+        "http://0.0.0.0:4000/vertex_ai/v1/projects/p/locations/global/publishers/google/models/gemini-3.8-flash:generateContent"
+    )
     mock_request.headers = Headers({})
     mock_request.scope = {}
     mock_request.state = SimpleNamespace(
@@ -9668,12 +10253,14 @@ async def _drain_logging_worker():
     await GLOBAL_LOGGING_WORKER.stop()
     yield
 
+
 @pytest.fixture()
 def _vcr_outcome_gate(request, vcr):
     install_live_call_probe(request, vcr)
     yield
     record_vcr_outcome(request, vcr)
 
+
 @pytest.mark.usefixtures("_drain_logging_worker", "_vcr_outcome_gate")
 def test_update_pass_through_route_updates_registry():
     """
@@ -9763,9 +10350,7 @@ def mock_request():
             return self._dict.values()
 
     class MockRequest:
-        def __init__(
-            self, headers=None, method="POST", request_body: Optional[dict] = None
-        ):
+        def __init__(self, headers=None, method="POST", request_body: Optional[dict] = None):
             self.headers = headers or {}
             self.query_params = QueryParams()
             self.method = method
@@ -9873,9 +10458,9 @@ def test_pass_through_routes_support_all_methods():
                 path = route.path
                 methods = set(route.methods)
                 allowed = PROTOCOL_CONSTRAINED_PASS_THROUGH_ROUTES.get(path, expected_methods)
-                assert (
-                    methods == allowed
-                ), f"Route {path} does not support all methods. Supported: {methods}, Expected: {allowed}"
+                assert methods == allowed, (
+                    f"Route {path} does not support all methods. Supported: {methods}, Expected: {allowed}"
+                )
 
     check_router_methods(llm_router)
 
@@ -9905,19 +10490,11 @@ def test_is_bedrock_agent_runtime_route():
 
     # Test agent runtime endpoints (should return True)
     assert _is_bedrock_agent_runtime_route("/knowledgebases/kb-123/retrieve") is True
-    assert (
-        _is_bedrock_agent_runtime_route("/agents/knowledgebases/kb-123/retrieve")
-        is True
-    )
+    assert _is_bedrock_agent_runtime_route("/agents/knowledgebases/kb-123/retrieve") is True
 
     # Test regular bedrock runtime endpoints (should return False)
-    assert (
-        _is_bedrock_agent_runtime_route("/guardrail/test-id/version/1/apply") is False
-    )
-    assert (
-        _is_bedrock_agent_runtime_route("/model/cohere.command-r-v1:0/converse")
-        is False
-    )
+    assert _is_bedrock_agent_runtime_route("/guardrail/test-id/version/1/apply") is False
+    assert _is_bedrock_agent_runtime_route("/model/cohere.command-r-v1:0/converse") is False
     assert _is_bedrock_agent_runtime_route("/some/random/endpoint") is False
 
 
@@ -9984,9 +10561,7 @@ def test_custom_pricing_used_in_cost_calculation():
 
     # Verify custom cost is different from standard cost (unless prices happen to match)
     # This confirms custom pricing is actually being applied
-    assert (
-        custom_cost != standard_cost
-    ), "Custom pricing should produce different cost than standard pricing"
+    assert custom_cost != standard_cost, "Custom pricing should produce different cost than standard pricing"
 
     # Test 3: Custom pricing with cache_read_input_token_cost and input_cost_per_token_batches
     # This specifically tests the parameters that were causing the original issue
@@ -10562,6 +11137,7 @@ def test_init_kwargs_client_metadata_cannot_mark_a_pass_through_call_as_a_silent
     assert "is_silent_experiment" not in json.loads(row["metadata"])
     assert result["litellm_params"]["metadata"]["client_key"] == "kept"
 
+
 @pytest.mark.asyncio
 async def test_direct_passthrough_keeps_mapped_baggage_tags_outside_upstream_body():
     from litellm.proxy.common_utils.http_parsing_utils import read_request_body
diff --git a/tests/unit/proxy/spend_tracking/test_savings.py b/tests/unit/proxy/spend_tracking/test_savings.py
index f9566fd1ba0..8503a124b01 100644
--- a/tests/unit/proxy/spend_tracking/test_savings.py
+++ b/tests/unit/proxy/spend_tracking/test_savings.py
@@ -137,6 +137,34 @@ def test_compression_savings_priced_at_input_rate():
     assert result.prompt_caching == 0.0
 
 
+def test_an_overflowing_deployment_price_records_finite_savings() -> None:
+    router: Final = Router(
+        model_list=[
+            {
+                "model_name": "overflowing-sonnet",
+                "litellm_params": {
+                    "model": "anthropic/claude-sonnet-5-5",
+                    "input_cost_per_token": 1e308,
+                    "cache_read_input_token_cost": 1e-07,
+                },
+            },
+        ]
+    )
+    deployment_id: Final = router.get_model_list(model_name="overflowing-sonnet")[0]["model_info"]["id"]
+
+    result: Final = compute_savings_spend(
+        model="claude-sonnet-5-5",
+        custom_llm_provider="anthropic",
+        compression_saved_tokens=4389,
+        gateway_injected_cache=True,
+        usage_object=_caching_usage(read=1000, written=0),
+        model_id=deployment_id,
+        llm_router=lambda: router,
+    )
+
+    assert result == (0.0, 0.0, 0.0, 0.0)
+
+
 def test_prompt_caching_savings_priced_at_input_minus_cache_read():
     input_cost, cache_read_cost = _anthropic_costs("claude-sonnet-5")
     # A model that supports prompt caching must charge less to read from cache;
diff --git a/tests/unit/proxy/test_common_request_processing.py b/tests/unit/proxy/test_common_request_processing.py
index 2d08609c93b..a7596b51e3e 100644
--- a/tests/unit/proxy/test_common_request_processing.py
+++ b/tests/unit/proxy/test_common_request_processing.py
@@ -83,6 +83,7 @@ from litellm.proxy.hooks.model_max_budget_limiter import (
     team_member_budget_entity_id,
 )
 from litellm.proxy.utils import ProxyLogging
+from litellm.responses.mcp.parked_stream_dispatch import IN_FLIGHT_ROUND
 from litellm.router import Router
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.utils import ModelResponseListIterator
@@ -9051,6 +9052,33 @@ class TestStreamingClientDisconnectBilling:
 
         proxy_logging_obj.arelease_max_parallel_requests_on_disconnect.assert_awaited_once()
 
+    @pytest.mark.asyncio
+    async def test_disconnect_whose_in_flight_round_billing_raises_still_closes_the_stream_and_frees_the_slot(self):
+        import types
+
+        response = await self._start_partial_stream()
+        closed: Final = AsyncMock()
+
+        async def cannot_price_the_in_flight_round() -> None:
+            raise RuntimeError("the in-flight round could not be priced")
+
+        setattr(response.logging_obj, IN_FLIGHT_ROUND, cannot_price_the_in_flight_round)
+        stream: Final = types.SimpleNamespace(chunks=[], messages=None, aclose=closed)
+        proxy_logging_obj: Final = types.SimpleNamespace(arelease_max_parallel_requests_on_disconnect=AsyncMock())
+
+        await ProxyBaseLLMRequestProcessing._finalize_streaming_generator_cleanup(
+            request=None,
+            request_data={"litellm_logging_obj": response.logging_obj},
+            response=stream,
+            stream_completed=False,
+            client_disconnected=True,
+            user_api_key_dict=MagicMock(),
+            proxy_logging_obj=proxy_logging_obj,
+        )
+
+        closed.assert_awaited_once()
+        proxy_logging_obj.arelease_max_parallel_requests_on_disconnect.assert_awaited_once()
+
     async def _bill_and_collect_success_event(self, prepare=None, request_data=None):
         recorder = _RecordingSuccessLogger()
         original_callbacks = litellm.callbacks
@@ -12468,6 +12496,55 @@ class TestResponseCostFromLoggingObjForCacheHits:
         )
         assert {name: headers.get(name) for name in cost_headers} == dict.fromkeys(cost_headers, expected_header)
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("response_cost", "expected_header"),
+        ((float("nan"), None), (float("inf"), None), (0.0042, "0.0042"), (2, "2")),
+        ids=("nan", "inf", "finite", "int"),
+    )
+    async def test_a_non_finite_response_cost_sends_no_cost_header(
+        self, response_cost: float, expected_header: str | None
+    ):
+        response: Final = litellm.ModelResponse()
+        response._hidden_params = {"response_cost": response_cost}
+
+        headers: Final = await ProxyBaseLLMRequestProcessing.build_litellm_proxy_success_headers_from_llm_response(
+            response=response,
+            request_data={"model": "gpt-5.4-mini"},
+            request=Request({"type": "http", "method": "POST", "headers": []}),
+            user_api_key_dict=ProxyUserAPIKeyAuth(api_key="sk-test"),
+            logging_obj=self._logging_obj(),
+            version=None,
+            proxy_logging_obj=ProxyLogging(user_api_key_cache=DualCache()),
+        )
+
+        assert headers.get("x-litellm-response-cost") == expected_header
+
+    @pytest.mark.asyncio
+    async def test_an_overflowing_cost_breakdown_sends_no_infinite_cost_header(self):
+        response: Final = litellm.ModelResponse()
+        response._hidden_params = {"response_cost": 0.0}
+        logging_obj: Final = self._logging_obj()
+        logging_obj.cost_breakdown = {
+            "original_cost": float("inf"),
+            "input_cost": float("inf"),
+            "output_cost": 0.0012,
+            "total_cost": float("inf"),
+        }
+
+        headers: Final = await ProxyBaseLLMRequestProcessing.build_litellm_proxy_success_headers_from_llm_response(
+            response=response,
+            request_data={"model": "gpt-5.4-mini"},
+            request=Request({"type": "http", "method": "POST", "headers": []}),
+            user_api_key_dict=ProxyUserAPIKeyAuth(api_key="sk-test"),
+            logging_obj=logging_obj,
+            version=None,
+            proxy_logging_obj=ProxyLogging(user_api_key_cache=DualCache()),
+        )
+
+        cost_headers: Final = {name: value for name, value in headers.items() if name.startswith("x-litellm-response-cost")}
+        assert cost_headers == {"x-litellm-response-cost-output": "0.0012"}
+
     def test_a_fresh_zero_cost_v1_messages_call_still_sends_no_cost_header(self):
         logging_obj: Final = self._logging_obj()
         logging_obj.model_call_details["response_cost"] = 0.0
diff --git a/tests/unit/proxy/test_health_check_functions.py b/tests/unit/proxy/test_health_check_functions.py
index 2c0198cd538..79eec44958f 100644
--- a/tests/unit/proxy/test_health_check_functions.py
+++ b/tests/unit/proxy/test_health_check_functions.py
@@ -741,6 +741,7 @@ async def test_perform_health_check_and_save_passes_model_id_to_perform_health_c
         result = await _perform_health_check_and_save(
             model_list=model_list,
             target_model=None,
+            recorded_model_name=None,
             cli_model=None,
             details=True,
             prisma_client=None,
@@ -777,6 +778,7 @@ async def test_perform_health_check_and_save_forwards_skip_disabled_background_f
         await _perform_health_check_and_save(
             model_list=model_list,
             target_model=None,
+            recorded_model_name=None,
             cli_model=None,
             details=True,
             prisma_client=None,
diff --git a/tests/unit/proxy/utils/helpers/test_error_helpers.py b/tests/unit/proxy/utils/helpers/test_error_helpers.py
index df399c8b1d2..b20857dbdaf 100644
--- a/tests/unit/proxy/utils/helpers/test_error_helpers.py
+++ b/tests/unit/proxy/utils/helpers/test_error_helpers.py
@@ -1,13 +1,20 @@
 import asyncio
 import json
+from typing import Final
 from unittest.mock import AsyncMock, MagicMock
 
+import httpx
+import openai
 import pytest
 from fastapi import HTTPException
 from prisma.errors import DataError
 
+import litellm
 from litellm.proxy._types import ProxyErrorTypes, ProxyException
+from litellm.proxy.common_request_processing import proxy_exception_from_route_error
+from litellm.proxy.common_utils.openai_error_payload import proxy_exception_for
 from litellm.proxy.utils import get_error_message_str, handle_exception_on_proxy
+from litellm.types.router import RouterErrors
 
 
 def normalize(value):
@@ -96,7 +103,7 @@ def test_handle_exception_on_proxy_happy_path_http_exception():
     assert snapshot == {
         "is_proxy_exception": True,
         "message": "forbidden",
-        "type": ProxyErrorTypes.internal_server_error.value,
+        "type": "auth_error",
         "code": "403",
     }
 
@@ -156,7 +163,7 @@ def test_handle_exception_on_proxy_uses_attached_status_code_when_present():
     assert snapshot == {
         "code": "418",
         "message": "teapot",
-        "type": ProxyErrorTypes.internal_server_error.value,
+        "type": "invalid_request_error",
     }
 
 
@@ -176,6 +183,176 @@ def test_handle_exception_on_proxy_error_path_none_input_wraps_as_500():
     }
 
 
+@pytest.mark.parametrize(
+    "status_code, expected_type",
+    [
+        (400, "invalid_request_error"),
+        (401, "auth_error"),
+        (403, "auth_error"),
+        (404, "invalid_request_error"),
+        (408, "invalid_request_error"),
+        (409, "invalid_request_error"),
+        (422, "invalid_request_error"),
+        (429, "rate_limit_error"),
+        (500, ProxyErrorTypes.internal_server_error.value),
+        (503, ProxyErrorTypes.internal_server_error.value),
+    ],
+)
+def test_handle_exception_on_proxy_labels_an_http_exception_by_the_status_it_answers(
+    status_code: int, expected_type: str
+):
+    """A management route that rejects a caller's own argument answers 400, and calling that
+    internal_server_error tells the caller's retry loop the gateway is down when nothing but
+    their request is wrong."""
+    result: Final = handle_exception_on_proxy(HTTPException(status_code=status_code, detail="boom"))
+
+    assert (result.code, result.type) == (str(status_code), expected_type)
+
+
+def _exception_carrying_status(carried: int | None, message: str = "boom") -> Exception:
+    class _CarriedStatus(Exception):
+        status_code = carried
+
+    return _CarriedStatus(message)
+
+
+@pytest.mark.parametrize(
+    "status_code, expected_type",
+    [
+        (400, "invalid_request_error"),
+        (404, "invalid_request_error"),
+        (408, "invalid_request_error"),
+        (429, "rate_limit_error"),
+        (500, ProxyErrorTypes.internal_server_error.value),
+    ],
+)
+def test_handle_exception_on_proxy_labels_a_carried_status_the_same_way(status_code: int, expected_type: str):
+    """Routes also reach this handler with plain exceptions carrying their own status, and
+    those must be named by that status rather than all landing on the 500 label."""
+    result: Final = handle_exception_on_proxy(_exception_carrying_status(status_code))
+
+    assert (result.code, result.type) == (str(status_code), expected_type)
+
+
+def test_handle_exception_on_proxy_keeps_the_type_the_exception_already_names():
+    """A rate limit litellm raised already names itself, and overwriting that with the status
+    map's guess would drop what the client branches on."""
+    result: Final = handle_exception_on_proxy(
+        litellm.RateLimitError(message="slow down", llm_provider="openai", model="gpt-4o")
+    )
+
+    assert (result.code, result.type) == ("429", "throttling_error")
+
+
+@pytest.mark.parametrize(
+    "exc",
+    [
+        openai.InternalServerError(
+            message="upstream down",
+            response=httpx.Response(500, request=httpx.Request("GET", "https://api.openai.com/v1/batches/b")),
+            body={"type": "server_error"},
+        ),
+        litellm.Timeout(message="took too long", model="gpt-6.1-sol", llm_provider="openai"),
+        litellm.RateLimitError(message="slow down", llm_provider="openai", model="gpt-6.1-sol"),
+        litellm.AuthenticationError(message="bad key", llm_provider="openai", model="gpt-6.1-sol"),
+        litellm.BadRequestError(message="bad input", model="gpt-6.1-sol", llm_provider="openai"),
+        HTTPException(status_code=404, detail="no such batch"),
+    ],
+    ids=["provider_5xx_naming_its_own_type", "timeout", "rate_limit", "bad_key", "bad_request", "http_404"],
+)
+def test_handle_exception_on_proxy_labels_a_failure_the_way_the_chat_route_does(exc: Exception):
+    """Batch, file, and management routes answer through this handler while chat answers through the route
+    error path, and one client calling both must read the same type for the same failure."""
+    shared: Final = handle_exception_on_proxy(exc)
+    chat: Final = proxy_exception_from_route_error(exc)
+
+    assert (shared.code, shared.type) == (chat.code, chat.type)
+
+
+@pytest.mark.parametrize(
+    "exc",
+    [
+        HTTPException(status_code=400, detail="bad budget_duration"),
+        HTTPException(status_code=401, detail="not allowed"),
+        HTTPException(status_code=403, detail="admin only"),
+        HTTPException(status_code=404, detail="no such team"),
+        litellm.AuthenticationError(message="bad key", llm_provider="openai", model="gpt-6.1-sol"),
+        ValueError(f"{RouterErrors.no_deployments_with_tag_routing.value}=['paid']"),
+        _exception_carrying_status(409, "duplicate credential"),
+    ],
+    ids=["http_400", "http_401", "http_403", "http_404", "provider_401", "tag_denial", "carried_409"],
+)
+def test_handle_exception_on_proxy_labels_a_failure_the_way_route_catch_alls_do(exc: Exception):
+    """Management routes answer some failures through their own catch-all and the rest through this handler,
+    so a client reading /key/list and /key/generate must see the same type and status for the same failure."""
+    shared: Final = handle_exception_on_proxy(exc)
+    catch_all: Final = proxy_exception_for(exc, default_status_code=500)
+
+    assert (shared.code, shared.type, shared.message) == (catch_all.code, catch_all.type, catch_all.message)
+
+
+@pytest.mark.parametrize(
+    "message, expected",
+    [
+        (f"{RouterErrors.no_deployments_with_provider_budget_routing.value}, try later", ("429", "rate_limit_error")),
+        (f"{RouterErrors.no_deployments_with_tag_routing.value}=['paid']", ("401", "auth_error")),
+    ],
+    ids=["no_deployment_left", "no_deployment_for_tags"],
+)
+def test_handle_exception_on_proxy_names_a_router_failure_by_the_status_it_answers(
+    message: str, expected: tuple[str, str]
+):
+    """A router failure that carries no status answers the 429 or 401 its message maps to, and a 429 labelled
+    internal_server_error reads as an outage to a client that branches on the type."""
+    result: Final = handle_exception_on_proxy(ValueError(message))
+
+    assert (result.code, result.type) == expected
+
+
+def test_handle_exception_on_proxy_keeps_the_path_a_rejected_request_names():
+    """A provider rejecting a batch input names the caller's own bucket path, and redacting the /tmp part of it
+    leaves the caller nothing to fix their request with."""
+    result: Final = handle_exception_on_proxy(
+        litellm.BadRequestError(
+            message="Invalid input_file_id gs://my-bucket/tmp/batch_input.jsonl",
+            model="gemini-3.1-pro-preview",
+            llm_provider="vertex_ai",
+        )
+    )
+
+    assert result.code == "400"
+    assert "gs://my-bucket/tmp/batch_input.jsonl" in result.message
+
+
+def test_handle_exception_on_proxy_keeps_the_message_an_exception_with_a_status_carries():
+    """Main sends a status-bearing failure's message verbatim, and relabeling its type must not change that text."""
+    result: Final = handle_exception_on_proxy(_exception_carrying_status(503, "Cannot connect to host 10.12.4.7:8443"))
+
+    assert (result.code, result.message) == ("503", "Cannot connect to host 10.12.4.7:8443")
+
+
+@pytest.mark.parametrize(
+    "message",
+    [
+        "boom",
+        "Cannot connect to host 10.12.4.7:8443",
+        "Cannot connect to host guardrail.internal.svc.cluster.local:443",
+        "Cannot connect to host [fd00::12]:8443",
+    ],
+    ids=["plain", "ipv4", "cluster_dns", "ipv6"],
+)
+def test_handle_exception_on_proxy_answers_a_generic_500_for_an_exception_whose_status_is_none(message: str):
+    """A guardrail whose upstream refuses the connection raises with status_code=None, which crashed the handler
+    into a 503 blaming the auth database, and its text names private hosts no virtual key was ever sent."""
+    result: Final = handle_exception_on_proxy(_exception_carrying_status(None, message))
+
+    assert (result.code, result.type, result.message) == (
+        "500",
+        ProxyErrorTypes.internal_server_error.value,
+        "Internal server error",
+    )
+
+
 @pytest.mark.parametrize(
     "exc",
     [
diff --git a/tests/unit/responses/litellm_completion_transformation/test_anthropic_responses_bridge.py b/tests/unit/responses/litellm_completion_transformation/test_anthropic_responses_bridge.py
index ef198b487b9..0341511496c 100644
--- a/tests/unit/responses/litellm_completion_transformation/test_anthropic_responses_bridge.py
+++ b/tests/unit/responses/litellm_completion_transformation/test_anthropic_responses_bridge.py
@@ -23,6 +23,7 @@ from litellm.responses.litellm_completion_transformation.transformation import (
 )
 from litellm.types.llms.openai import ResponsesAPIStreamEvents
 from litellm.types.utils import Message, ModelResponse
+from tests.unit.proxy.conftest import httpx_transport
 
 
 def test_response_api_handler_merges_metadata_and_service_tier_without_error():
@@ -593,6 +594,31 @@ def _anthropic_message(*content: Mapping[str, object]) -> httpx.Response:
     )
 
 
+@pytest.mark.usefixtures(httpx_transport.__name__)
+@pytest.mark.parametrize("output", ["", [], [{"type": "input_text", "text": ""}]])
+def test_empty_responses_tool_output_reaches_anthropic_without_json_text(
+    respx_mock: respx.MockRouter, output: str | list[dict[str, str]]
+) -> None:
+    route: Final = respx_mock.post(_ANTHROPIC_MESSAGES_URL).mock(
+        return_value=_anthropic_message({"type": "text", "text": "ok"})
+    )
+    response: Final = litellm.responses(
+        model=_MODEL,
+        api_key="mock_api_key",
+        input=[
+            {"role": "user", "content": "Check the weather"},
+            {"type": "function_call", "call_id": "call_empty", "name": "get_weather", "arguments": "{}"},
+            {"type": "function_call_output", "call_id": "call_empty", "output": output},
+        ],
+    )
+    sent: Final = json.loads(route.calls.last.request.content)
+    assert response.output_text == "ok"
+    assert sent["messages"][-1] == {
+        "role": "user",
+        "content": [{"type": "tool_result", "tool_use_id": "call_empty", "content": ""}],
+    }
+
+
 def _replay(output: Sequence[BaseModel]) -> list[object]:
     return [*_FIRST_INPUT, *(item.model_dump(exclude_none=True) for item in output), *_NEXT_INPUT]
 
diff --git a/tests/unit/responses/litellm_completion_transformation/test_function_call_output_normalization.py b/tests/unit/responses/litellm_completion_transformation/test_function_call_output_normalization.py
index 65800e42124..fce06598d29 100644
--- a/tests/unit/responses/litellm_completion_transformation/test_function_call_output_normalization.py
+++ b/tests/unit/responses/litellm_completion_transformation/test_function_call_output_normalization.py
@@ -50,9 +50,10 @@ def test_image_detail_mime_and_adjacent_text_survive_normalization(kind: str, de
         else "data:application/octet-stream;base64,AAAA",
         **({} if nested_url else metadata),
     }
-    parts: Final = [{"type": "input_text", "text": "Screenshot follows"}, image]
+    parts: Final = [{"type": "input_text", "text": ""}, {"type": "input_text", "text": "Screenshot follows"}, image]
     original: Final = deepcopy(parts)
     assert _normalize_media_content(kind, parts) == [
+        *([{"type": "text", "text": ""}] if kind == "direct" else []),
         {"type": "text", "text": "Screenshot follows"},
         {"type": "image_url", "image_url": {"url": "data:application/octet-stream;base64,AAAA", **metadata}},
     ]
@@ -97,6 +98,12 @@ def test_media_normalization_preserves_formats_references_and_metadata(kind: str
     ("output", "expected"),
     [
         (None, ""),
+        ("", ""),
+        ([], ""),
+        ([{"type": "input_text", "text": ""}], ""),
+        ([{"type": kind, "text": ""} for kind in ("input_text", "output_text", "text")], ""),
+        ("[]", "[]"),
+        ([{"type": "input_text", "text": " \n"}], " \n"),
         ('{"ok":true}', '{"ok":true}'),
         ([{"type": "input_text", "text": "hello"}, {"type": "input_text", "text": " world"}], "hello world"),
         ({"type": "file", "status": "ready"}, '{"type": "file", "status": "ready"}'),
@@ -106,6 +113,14 @@ def test_media_normalization_preserves_formats_references_and_metadata(kind: str
         ),
         ({"type": "input_image", "format": 17}, '{"type": "input_image", "format": 17}'),
         ([{"type": "unknown", "value": 17}], '[{"type": "unknown", "value": 17}]'),
+        ([{"type": "input_text", "text": 17}], '[{"type": "input_text", "text": 17}]'),
+        ([{"type": "input_text"}], '[{"type": "input_text"}]'),
+        ([{"type": "input_text", "text": None}], '[{"type": "input_text", "text": null}]'),
+        (
+            [{"type": "input_text", "text": ""}, {"type": "unknown", "value": 17}],
+            '[{"type": "input_text", "text": ""}, {"type": "unknown", "value": 17}]',
+        ),
+        ([{"type": "input_text", "text": ""}, 17], '[{"type": "input_text", "text": ""}, 17]'),
         (
             [{"type": "input_text", "text": "keep"}, {"type": "input_image", "file_id": "file-only"}],
             "keep",
diff --git a/tests/unit/responses/litellm_completion_transformation/test_google_ai_studio_responses_wire.py b/tests/unit/responses/litellm_completion_transformation/test_google_ai_studio_responses_wire.py
index f63088a606f..c7acc70ba95 100644
--- a/tests/unit/responses/litellm_completion_transformation/test_google_ai_studio_responses_wire.py
+++ b/tests/unit/responses/litellm_completion_transformation/test_google_ai_studio_responses_wire.py
@@ -84,6 +84,34 @@ async def test_web_search_preview_is_sent_as_google_search() -> None:
     assert request_body["tools"] == [{"googleSearch": {}}]
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("output", ["", [], [{"type": "input_text", "text": ""}]])
+async def test_empty_responses_tool_output_reaches_gemini_without_json_text(
+    output: str | list[dict[str, str]],
+) -> None:
+    with respx.mock() as mock_router:
+        route: Final = mock_router.post(url__regex=_GEMINI_URL).mock(
+            return_value=httpx.Response(status_code=200, json=_function_call_response("signature"))
+        )
+        response: Final = await litellm.aresponses(
+            model="gemini/gemini-2.5-flash",
+            api_key="test-key",
+            input=[
+                {"role": "user", "content": "Check the weather"},
+                {"type": "function_call", "call_id": "call_empty", "name": "get_weather", "arguments": "{}"},
+                {"type": "function_call_output", "call_id": "call_empty", "output": output},
+            ],
+        )
+        request_body: Final = _JSON_OBJECT.validate_json(route.calls.last.request.content)
+
+    assert isinstance(response, ResponsesAPIResponse)
+    assert request_body["contents"] == [
+        {"role": "user", "parts": [{"text": "Check the weather"}]},
+        {"role": "model", "parts": [{"function_call": {"name": "get_weather", "args": {}}}]},
+        {"role": "user", "parts": [{"function_response": {"name": "get_weather", "response": {"content": ""}}}]},
+    ]
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("assistant_content", "assistant_parts"),
diff --git a/tests/unit/responses/mcp/test_chat_completions_handler.py b/tests/unit/responses/mcp/test_chat_completions_handler.py
index ec5968c2a1a..c0d32742e8a 100644
--- a/tests/unit/responses/mcp/test_chat_completions_handler.py
+++ b/tests/unit/responses/mcp/test_chat_completions_handler.py
@@ -1,17 +1,25 @@
 import asyncio
+import gc
 import json
+import queue
 import sys
+import threading
 import types
-from collections.abc import Mapping, Sequence
+import warnings
+from collections.abc import AsyncIterator, Callable, Iterator, Mapping, Sequence
+from contextlib import contextmanager
 from datetime import datetime
 from types import MappingProxyType
 from typing import Final, cast
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
+import httpx
 import pytest
 import respx
 from httpx import Response
 from mcp.types import Tool as MCPTool
+from starlette.responses import StreamingResponse
+from starlette.types import Message
 
 import litellm
 from litellm.integrations.custom_logger import CustomLogger
@@ -25,7 +33,8 @@ from litellm.responses.mcp.litellm_proxy_mcp_handler import (
     LiteLLM_Proxy_MCP_Handler,
 )
 from litellm.responses.utils import ResponsesAPIRequestUtils
-from litellm.types.utils import ModelResponse, StandardLoggingPayload
+from litellm.types.utils import ModelResponse, ModelResponseStream, StandardLoggingPayload, Usage
+from litellm.utils import CustomStreamWrapper
 
 
 @pytest.mark.asyncio
@@ -1556,6 +1565,7 @@ _CHAT_ROUND_TWO: Final = MappingProxyType(
         ),
     }
 )
+_NEVER_LOGGED_SECONDS: Final = 60
 _CONTEXT_WINDOW_ERROR: Final = MappingProxyType(
     {
         "error": MappingProxyType(
@@ -1575,16 +1585,31 @@ class _ChatRoundRecorder(CustomLogger):
         super().__init__()
         self.logged: tuple[StandardLoggingPayload, ...] = ()
         self.failed: tuple[StandardLoggingPayload, ...] = ()
+        self._recorded: Final = asyncio.Condition()
 
     async def async_log_success_event(
         self, kwargs: Mapping[str, object], response_obj: object, start_time: datetime, end_time: datetime
     ) -> None:
         self.logged = (*self.logged, cast(StandardLoggingPayload, kwargs["standard_logging_object"]))
+        await self._announce()
 
     async def async_log_failure_event(
         self, kwargs: Mapping[str, object], response_obj: object, start_time: datetime, end_time: datetime
     ) -> None:
         self.failed = (*self.failed, cast(StandardLoggingPayload, kwargs["standard_logging_object"]))
+        await self._announce()
+
+    async def _announce(self) -> None:
+        async with self._recorded:
+            self._recorded.notify_all()
+
+    async def settled(self, logged: int = 0, failed: int = 0) -> None:
+        async with self._recorded:
+            await asyncio.wait_for(
+                self._recorded.wait_for(lambda: len(self.logged) >= logged and len(self.failed) >= failed),
+                timeout=_NEVER_LOGGED_SECONDS,
+            )
+        await _settled()
 
 
 def _chat_round_cost(body: Mapping[str, object]) -> float:
@@ -1600,18 +1625,20 @@ async def _settled() -> None:
     await asyncio.wait_for(GLOBAL_LOGGING_WORKER.flush(), timeout=10)
 
 
-async def _auto_execute_chat_echo(
-    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, rounds: Sequence[Response], call_id: str
-) -> tuple[_ChatRoundRecorder, ModelResponse | Exception]:
+def _serve_chat_rounds(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, rounds: Sequence[Response]
+) -> None:
     monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
     monkeypatch.setenv("DISABLE_AIOHTTP_TRANSPORT", "True")
     litellm.in_memory_llm_clients_cache.flush_cache()
     respx_mock.post("https://mcp-chat-rounds.example.com/v1/chat/completions").mock(side_effect=list(rounds))
-    recorder: Final = _ChatRoundRecorder()
-    logging_obj: Final = Logging(
+
+
+def _chat_rounds_logging_obj(recorder: _ChatRoundRecorder, call_id: str, stream: bool) -> Logging:
+    return Logging(
         model="openai/gpt-5.6",
         messages=[{"role": "user", "content": "Call echo with PING"}],
-        stream=False,
+        stream=stream,
         call_type="acompletion",
         start_time=datetime(2026, 1, 1),
         litellm_call_id=call_id,
@@ -1619,6 +1646,10 @@ async def _auto_execute_chat_echo(
         dynamic_async_success_callbacks=[recorder],
         dynamic_async_failure_callbacks=[recorder],
     )
+
+
+@contextmanager
+def _echo_tool_served() -> Iterator[None]:
     echo_tool: Final = MCPTool.model_validate(
         {"name": "echo", "inputSchema": {"type": "object", "properties": {"value": {"type": "string"}}}},
         by_name=False,
@@ -1635,6 +1666,16 @@ async def _auto_execute_chat_echo(
             AsyncMock(return_value=[{"tool_call_id": "call_echo", "result": "PING", "name": "echo"}]),
         ),
     ):
+        yield
+
+
+async def _auto_execute_chat_echo(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, rounds: Sequence[Response], call_id: str
+) -> tuple[_ChatRoundRecorder, ModelResponse | Exception]:
+    _serve_chat_rounds(respx_mock, monkeypatch, rounds)
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, call_id, stream=False)
+    with _echo_tool_served():
         try:
             response: Final = await litellm.acompletion(
                 model="openai/gpt-5.6",
@@ -1712,3 +1753,994 @@ async def test_non_stream_auto_execute_bills_the_paid_first_round_when_the_follo
     assert (recorder.failed[0]["prompt_tokens"], recorder.failed[0]["completion_tokens"]) == (71, 19)
     assert recorder.failed[0]["response_cost"] == pytest.approx(_chat_round_cost(_CHAT_ROUND_ONE))
     assert recorder.failed[0]["response_cost"] > 0
+
+
+_FIXED_MARGIN: Final = 0.001
+
+
+def _chat_stream_events(body: Mapping[str, object]) -> tuple[Mapping[str, object], ...]:
+    completed: Final = json.loads(json.dumps(body, default=dict))
+    choice: Final = completed["choices"][0]
+    message: Final = choice["message"]
+    calls: Final = message.get("tool_calls") or []
+    delta: Final = (
+        {**message, "tool_calls": [{**call, "index": index} for index, call in enumerate(calls)]} if calls else message
+    )
+    head: Final = {"id": completed["id"], "object": "chat.completion.chunk", "created": 1, "model": completed["model"]}
+    return (
+        {**head, "choices": [{"index": 0, "delta": delta, "finish_reason": None}]},
+        {**head, "choices": [{"index": 0, "delta": {}, "finish_reason": choice["finish_reason"]}]},
+        {**head, "choices": [], "usage": completed["usage"]},
+    )
+
+
+def _sse(events: Sequence[Mapping[str, object]]) -> bytes:
+    return b"".join(f"data: {json.dumps(event)}\n\n".encode() for event in events)
+
+
+def _streamed(body: Mapping[str, object]) -> Response:
+    return Response(
+        200,
+        content=_sse(_chat_stream_events(body)) + b"data: [DONE]\n\n",
+        headers={"content-type": "text/event-stream"},
+    )
+
+
+class _CutOnceTheAnswerStarts(httpx.AsyncByteStream):
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield _sse(_chat_stream_events(_CHAT_ROUND_TWO)[:1])
+        raise httpx.ReadError("connection reset mid-stream")
+
+
+def _cut_once_the_answer_starts() -> Response:
+    return Response(200, stream=_CutOnceTheAnswerStarts(), headers={"content-type": "text/event-stream"})
+
+
+async def _open_chat_echo_stream(
+    logging_obj: Logging, metadata: dict[str, object] | None = None
+) -> CustomStreamWrapper:
+    stream: Final = await litellm.acompletion(
+        model="openai/gpt-5.6",
+        messages=[{"role": "user", "content": "Call echo with PING"}],
+        tools=[{"type": "mcp", "server_url": "litellm_proxy/mcp/demo", "require_approval": "never"}],
+        api_key="sk-mcp-chat-rounds",
+        api_base="https://mcp-chat-rounds.example.com/v1",
+        stream=True,
+        stream_options={"include_usage": True},
+        litellm_logging_obj=logging_obj,
+        metadata=metadata,
+    )
+    assert isinstance(stream, CustomStreamWrapper)
+    return stream
+
+
+async def _read_all(stream: CustomStreamWrapper) -> tuple[ModelResponseStream, ...]:
+    return tuple([chunk async for chunk in stream])
+
+
+async def _read_until(stream: CustomStreamWrapper, content: str) -> None:
+    async for chunk in stream:
+        if chunk.choices and chunk.choices[0].delta.content == content:
+            return
+    pytest.fail(f"the stream never sent {content!r}")
+
+
+def _streamed_usage(chunks: Sequence[ModelResponseStream]) -> Usage:
+    usages: Final = tuple(usage for chunk in chunks if isinstance(usage := getattr(chunk, "usage", None), Usage))
+    assert len(usages) == 1, usages
+    return usages[0]
+
+
+def _assert_one_stream_row_bills_both_rounds_once(
+    logged: Sequence[StandardLoggingPayload], chunks: Sequence[ModelResponseStream]
+) -> None:
+    charged_once: Final = _chat_round_cost(_CHAT_ROUND_ONE) + _chat_round_cost(_CHAT_ROUND_TWO) - _FIXED_MARGIN
+    assert len(logged) == 1
+    row: Final = logged[0]
+    assert row["id"] == chunks[0].id
+    assert (row["prompt_tokens"], row["completion_tokens"]) == (71 + 149, 19 + 5)
+    assert row["metadata"]["usage_object"]["prompt_tokens_details"]["cached_tokens"] == 32 + 64
+    assert row["response_cost"] == pytest.approx(charged_once)
+    assert row["cost_breakdown"]["total_cost"] == pytest.approx(charged_once)
+    assert row["metadata"]["usage_object"]["cost"] == pytest.approx(row["response_cost"])
+    usage: Final = _streamed_usage(chunks)
+    assert (usage.prompt_tokens, usage.completion_tokens, usage.total_tokens) == (71 + 149, 19 + 5, 90 + 154)
+    assert usage.cost == pytest.approx(row["response_cost"])
+
+
+def _prompt_tokens_the_follow_up_sent(respx_mock: respx.MockRouter) -> int:
+    follow_up_request: Final = json.loads(respx_mock.calls[1].request.content)
+    return litellm.token_counter(model="gpt-5.6", messages=follow_up_request["messages"])
+
+
+def _assert_one_row_bills_round_one(logged: Sequence[StandardLoggingPayload]) -> None:
+    assert len(logged) == 1
+    assert (logged[0]["prompt_tokens"], logged[0]["completion_tokens"]) == (71, 19)
+    assert logged[0]["response_cost"] == pytest.approx(_chat_round_cost(_CHAT_ROUND_ONE))
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_read_to_the_end_logs_one_row_whose_usage_cost_counts_the_fixed_margin_once(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-read-to-the-end", stream=True)
+
+    with _echo_tool_served():
+        chunks: Final = await _read_all(await _open_chat_echo_stream(logging_obj))
+    await recorder.settled(logged=1)
+
+    _assert_one_stream_row_bills_both_rounds_once(recorder.logged, chunks)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_deferred_for_a_post_call_guardrail_logs_both_rounds_once_when_the_proxy_releases(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+    from litellm.proxy.utils import ProxyLogging
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-rounds-deferred", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+            response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+        )
+        chunks: Final = await _read_all(stream)
+    await _settled()
+    logged_before_release: Final = recorder.logged
+    ProxyLogging.fire_deferred_stream_logging({"litellm_logging_obj": logging_obj})
+    await recorder.settled(logged=1)
+
+    assert logged_before_release == ()
+    _assert_one_stream_row_bills_both_rounds_once(recorder.logged, chunks)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_blocked_by_a_post_call_guardrail_bills_both_rounds_on_the_failure_row(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    from litellm.exceptions import GuardrailRaisedException
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+    from litellm.proxy.utils import ProxyLogging
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-rounds-blocked", stream=True)
+    blocked: Final = GuardrailRaisedException(guardrail_name="output-policy", message="blocked")
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+            response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+        )
+        await _read_all(stream)
+    assert ProxyLogging._discard_deferred_stream_logging_for_failure({"litellm_logging_obj": logging_obj}, blocked)
+    await logging_obj.async_failure_handler(blocked, "blocked by output-policy")
+    await recorder.settled(failed=1)
+
+    charged_once: Final = _chat_round_cost(_CHAT_ROUND_ONE) + _chat_round_cost(_CHAT_ROUND_TWO) - _FIXED_MARGIN
+    assert recorder.logged == ()
+    assert len(recorder.failed) == 1
+    assert (recorder.failed[0]["prompt_tokens"], recorder.failed[0]["completion_tokens"]) == (71 + 149, 19 + 5)
+    assert recorder.failed[0]["response_cost"] == pytest.approx(charged_once)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_rejected_by_the_proxy_during_the_follow_up_bills_round_one_with_its_own_breakdown(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    from fastapi import HTTPException
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+    from litellm.proxy.utils import ProxyLogging
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-rejected-mid-follow-up", stream=True)
+    rejected: Final = HTTPException(status_code=400, detail="rejected by a stream hook")
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+            response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+        )
+        await _read_until(stream, "PING")
+        assert ProxyLogging._discard_deferred_stream_logging_for_failure({"litellm_logging_obj": logging_obj}, rejected)
+        await logging_obj.async_failure_handler(rejected, "rejected by a stream hook")
+        await recorder.settled(failed=1)
+
+    assert recorder.logged == ()
+    assert len(recorder.failed) == 1
+    failed: Final = recorder.failed[0]
+    breakdown: Final = failed["cost_breakdown"]
+    assert (failed["prompt_tokens"], failed["completion_tokens"]) == (71, 19)
+    assert failed["response_cost"] == pytest.approx(_chat_round_cost(_CHAT_ROUND_ONE))
+    assert breakdown is not None
+    assert breakdown["total_cost"] == pytest.approx(failed["response_cost"])
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_answered_without_a_tool_call_logs_its_one_round_once_the_answer_finishes(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_TWO),))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-one-round", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        async for chunk in stream:
+            if chunk.choices and chunk.choices[0].finish_reason is not None:
+                break
+        await recorder.settled(logged=1)
+        logged_once_the_answer_finished: Final = recorder.logged
+        after_the_answer: Final = await _read_all(stream)
+        await _settled()
+
+    assert len(logged_once_the_answer_finished) == 1
+    assert recorder.logged == logged_once_the_answer_finished
+    assert recorder.logged[0]["id"] == _CHAT_ROUND_TWO["id"]
+    assert (recorder.logged[0]["prompt_tokens"], recorder.logged[0]["completion_tokens"]) == (149, 5)
+    assert after_the_answer[-1:] and isinstance(after_the_answer[-1].usage, Usage)
+    usage: Final = _streamed_usage(after_the_answer)
+    assert (usage.prompt_tokens, usage.completion_tokens, usage.total_tokens) == (
+        recorder.logged[0]["prompt_tokens"],
+        recorder.logged[0]["completion_tokens"],
+        recorder.logged[0]["total_tokens"],
+    )
+    assert recorder.logged[0]["response_cost"] == pytest.approx(_chat_round_cost(_CHAT_ROUND_TWO))
+    assert recorder.failed == ()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("closes", (True, False), ids=("aclose", "dropped"))
+async def test_stream_auto_execute_bills_the_finished_first_round_when_the_caller_stops_reading_the_follow_up(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, closes: bool
+):
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-caller-stops", stream=True)
+
+    async def stop_reading_once_the_follow_up_answers() -> None:
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        await _read_until(stream, "PING")
+        if closes:
+            await stream.aclose()
+
+    with _echo_tool_served():
+        await stop_reading_once_the_follow_up_answers()
+        await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_whose_first_round_breaks_mid_answer_bills_only_its_failure_row(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    _serve_chat_rounds(respx_mock, monkeypatch, (_cut_once_the_answer_starts(),))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-first-round-breaks", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        with pytest.raises(litellm.ServiceUnavailableError):
+            await _read_all(stream)
+    await recorder.settled(failed=1)
+
+    assert recorder.logged == ()
+    assert len(recorder.failed) == 1
+    assert recorder.failed[0]["completion_tokens"] > 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_bills_a_broken_follow_up_on_its_own_failure_row_with_no_second_fixed_margin(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+    from litellm.proxy.utils import ProxyLogging, _failure_fields_to_lift
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _cut_once_the_answer_starts()))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-follow-up-breaks", stream=True)
+    request_data: Final = MappingProxyType({"litellm_logging_obj": logging_obj})
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        with pytest.raises(litellm.ServiceUnavailableError) as broken:
+            await _read_all(stream)
+    if not ProxyLogging._discard_deferred_stream_logging_for_failure(dict(request_data), broken.value):
+        ProxyLogging.fire_deferred_stream_logging(dict(request_data))
+    await recorder.settled(logged=1, failed=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+    assert len(recorder.failed) == 1
+    failed: Final = recorder.failed[0]
+    unmargined: Final = (
+        litellm.completion_cost(
+            completion_response=ModelResponse(
+                model="gpt-5.6",
+                usage=Usage(
+                    prompt_tokens=failed["prompt_tokens"],
+                    completion_tokens=failed["completion_tokens"],
+                    total_tokens=failed["total_tokens"],
+                ),
+            ),
+            model="gpt-5.6",
+            custom_llm_provider="openai",
+        )
+        - _FIXED_MARGIN
+    )
+    assert failed["prompt_tokens"] == _prompt_tokens_the_follow_up_sent(respx_mock)
+    assert failed["completion_tokens"] > 0
+    assert failed["response_cost"] == pytest.approx(unmargined)
+    request_failure: Final = _failure_fields_to_lift(request_data)
+    assert cast(StandardLoggingPayload, request_failure["standard_logging_object"])["id"] != recorder.logged[0]["id"]
+    assert request_failure["response_cost"] == pytest.approx(unmargined)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_whose_follow_up_breaks_reports_the_request_guardrail_result_on_the_failure_row_only(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.integrations.custom_guardrail import CustomGuardrail
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+    from litellm.proxy.utils import ProxyLogging
+
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _cut_once_the_answer_starts()))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-follow-up-breaks-guarded", stream=True)
+    metadata: Final[dict[str, object]] = {}
+    request_data: Final = {"metadata": metadata, "litellm_logging_obj": logging_obj}
+    content_filter: Final = CustomGuardrail(guardrail_name="request-content-filter", event_hook="post_call")
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj, metadata)
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        with pytest.raises(litellm.ServiceUnavailableError) as broken:
+            await _read_all(stream)
+    content_filter.add_standard_logging_guardrail_information_to_request_data(
+        guardrail_json_response=str(broken.value),
+        request_data=request_data,
+        guardrail_status="guardrail_failed_to_respond",
+    )
+    if not ProxyLogging._discard_deferred_stream_logging_for_failure(request_data, broken.value):
+        ProxyLogging.fire_deferred_stream_logging(request_data)
+    await recorder.settled(logged=1, failed=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+    assert recorder.logged[0]["guardrail_information"] is None
+    assert [entry["guardrail_name"] for entry in recorder.failed[0]["guardrail_information"] or ()] == [
+        "request-content-filter"
+    ]
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_served_through_the_proxy_stream_hook_logs_both_rounds_once_when_it_ends(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    from litellm.caching.caching import DualCache
+    from litellm.proxy._types import UserAPIKeyAuth
+    from litellm.proxy.utils import ProxyLogging
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-proxy-stream-hook", stream=True)
+
+    with _echo_tool_served():
+        served: Final = ProxyLogging(user_api_key_cache=DualCache()).async_post_call_streaming_iterator_hook(
+            response=await _open_chat_echo_stream(logging_obj),
+            user_api_key_dict=UserAPIKeyAuth(),
+            request_data={"litellm_logging_obj": logging_obj},
+        )
+        chunks: Final = tuple([chunk async for chunk in served])
+    await recorder.settled(logged=1)
+
+    _assert_one_stream_row_bills_both_rounds_once(recorder.logged, chunks)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_whose_follow_up_streams_nothing_still_bills_the_first_round_once(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    nothing_streamed: Final = Response(200, content=b"data: [DONE]\n\n", headers={"content-type": "text/event-stream"})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), nothing_streamed))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-empty-follow-up", stream=True)
+
+    with _echo_tool_served():
+        await _read_all(await _open_chat_echo_stream(logging_obj))
+    await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+
+
+_ANSWER_WITH_UNREADABLE_AUDIO: Final = MappingProxyType(
+    {
+        **_CHAT_ROUND_TWO,
+        "choices": (
+            MappingProxyType(
+                {
+                    "index": 0,
+                    "finish_reason": "stop",
+                    "message": MappingProxyType(
+                        {
+                            "role": "assistant",
+                            "content": "PING",
+                            "audio": MappingProxyType({"id": "audio_echo", "data": "not base64", "transcript": "PING"}),
+                        }
+                    ),
+                }
+            ),
+        ),
+    }
+)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_whose_follow_up_cannot_be_assembled_ends_with_the_usage_of_the_round_it_billed(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_ANSWER_WITH_UNREADABLE_AUDIO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-follow-up-unassembled", stream=True)
+
+    with _echo_tool_served():
+        chunks: Final = await _read_all(await _open_chat_echo_stream(logging_obj))
+    await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+    assert any(chunk.choices and chunk.choices[0].delta.content == "PING" for chunk in chunks)
+    usage: Final = _streamed_usage(chunks)
+    assert (usage.prompt_tokens, usage.completion_tokens, usage.total_tokens) == (71, 19, 90)
+    assert usage.cost == pytest.approx(recorder.logged[0]["response_cost"])
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+@pytest.mark.parametrize("answer", [_CHAT_ROUND_TWO, _ANSWER_WITH_UNREADABLE_AUDIO], ids=("assembled", "unassembled"))
+async def test_stream_auto_execute_sends_its_usage_chunk_under_the_id_of_the_row_it_billed(
+    respx_mock: respx.MockRouter,
+    monkeypatch: pytest.MonkeyPatch,
+    deferred_for_a_post_call_guardrail: bool,
+    answer: Mapping[str, object],
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+    from litellm.proxy.utils import ProxyLogging
+
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(answer)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-usage-chunk-id", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        chunks: Final = await _read_all(stream)
+    ProxyLogging.fire_deferred_stream_logging({"litellm_logging_obj": logging_obj})
+    await recorder.settled(logged=1)
+
+    usage_chunks: Final = tuple(chunk for chunk in chunks if isinstance(getattr(chunk, "usage", None), Usage))
+    answer_chunks: Final = tuple(chunk for chunk in chunks if chunk.choices and chunk.choices[0].delta.content == "PING")
+    assert len(recorder.logged) == 1
+    assert [chunk.id for chunk in answer_chunks] == [_CHAT_ROUND_TWO["id"]]
+    assert len(usage_chunks) == 1
+    assert usage_chunks[0].id == chunks[0].id == recorder.logged[0]["id"] == _CHAT_ROUND_ONE["id"]
+
+
+def _assert_one_row_bills_round_one_and_the_partial_answer(
+    recorder: _ChatRoundRecorder, respx_mock: respx.MockRouter
+) -> None:
+    assert len(recorder.logged) == 1
+    row: Final = recorder.logged[0]
+    assert row["id"] == _CHAT_ROUND_ONE["id"]
+    partial_prompt, partial_completion = (row["prompt_tokens"] - 71, row["completion_tokens"] - 19)
+    assert partial_prompt == _prompt_tokens_the_follow_up_sent(respx_mock)
+    assert partial_completion > 0
+    partial_answer: Final = litellm.completion_cost(
+        completion_response=ModelResponse(
+            model="gpt-5.6",
+            usage=Usage(
+                prompt_tokens=partial_prompt,
+                completion_tokens=partial_completion,
+                total_tokens=partial_prompt + partial_completion,
+            ),
+        ),
+        model="gpt-5.6",
+        custom_llm_provider="openai",
+    )
+    assert row["response_cost"] == pytest.approx(_chat_round_cost(_CHAT_ROUND_ONE) + partial_answer - _FIXED_MARGIN)
+    assert recorder.failed == ()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_hung_up_during_the_follow_up_bills_round_one_and_the_partial_answer_on_one_row(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-hung-up-mid-answer", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        await _read_until(stream, "PING")
+        await ProxyBaseLLMRequestProcessing.finalize_streaming_generator_cleanup(
+            request=None, request_data={"litellm_logging_obj": logging_obj}, response=stream, client_disconnected=True
+        )
+    await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one_and_the_partial_answer(recorder, respx_mock)
+
+
+def _chat_rounds_router() -> litellm.Router:
+    return litellm.Router(
+        model_list=[
+            {
+                "model_name": "mcp-chat-rounds",
+                "litellm_params": {
+                    "model": "openai/gpt-5.6",
+                    "api_key": "sk-mcp-chat-rounds",
+                    "api_base": "https://mcp-chat-rounds.example.com/v1",
+                },
+            }
+        ]
+    )
+
+
+class _StallsOnceTheAnswerStarts(httpx.AsyncByteStream):
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield _sse(_chat_stream_events(_CHAT_ROUND_TWO)[:1])
+        await asyncio.Event().wait()
+
+
+def _streams_content(body: object, content: str) -> bool:
+    lines: Final = body.decode().splitlines() if isinstance(body, bytes) else ()
+    events: Final = tuple(json.loads(line.removeprefix("data: ")) for line in lines if line.startswith("data: {"))
+    return any(event["choices"] and event["choices"][0]["delta"].get("content") == content for event in events)
+
+
+async def _serve_until_the_client_hangs_up_after(response: StreamingResponse, content: str) -> None:
+    read: Final = asyncio.Event()
+
+    async def receive() -> Message:
+        await read.wait()
+        return {"type": "http.disconnect"}
+
+    async def send(message: Message) -> None:
+        if message["type"] == "http.response.body" and _streams_content(message.get("body"), content):
+            read.set()
+
+    uvicorn_scope: Final = {"type": "http", "asgi": {"version": "3.0", "spec_version": "2.3"}, "headers": []}
+    await response(uvicorn_scope, receive, send)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_routed_through_the_proxy_bills_the_partial_answer_when_the_client_hangs_up(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.proxy import proxy_server
+    from litellm.proxy._types import UserAPIKeyAuth
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing, create_response
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(
+        respx_mock,
+        monkeypatch,
+        (
+            _streamed(_CHAT_ROUND_ONE),
+            Response(200, stream=_StallsOnceTheAnswerStarts(), headers={"content-type": "text/event-stream"}),
+        ),
+    )
+    router: Final = _chat_rounds_router()
+    monkeypatch.setattr(proxy_server, "llm_router", router)
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-routed-hang-up", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await router.acompletion(
+            model="mcp-chat-rounds",
+            messages=[{"role": "user", "content": "Call echo with PING"}],
+            tools=[{"type": "mcp", "server_url": "litellm_proxy/mcp/demo", "require_approval": "never"}],
+            stream=True,
+            stream_options={"include_usage": True},
+            litellm_logging_obj=logging_obj,
+        )
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        served: Final = await create_response(
+            proxy_server.async_data_generator(
+                response=stream,
+                user_api_key_dict=UserAPIKeyAuth(),
+                request_data={"litellm_logging_obj": logging_obj, "model": "mcp-chat-rounds", "metadata": {}},
+            ),
+            "text/event-stream",
+            {},
+        )
+        assert isinstance(served, StreamingResponse)
+        await _serve_until_the_client_hangs_up_after(served, "PING")
+    await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one_and_the_partial_answer(recorder, respx_mock)
+
+
+async def _stop_reading_once_the_proxy_sent(served: AsyncIterator[object], content: str) -> None:
+    async for frame in served:
+        if _streams_content(frame, content):
+            return
+    pytest.fail(f"the proxy never sent {content!r}")
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_routed_through_the_proxy_bills_the_partial_answer_when_hung_up_between_reads(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.proxy import proxy_server
+    from litellm.proxy._types import UserAPIKeyAuth
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    router: Final = _chat_rounds_router()
+    monkeypatch.setattr(proxy_server, "llm_router", router)
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-routed-hang-up-between-reads", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await router.acompletion(
+            model="mcp-chat-rounds",
+            messages=[{"role": "user", "content": "Call echo with PING"}],
+            tools=[{"type": "mcp", "server_url": "litellm_proxy/mcp/demo", "require_approval": "never"}],
+            stream=True,
+            stream_options={"include_usage": True},
+            litellm_logging_obj=logging_obj,
+        )
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        served: Final = proxy_server.async_data_generator(
+            response=stream,
+            user_api_key_dict=UserAPIKeyAuth(),
+            request_data={"litellm_logging_obj": logging_obj, "model": "mcp-chat-rounds", "metadata": {}},
+        )
+        await _stop_reading_once_the_proxy_sent(served, "PING")
+        await served.aclose()
+    await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one_and_the_partial_answer(recorder, respx_mock)
+
+
+_LONGEST_WAIT_FOR_THE_LOOP_TO_MOVE_SECONDS: Final = 10
+
+
+class _CountsTheToolResultWhileTheLoopRuns:
+    def __init__(self, loop: asyncio.AbstractEventLoop, count: Callable[..., int]) -> None:
+        self._loop: Final = loop
+        self._count: Final = count
+        self._counting: Final = asyncio.Event()
+        self._loop_moved: Final = threading.Event()
+        self.loop_moved_while_counting: tuple[bool, ...] = ()
+
+    def __call__(self, model: str | None = None, messages: list[object] | None = None, **kwargs: object) -> int:
+        if any(isinstance(message, Mapping) and message.get("role") == "tool" for message in messages or ()):
+            self._loop.call_soon_threadsafe(self._counting.set)
+            moved: Final = self._loop_moved.wait(timeout=_LONGEST_WAIT_FOR_THE_LOOP_TO_MOVE_SECONDS)
+            self.loop_moved_while_counting = (*self.loop_moved_while_counting, moved)
+        return self._count(model=model, messages=messages, **kwargs)
+
+    async def keep_the_loop_moving(self) -> None:
+        await self._counting.wait()
+        self._loop_moved.set()
+
+
+@contextmanager
+def _partial_count_watched(monkeypatch: pytest.MonkeyPatch) -> Iterator[_CountsTheToolResultWhileTheLoopRuns]:
+    from litellm.litellm_core_utils import streaming_chunk_builder_utils
+
+    counter: Final = _CountsTheToolResultWhileTheLoopRuns(
+        asyncio.get_running_loop(), streaming_chunk_builder_utils.token_counter
+    )
+    monkeypatch.setattr(streaming_chunk_builder_utils, "token_counter", counter)
+    other_task: Final = asyncio.create_task(counter.keep_the_loop_moving())
+    try:
+        yield counter
+    finally:
+        other_task.cancel()
+
+
+class _StallsAfterTheAnswerStarts(httpx.AsyncByteStream):
+    def __init__(self) -> None:
+        self.stalled: Final = asyncio.Event()
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield _sse(_chat_stream_events(_CHAT_ROUND_TWO)[:1])
+        self.stalled.set()
+        await asyncio.Event().wait()
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_cancelled_mid_answer_counts_the_partial_off_the_loop_and_bills_it_once(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    answer: Final = _StallsAfterTheAnswerStarts()
+    _serve_chat_rounds(
+        respx_mock,
+        monkeypatch,
+        (_streamed(_CHAT_ROUND_ONE), Response(200, stream=answer, headers={"content-type": "text/event-stream"})),
+    )
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-cancelled-off-the-loop", stream=True)
+
+    with _echo_tool_served(), _partial_count_watched(monkeypatch) as counter:
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        reading: Final = asyncio.create_task(_read_all(stream))
+        await asyncio.wait_for(answer.stalled.wait(), timeout=10)
+        reading.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await reading
+        await stream.aclose()
+        await recorder.settled(logged=1)
+
+    assert counter.loop_moved_while_counting == (True,)
+    _assert_one_row_bills_round_one_and_the_partial_answer(recorder, respx_mock)
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_routed_through_the_proxy_and_closed_between_reads_counts_the_partial_off_the_loop(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    from litellm.proxy import proxy_server
+    from litellm.proxy._types import UserAPIKeyAuth
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    router: Final = _chat_rounds_router()
+    monkeypatch.setattr(proxy_server, "llm_router", router)
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-routed-closed-off-the-loop", stream=True)
+
+    with _echo_tool_served(), _partial_count_watched(monkeypatch) as counter:
+        stream: Final = await router.acompletion(
+            model="mcp-chat-rounds",
+            messages=[{"role": "user", "content": "Call echo with PING"}],
+            tools=[{"type": "mcp", "server_url": "litellm_proxy/mcp/demo", "require_approval": "never"}],
+            stream=True,
+            stream_options={"include_usage": True},
+            litellm_logging_obj=logging_obj,
+        )
+        served: Final = proxy_server.async_data_generator(
+            response=stream,
+            user_api_key_dict=UserAPIKeyAuth(),
+            request_data={"litellm_logging_obj": logging_obj, "model": "mcp-chat-rounds", "metadata": {}},
+        )
+        await _stop_reading_once_the_proxy_sent(served, "PING")
+        await served.aclose()
+        await recorder.settled(logged=1)
+
+    assert counter.loop_moved_while_counting == (True,)
+    _assert_one_row_bills_round_one_and_the_partial_answer(recorder, respx_mock)
+
+
+class _StallsBeforeTheAnswerStarts(httpx.AsyncByteStream):
+    def __init__(self) -> None:
+        self.opened: Final = asyncio.Event()
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield b": the answer has not started\n\n"
+        self.opened.set()
+        await asyncio.Event().wait()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_hung_up_before_the_answer_starts_bills_round_one_alone_on_one_row(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+
+    answer: Final = _StallsBeforeTheAnswerStarts()
+    _serve_chat_rounds(
+        respx_mock,
+        monkeypatch,
+        (_streamed(_CHAT_ROUND_ONE), Response(200, stream=answer, headers={"content-type": "text/event-stream"})),
+    )
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-hung-up-before-answer", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        reading: Final = asyncio.create_task(_read_all(stream))
+        await asyncio.wait_for(answer.opened.wait(), timeout=10)
+        reading.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await reading
+        await ProxyBaseLLMRequestProcessing.finalize_streaming_generator_cleanup(
+            request=None, request_data={"litellm_logging_obj": logging_obj}, response=stream, client_disconnected=True
+        )
+    await recorder.settled(logged=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+    assert recorder.failed == ()
+
+
+async def _read_through_the_usage_chunk(
+    chunks: AsyncIterator[ModelResponseStream], read: tuple[ModelResponseStream, ...] = ()
+) -> tuple[ModelResponseStream, ...]:
+    chunk: Final = await anext(chunks)
+    if isinstance(getattr(chunk, "usage", None), Usage):
+        return (*read, chunk)
+    return await _read_through_the_usage_chunk(chunks, (*read, chunk))
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("deferred_for_a_post_call_guardrail", [False, True])
+async def test_stream_auto_execute_hung_up_after_its_whole_answer_bills_both_rounds_once(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch, deferred_for_a_post_call_guardrail: bool
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+
+    monkeypatch.setattr(litellm, "cost_margin_config", {"openai": {"fixed_amount": _FIXED_MARGIN}})
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-hung-up-after-answer", stream=True)
+
+    with _echo_tool_served():
+        stream: Final = await _open_chat_echo_stream(logging_obj)
+        if deferred_for_a_post_call_guardrail:
+            ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+                response=stream, route_type="acompletion", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+            )
+        chunks: Final = await _read_through_the_usage_chunk(aiter(stream))
+        await ProxyBaseLLMRequestProcessing.finalize_streaming_generator_cleanup(
+            request=None, request_data={"litellm_logging_obj": logging_obj}, response=stream, client_disconnected=True
+        )
+    await recorder.settled(logged=1)
+
+    _assert_one_stream_row_bills_both_rounds_once(recorder.logged, chunks)
+    assert recorder.failed == ()
+
+
+@pytest.mark.asyncio
+async def test_stream_auto_execute_bridged_to_messages_bills_round_one_when_its_follow_up_breaks(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
+
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _cut_once_the_answer_starts()))
+    recorder: Final = _ChatRoundRecorder()
+    logging_obj: Final = _chat_rounds_logging_obj(recorder, "mcp-chat-stream-bridged-to-messages", stream=True)
+
+    async def bridged(stream: CustomStreamWrapper) -> AsyncIterator[ModelResponseStream]:
+        async for chunk in stream:
+            yield chunk
+
+    with _echo_tool_served():
+        relayed: Final = bridged(await _open_chat_echo_stream(logging_obj))
+        ProxyBaseLLMRequestProcessing(data={})._arm_deferred_stream_dispatch(
+            response=relayed, route_type="anthropic_messages", user_api_key_dict=MagicMock(), logging_obj=logging_obj
+        )
+        with pytest.raises(litellm.ServiceUnavailableError):
+            _ = [chunk async for chunk in relayed]
+    await recorder.settled(logged=1, failed=1)
+
+    _assert_one_row_bills_round_one(recorder.logged)
+
+
+def _read_synchronously_until_the_follow_up_answers(
+    logging_obj: Logging, loop: asyncio.AbstractEventLoop, before_dropping: Callable[[], None] = lambda: None
+) -> None:
+    stream: Final = loop.run_until_complete(_open_chat_echo_stream(logging_obj))
+    for chunk in stream:
+        if chunk.choices and chunk.choices[0].delta.content == "PING":
+            before_dropping()
+            return
+    pytest.fail("the stream never sent 'PING'")
+
+
+_CHAT_STREAM_BILLING_NAMES: Final = ("MCPStreamingIterator", "ChatStreamRoundBilling", "_log_success")
+
+
+def _names_chat_stream_billing(text: str) -> bool:
+    return any(name in text for name in _CHAT_STREAM_BILLING_NAMES)
+
+
+class _UnraisableRecorder:
+    def __init__(self) -> None:
+        self.raised: tuple[str, ...] = ()
+
+    def __call__(self, unraisable: "sys.UnraisableHookArgs") -> None:
+        self.raised = (*self.raised, f"{unraisable.object!r}: {unraisable.exc_value!r}")
+
+
+def test_stream_auto_execute_read_synchronously_and_dropped_mid_answer_bills_the_finished_first_round(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    unraisable: Final = _UnraisableRecorder()
+    loop: Final = asyncio.new_event_loop()
+    gc.collect()
+    monkeypatch.setattr(sys, "unraisablehook", unraisable)
+    asyncio.set_event_loop(loop)
+
+    try:
+        with _echo_tool_served(), warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            _read_synchronously_until_the_follow_up_answers(
+                _chat_rounds_logging_obj(recorder, "mcp-chat-stream-sync-dropped", stream=True), loop
+            )
+            gc.collect()
+            loop.run_until_complete(recorder.settled(logged=1))
+    finally:
+        asyncio.set_event_loop(None)
+        loop.close()
+
+    _assert_one_row_bills_round_one(recorder.logged)
+    assert [raised for raised in unraisable.raised if _names_chat_stream_billing(raised)] == []
+    assert [str(warning.message) for warning in caught if _names_chat_stream_billing(str(warning.message))] == []
+
+
+def test_stream_auto_execute_read_synchronously_and_dropped_after_its_loop_closed_drops_without_errors(
+    respx_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+):
+    _serve_chat_rounds(respx_mock, monkeypatch, (_streamed(_CHAT_ROUND_ONE), _streamed(_CHAT_ROUND_TWO)))
+    recorder: Final = _ChatRoundRecorder()
+    unraisable: Final = _UnraisableRecorder()
+    loop: Final = asyncio.new_event_loop()
+    gc.collect()
+    monkeypatch.setattr(sys, "unraisablehook", unraisable)
+    asyncio.set_event_loop(loop)
+
+    try:
+        with _echo_tool_served(), warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            _read_synchronously_until_the_follow_up_answers(
+                _chat_rounds_logging_obj(recorder, "mcp-chat-stream-sync-dropped-after-close", stream=True),
+                loop,
+                before_dropping=loop.close,
+            )
+            gc.collect()
+    finally:
+        asyncio.set_event_loop(None)
+        loop.close()
+
+    assert [raised for raised in unraisable.raised if _names_chat_stream_billing(raised)] == []
+    assert [str(warning.message) for warning in caught if _names_chat_stream_billing(str(warning.message))] == []
diff --git a/tests/unit/responses/mcp/test_parked_stream_dispatch.py b/tests/unit/responses/mcp/test_parked_stream_dispatch.py
new file mode 100644
index 00000000000..dd380c582c8
--- /dev/null
+++ b/tests/unit/responses/mcp/test_parked_stream_dispatch.py
@@ -0,0 +1,17 @@
+from typing import Final
+
+import pytest
+
+from litellm.responses.mcp.parked_stream_dispatch import parked_success
+from litellm.types.utils import ModelResponse
+
+_ASSEMBLED: Final = ModelResponse(id="chatcmpl-parked", model="gpt-5.6")
+
+
+@pytest.mark.parametrize(
+    "parked",
+    [(), (_ASSEMBLED,), (_ASSEMBLED, False, "not a logger"), (_ASSEMBLED, False, None, None)],
+    ids=("empty", "assembled-alone", "third-part-is-not-a-logger", "four-parts"),
+)
+def test_a_parked_dispatch_of_an_unknown_shape_is_never_dispatched(parked: tuple[object, ...]):
+    assert parked_success(parked) is None
diff --git a/tests/unit/responses/test_responses_websocket_all_providers.py b/tests/unit/responses/test_responses_websocket_all_providers.py
index ab52e6d29c3..d0e26798090 100644
--- a/tests/unit/responses/test_responses_websocket_all_providers.py
+++ b/tests/unit/responses/test_responses_websocket_all_providers.py
@@ -8,15 +8,21 @@ Tests that:
 """
 
 import asyncio
+import itertools
 import json
-from collections.abc import Mapping
-from typing import Final
-from unittest.mock import MagicMock
+from collections.abc import AsyncIterator, Mapping
+from datetime import datetime, timezone
+from functools import partial
+from typing import TYPE_CHECKING, Final
+from unittest.mock import AsyncMock, MagicMock
 
+import httpx
 import pytest
+import respx
 
 from litellm.llms.azure.responses.transformation import AzureOpenAIResponsesAPIConfig
 from litellm.llms.chatgpt.responses.transformation import ChatGPTResponsesAPIConfig
+from litellm.llms.custom_llm import CustomLLM
 from litellm.llms.databricks.responses.transformation import (
     DatabricksResponsesAPIConfig,
 )
@@ -42,6 +48,13 @@ from litellm.llms.volcengine.responses.transformation import (
     VolcEngineResponsesAPIConfig,
 )
 from litellm.llms.xai.responses.transformation import XAIResponsesAPIConfig
+from litellm.types.utils import GenericStreamingChunk
+
+if TYPE_CHECKING:
+    from litellm.caching.dual_cache import DualCache
+    from litellm.litellm_core_utils.litellm_logging import Logging
+    from litellm.responses.streaming_iterator import ResponsesWsTurnAdmission
+    from litellm.router_utils.pre_call_checks.model_rate_limit_check import ModelRateLimitingCheck
 
 
 class TestResponsesAPIWebSocketSupport:
@@ -1591,7 +1604,7 @@ def _admission_refusing_the_next_turn():
 
     from litellm.exceptions import RateLimitError
 
-    return AsyncMock(side_effect=[RateLimitError(message="crossed budget", llm_provider="", model=""), None])
+    return AsyncMock(side_effect=[RateLimitError(message="crossed budget", llm_provider="", model=""), {}])
 
 
 class _ClientSocket:
@@ -1630,7 +1643,7 @@ class _StalledClientSocket(_ClientSocket):
 def _admission_crashing_the_next_turn():
     from unittest.mock import AsyncMock
 
-    return AsyncMock(side_effect=[ValueError("custom check failed"), None])
+    return AsyncMock(side_effect=[ValueError("custom check failed"), {}])
 
 
 def _guard_blocking(word: str):
@@ -1655,6 +1668,229 @@ def _guard_recording(bill_refusal: MagicMock):
     return guard
 
 
+_OPENED_ON: Final = "global_router:ws-dep:openai/gpt-5-mini:otpm:12-34"
+_TURNED_ON: Final = "global_router:ws-dep:openai/gpt-5-mini:otpm:12-35"
+_OPENED_AT: Final = datetime(2026, 1, 1, 12, 34, 56, tzinfo=timezone.utc)
+_TURNED_AT: Final = datetime(2026, 1, 1, 12, 35, 5, tzinfo=timezone.utc)
+_WS_DEPLOYMENT: Final = {
+    "litellm_params": {"model": "openai/gpt-5-mini", "otpm": 4096},
+    "model_info": {"id": "ws-dep"},
+}
+_OTHER_USAGE: Final = 10
+_OUTPUT_TOKENS_PER_TURN: Final = 2
+_UPSTREAM_ERROR: Final = json.dumps({"type": "error", "error": {"type": "server_error", "message": "upstream failed"}})
+
+
+def _turn_completed() -> str:
+    return json.dumps(
+        {
+            "type": "response.completed",
+            "response": {
+                "id": "resp_turn",
+                "status": "completed",
+                "output": [],
+                "usage": {"input_tokens": 5, "output_tokens": _OUTPUT_TOKENS_PER_TURN, "total_tokens": 7},
+            },
+        }
+    )
+
+
+async def _socket_opened_on(dual_cache: "DualCache") -> Mapping[str, object]:
+    from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import async_admit_io_token_turn
+
+    await dual_cache.async_increment_cache(key=_OPENED_ON, value=_OTHER_USAGE, ttl=60)
+    await dual_cache.async_increment_cache(key=_TURNED_ON, value=_OTHER_USAGE, ttl=60)
+    return await async_admit_io_token_turn(dual_cache, _WS_DEPLOYMENT, _OPENED_AT)
+
+
+def _turns_finish_at(monkeypatch: pytest.MonkeyPatch, finished_at: datetime) -> None:
+    monkeypatch.setattr(
+        "litellm.router_utils.pre_call_checks.io_token_rate_limit_check.get_utc_datetime", lambda: finished_at
+    )
+
+
+def _later_turns_admitted_through(dual_cache: "DualCache") -> "ResponsesWsTurnAdmission":
+    from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import async_admit_io_token_turn
+
+    return partial(async_admit_io_token_turn, dual_cache, _WS_DEPLOYMENT, _TURNED_AT)
+
+
+_ITPM_OPENED_ON: Final = "global_router:ws-dep:openai/gpt-5-mini:itpm:12-34"
+_ITPM_DEPLOYMENT: Final = {
+    "litellm_params": {"model": "openai/gpt-5-mini", "itpm": 40_000},
+    "model_info": {"id": "ws-dep"},
+}
+_TURN_INPUT_TOKENS: Final = 1_000
+
+
+def _turn_completed_reading_cache(cached_tokens: int) -> str:
+    return json.dumps(
+        {
+            "type": "response.completed",
+            "response": {
+                "id": "resp_cached_turn",
+                "status": "completed",
+                "output": [],
+                "usage": {
+                    "input_tokens": _TURN_INPUT_TOKENS,
+                    "input_tokens_details": {"cached_tokens": cached_tokens},
+                    "output_tokens": _OUTPUT_TOKENS_PER_TURN,
+                    "total_tokens": _TURN_INPUT_TOKENS + _OUTPUT_TOKENS_PER_TURN,
+                },
+            },
+        }
+    )
+
+
+def _connection_logged_through(rate_limits: "ModelRateLimitingCheck", opened_with: Mapping[str, object]) -> "Logging":
+    import time
+
+    from litellm.litellm_core_utils.litellm_logging import Logging
+    from litellm.types.utils import CallTypes
+
+    connection: Final = Logging(
+        model="gpt-5-mini",
+        messages=[],
+        stream=False,
+        call_type=CallTypes.aresponses_websocket.value,
+        start_time=time.time(),
+        litellm_call_id="connection-call",
+        function_id="connection-call",
+        dynamic_async_success_callbacks=[rate_limits],
+        dynamic_async_failure_callbacks=[rate_limits],
+    )
+    connection.update_environment_variables(
+        litellm_params={"metadata": dict(opened_with), CallTypes.aresponses_websocket.value: True},
+        optional_params={},
+    )
+    return connection
+
+
+def _provider_turn_stream(_request: httpx.Request) -> httpx.Response:
+    completed: Final = {
+        "id": "resp_turn",
+        "object": "response",
+        "created_at": 1767271505,
+        "status": "completed",
+        "model": "gpt-5-mini",
+        "output": [],
+        "parallel_tool_calls": True,
+        "tool_choice": "auto",
+        "tools": [],
+        "usage": {"input_tokens": 5, "output_tokens": _OUTPUT_TOKENS_PER_TURN, "total_tokens": 7},
+    }
+    return httpx.Response(
+        200,
+        headers={"content-type": "text/event-stream"},
+        text="".join(
+            f"event: {kind}\ndata: {json.dumps({'type': kind, 'response': completed})}\n\n"
+            for kind in ("response.created", "response.completed")
+        ),
+    )
+
+
+class _ProviderResponsesSocket:
+    """A provider's native Responses socket that answers each ``response.create`` with a completed turn."""
+
+    def __init__(self) -> None:
+        self.sent: Final[list[dict[str, object]]] = []
+        self._replies: Final[asyncio.Queue[str]] = asyncio.Queue()
+
+    def connect(self, _url: str, **_kwargs: object) -> "_ProviderResponsesSocket":
+        return self
+
+    async def __aenter__(self) -> "_ProviderResponsesSocket":
+        return self
+
+    async def __aexit__(self, *_exc_info: object) -> None:
+        return None
+
+    async def send(self, message: str) -> None:
+        self.sent.append(json.loads(message))
+        await self._replies.put(_turn_completed())
+
+    async def recv(self, decode: bool = False) -> str:
+        return await self._replies.get()
+
+    async def close(self) -> None:
+        return None
+
+
+class _TwoOutputTokenTurns(CustomLLM):
+    def __init__(self, failing_turns: frozenset[int] = frozenset()) -> None:
+        super().__init__()
+        self._failing_turns: Final = failing_turns
+        self._turns: Final = itertools.count(1)
+
+    async def astreaming(self, *args: object, **kwargs: object) -> AsyncIterator[GenericStreamingChunk]:
+        if next(self._turns) in self._failing_turns:
+            raise RuntimeError("upstream failed")
+        yield GenericStreamingChunk(
+            text="hi",
+            is_finished=True,
+            finish_reason="stop",
+            index=0,
+            tool_use=None,
+            usage={"prompt_tokens": 5, "completion_tokens": _OUTPUT_TOKENS_PER_TURN, "total_tokens": 7},
+        )
+
+
+async def _run_managed_relay(
+    monkeypatch: pytest.MonkeyPatch,
+    provider: CustomLLM,
+    rate_limits: "ModelRateLimitingCheck",
+    frames: tuple[str, ...],
+    turn_admission: "ResponsesWsTurnAdmission | None",
+    opened_with: Mapping[str, object],
+) -> _ClientSocket:
+    import litellm
+
+    monkeypatch.setattr(litellm, "custom_provider_map", [{"provider": "ws-turn-llm", "custom_handler": provider}])
+    return await _relay_turns_to(monkeypatch, "ws-turn-llm/turns", rate_limits, frames, turn_admission, opened_with)
+
+
+async def _relay_turns_to(
+    monkeypatch: pytest.MonkeyPatch,
+    model: str,
+    rate_limits: "ModelRateLimitingCheck",
+    frames: tuple[str, ...],
+    turn_admission: "ResponsesWsTurnAdmission | None",
+    opened_with: Mapping[str, object],
+    **connection: object,
+) -> _ClientSocket:
+    import litellm
+    from litellm.litellm_core_utils.litellm_logging import Logging
+    from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER
+    from litellm.responses.streaming_iterator import ManagedResponsesWebSocketHandler, drain_logging_tasks
+
+    monkeypatch.setattr(litellm, "callbacks", [rate_limits])
+    first, *later = frames
+    websocket: Final = _ClientSocket(*later)
+    handler: Final = ManagedResponsesWebSocketHandler(
+        websocket=websocket,
+        model=model,
+        logging_obj=Logging(
+            model=model,
+            messages=[],
+            stream=True,
+            call_type="aresponses",
+            start_time=0,
+            litellm_call_id="test-id",
+            function_id="test-func",
+        ),
+        litellm_metadata={"user_api_key_hash": "k1", **opened_with},
+        first_message=first,
+        turn_admission=turn_admission,
+        **connection,
+    )
+
+    await handler.run()
+    await drain_logging_tasks()
+    await asyncio.sleep(0)
+    await asyncio.wait_for(GLOBAL_LOGGING_WORKER.flush(), timeout=10.0)
+    return websocket
+
+
 def _errors(websocket: _ClientSocket) -> list[tuple[object, object]]:
     return [(frame.get("status"), frame["error"]) for frame in websocket.sent if frame.get("type") == "error"]
 
@@ -1722,6 +1958,195 @@ class TestWebSocketTurnAdmission:
         assert isinstance(failure, RateLimitError)
         assert "crossed budget" in str(failure)
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("first_turn_end", "first_turn_tokens"),
+        [
+            pytest.param(_turn_completed(), _OUTPUT_TOKENS_PER_TURN, id="first_turn_completed"),
+            pytest.param(_UPSTREAM_ERROR, 0, id="first_turn_failed"),
+        ],
+    )
+    async def test_native_relay_counts_every_turn_on_the_minute_it_finishes(
+        self, first_turn_end: str, first_turn_tokens: int, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        import websockets.exceptions  # noqa: F401  (lazy submodule must be importable)
+
+        from litellm.caching.dual_cache import DualCache
+        from litellm.responses.streaming_iterator import drain_logging_tasks
+        from litellm.router_utils.pre_call_checks.model_rate_limit_check import ModelRateLimitingCheck
+
+        _turns_finish_at(monkeypatch, _TURNED_AT)
+        dual_cache: Final = DualCache()
+        opened_with: Final = await _socket_opened_on(dual_cache)
+        first, second, third = _turn_frames()
+        backend_ws: Final = MagicMock()
+        backend_ws.send = AsyncMock()
+        backend_ws.recv = AsyncMock(
+            side_effect=[first_turn_end, _turn_completed(), _turn_completed(), Exception("stop")]
+        )
+        handler: Final = _make_streaming(
+            websocket=_ClientSocket(second, third),
+            backend_ws=backend_ws,
+            request_data={},
+            logging_obj=_connection_logged_through(ModelRateLimitingCheck(dual_cache), opened_with),
+            first_message=first,
+            turn_admission=_later_turns_admitted_through(dual_cache),
+        )
+
+        await handler.client_to_backend()
+        await handler.backend_to_client()
+        await drain_logging_tasks()
+
+        assert await dual_cache.async_get_cache(key=_OPENED_ON) == _OTHER_USAGE
+        assert (
+            await dual_cache.async_get_cache(key=_TURNED_ON)
+            == _OTHER_USAGE + first_turn_tokens + 2 * _OUTPUT_TOKENS_PER_TURN
+        )
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("cached_tokens", "counted_input_tokens"),
+        [
+            pytest.param(800, _TURN_INPUT_TOKENS - 800, id="cached_input"),
+            pytest.param(0, _TURN_INPUT_TOKENS, id="uncached_input"),
+        ],
+    )
+    async def test_native_relay_leaves_a_turn_s_cached_input_out_of_the_deployment_s_itpm(
+        self, cached_tokens: int, counted_input_tokens: int, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        import websockets.exceptions  # noqa: F401  (lazy submodule must be importable)
+
+        from litellm.caching.dual_cache import DualCache
+        from litellm.responses.streaming_iterator import drain_logging_tasks
+        from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import async_admit_io_token_turn
+        from litellm.router_utils.pre_call_checks.model_rate_limit_check import ModelRateLimitingCheck
+
+        _turns_finish_at(monkeypatch, _OPENED_AT)
+        dual_cache: Final = DualCache()
+        opened_with: Final = await async_admit_io_token_turn(dual_cache, _ITPM_DEPLOYMENT, _OPENED_AT)
+        first, _, _ = _turn_frames()
+        backend_ws: Final = MagicMock()
+        backend_ws.send = AsyncMock()
+        backend_ws.recv = AsyncMock(side_effect=[_turn_completed_reading_cache(cached_tokens), Exception("stop")])
+        handler: Final = _make_streaming(
+            websocket=_ClientSocket(),
+            backend_ws=backend_ws,
+            request_data={},
+            logging_obj=_connection_logged_through(ModelRateLimitingCheck(dual_cache), opened_with),
+            first_message=first,
+        )
+
+        await handler.client_to_backend()
+        await handler.backend_to_client()
+        await drain_logging_tasks()
+
+        assert await dual_cache.async_get_cache(key=_ITPM_OPENED_ON) == counted_input_tokens
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("failing_turns", "first_turn_tokens"),
+        [
+            pytest.param(frozenset(), _OUTPUT_TOKENS_PER_TURN, id="first_turn_completed"),
+            pytest.param(frozenset({1}), 0, id="first_turn_failed"),
+        ],
+    )
+    async def test_managed_relay_counts_every_turn_on_the_minute_it_finishes(
+        self, monkeypatch: pytest.MonkeyPatch, failing_turns: frozenset[int], first_turn_tokens: int
+    ) -> None:
+        from litellm.caching.dual_cache import DualCache
+        from litellm.router_utils.pre_call_checks.model_rate_limit_check import ModelRateLimitingCheck
+
+        _turns_finish_at(monkeypatch, _TURNED_AT)
+        dual_cache: Final = DualCache()
+        opened_with: Final = await _socket_opened_on(dual_cache)
+
+        await _run_managed_relay(
+            monkeypatch,
+            _TwoOutputTokenTurns(failing_turns),
+            ModelRateLimitingCheck(dual_cache),
+            _turn_frames(),
+            _later_turns_admitted_through(dual_cache),
+            opened_with,
+        )
+
+        assert await dual_cache.async_get_cache(key=_OPENED_ON) == _OTHER_USAGE
+        assert (
+            await dual_cache.async_get_cache(key=_TURNED_ON)
+            == _OTHER_USAGE + first_turn_tokens + 2 * _OUTPUT_TOKENS_PER_TURN
+        )
+
+    @pytest.mark.asyncio
+    async def test_managed_relay_sends_the_provider_only_the_metadata_each_turn_carries(
+        self, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter
+    ) -> None:
+        import litellm
+        from litellm.caching.dual_cache import DualCache
+        from litellm.router_utils.pre_call_checks.model_rate_limit_check import ModelRateLimitingCheck
+
+        monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+        litellm.in_memory_llm_clients_cache.flush_cache()
+        _turns_finish_at(monkeypatch, _TURNED_AT)
+        provider: Final = respx_mock.post("https://api.openai.com/v1/responses").mock(side_effect=_provider_turn_stream)
+        client_metadata: Final = {"session": "abc", "team": "search"}
+        dual_cache: Final = DualCache()
+
+        await _relay_turns_to(
+            monkeypatch,
+            "openai/gpt-5-mini",
+            ModelRateLimitingCheck(dual_cache),
+            tuple(
+                json.dumps({"type": "response.create", "input": word, "metadata": client_metadata})
+                for word in ("one", "two")
+            ),
+            _later_turns_admitted_through(dual_cache),
+            await _socket_opened_on(dual_cache),
+            api_key="sk-fake",
+        )
+
+        assert [json.loads(call.request.read()).get("metadata") for call in provider.calls] == [
+            client_metadata,
+            client_metadata,
+        ]
+        assert await dual_cache.async_get_cache(key=_TURNED_ON) == _OTHER_USAGE + 2 * _OUTPUT_TOKENS_PER_TURN
+
+    @pytest.mark.asyncio
+    async def test_native_relay_sends_the_provider_only_the_metadata_the_socket_opened_with(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from unittest.mock import patch
+
+        from litellm import Router
+
+        monkeypatch.setenv("LITELLM_RUST", "false")
+        provider: Final = _ProviderResponsesSocket()
+        client_metadata: Final = {"session": "abc", "team": "search"}
+        first, second, _ = _turn_frames()
+        router: Final = Router(
+            model_list=[
+                {
+                    "model_name": "ws-io",
+                    "litellm_params": {
+                        "model": "openai/gpt-5-mini",
+                        "api_key": "sk-fake",
+                        "itpm": 40_000,
+                        "otpm": 4096,
+                    },
+                    "model_info": {"id": "ws-dep"},
+                }
+            ],
+            optional_pre_call_checks=["enforce_model_rate_limits"],
+        )
+
+        with patch("websockets.connect", provider.connect):
+            await router._aresponses_websocket(
+                model="ws-io",
+                websocket=_ClientSocket(second),
+                first_message=first,
+                metadata=dict(client_metadata),
+            )
+
+        assert [frame.get("metadata") for frame in provider.sent] == [client_metadata, client_metadata]
+
     @pytest.mark.asyncio
     async def test_managed_relay_skips_a_later_turn_the_deployment_refuses(self, monkeypatch: pytest.MonkeyPatch):
         from unittest.mock import AsyncMock
@@ -1875,7 +2300,7 @@ class TestWebSocketTurnAdmission:
             request_data={},
             first_message=first,
             frame_guard=_guard_recording(bill_refusal),
-            turn_admission=AsyncMock(side_effect=[refusal, None]),
+            turn_admission=AsyncMock(side_effect=[refusal, {}]),
         )
 
         close_time_failure: Final = await handler.bidirectional_forward()
@@ -1904,7 +2329,7 @@ class TestWebSocketTurnAdmission:
             request_data={},
             first_message=first,
             frame_guard=_guard_recording(bill_refusal),
-            turn_admission=AsyncMock(side_effect=[refusal, None]),
+            turn_admission=AsyncMock(side_effect=[refusal, {}]),
         )
         relay: Final = asyncio.ensure_future(handler.bidirectional_forward())
         await asyncio.wait_for(client.send_started.wait(), timeout=1)
@@ -1955,7 +2380,7 @@ class TestWebSocketTurnAdmission:
             ),
             first_message=first,
             frame_guard=_guard_recording(bill_refusal),
-            turn_admission=AsyncMock(side_effect=[refusal, None]),
+            turn_admission=AsyncMock(side_effect=[refusal, {}]),
         )
 
         close_time_failure: Final = await handler.run()
diff --git a/tests/unit/test_anthropic_beta_headers_filtering.py b/tests/unit/test_anthropic_beta_headers_filtering.py
index deba7fe9587..c8fef95cf98 100644
--- a/tests/unit/test_anthropic_beta_headers_filtering.py
+++ b/tests/unit/test_anthropic_beta_headers_filtering.py
@@ -85,7 +85,8 @@ class TestAnthropicBetaHeadersFiltering:
         filtered = filter_and_transform_beta_headers(
             beta_headers=all_headers, provider=provider
         )
-        assert ("compact-2026-09-04" in filtered) is (provider == "anthropic")
+        assert ("compact-2026-09-04" in filtered) is (provider in ("anthropic", "azure_ai", "vertex_ai"))
+        assert ("mid-conversation-tool-changes-2026-07-01" in filtered) is (provider != "bedrock_converse")
 
         for header in unsupported_headers:
             assert (
@@ -406,15 +407,49 @@ class TestAnthropicBetaHeadersFiltering:
                 test_case["expected"] in filtered
             ), f"Header '{test_case['input']}' should be mapped to '{test_case['expected']}' for {test_case['provider']}, but got: {filtered}"
 
-    def test_filter_and_transform_beta_headers_vertex_ai_keeps_compact(self):
-        """Vertex AI supports compact context edits, so the compact beta header
-        must be forwarded instead of stripped (it was previously mapped to null,
-        which broke compact_20260112 context edits over /v1/messages)."""
-        filtered = filter_and_transform_beta_headers(
-            beta_headers=["compact-2026-01-12"], provider="vertex_ai"
+    @pytest.mark.parametrize("beta", ["compact-2026-09-04", "inline-tools-2026-09-15"])
+    def test_vertex_ai_header_only_beta_is_forwarded_as_the_header_and_dropped_from_the_body(
+        self, beta: str
+    ) -> None:
+        headers, body = update_request_with_filtered_beta(
+            headers={"anthropic-beta": f"{beta},context-1m-2025-08-07"},
+            request_data={"anthropic_beta": [beta, "context-1m-2025-08-07"]},
+            provider="vertex_ai",
         )
 
-        assert filtered == ["compact-2026-01-12"]
+        assert set(headers["anthropic-beta"].split(",")) == {beta, "context-1m-2025-08-07"}
+        assert body["anthropic_beta"] == ["context-1m-2025-08-07"]
+
+    def test_header_only_betas_stay_out_of_the_provider_columns_older_proxies_read(self) -> None:
+        """Proxies released before header-only columns existed fetch this map from main, read only the
+        provider column, and copy its betas into the body field too, where Vertex answers 400. So a
+        header-only beta may sit in its provider column only if older proxies already forwarded it."""
+        header_only_columns: Final = {
+            column.removesuffix("_header_only"): betas
+            for column, betas in self.config.items()
+            if column.endswith("_header_only")
+        }
+        forwarded_by_older_proxies: Final = {
+            provider: {beta for beta in betas if self.config[provider].get(beta) is not None}
+            for provider, betas in header_only_columns.items()
+        }
+
+        assert "vertex_ai" in header_only_columns
+        assert {provider: betas for provider, betas in forwarded_by_older_proxies.items() if betas} == {
+            "vertex_ai": {"inline-tools-2026-09-15"}
+        }
+
+    def test_filter_and_transform_beta_headers_vertex_ai_keeps_compact(self):
+        """Vertex AI serves both compaction betas (threshold compaction behind compact-2026-01-12
+        and on-demand compaction behind compact-2026-09-04, Google Cloud: beta on
+        https://platform.claude.com/docs/en/build-with-claude/compaction-on-demand, read 2026-10-05),
+        so the Vertex filter forwards both instead of stripping them: a dropped header makes
+        Vertex answer 400 "compaction: Extra inputs are not permitted"."""
+        filtered = filter_and_transform_beta_headers(
+            beta_headers=["compact-2026-01-12", "compact-2026-09-04"], provider="vertex_ai"
+        )
+
+        assert filtered == ["compact-2026-01-12", "compact-2026-09-04"]
 
     @pytest.mark.parametrize("provider", ["bedrock_converse", "bedrock"])
     def test_fine_grained_tool_streaming_forwarded_for_bedrock(self, provider):
diff --git a/tests/unit/test_main.py b/tests/unit/test_main.py
index b0bf1cb879e..9f2d2a9bbc5 100644
--- a/tests/unit/test_main.py
+++ b/tests/unit/test_main.py
@@ -5900,6 +5900,28 @@ def test_stream_chunk_builder_keeps_provider_reported_usage_cost():
     assert response._hidden_params["response_cost"] == pytest.approx(0.5)
 
 
+@pytest.mark.parametrize("reported_cost", [float("nan"), float("inf")])
+def test_stream_chunk_builder_bills_the_token_price_when_the_provider_cost_is_not_finite(reported_cost: float):
+    usage_chunk: Final = _stream_builder_text_chunk("gpt-4o", "")
+    usage_chunk.usage = Usage(prompt_tokens=10, completion_tokens=5, total_tokens=15, cost=reported_cost)
+    chunks: Final = [
+        _stream_builder_text_chunk("gpt-4o", "Hello "),
+        _stream_builder_text_chunk("gpt-4o", "world.", finish_reason="stop"),
+        usage_chunk,
+    ]
+
+    response: Final = litellm.stream_chunk_builder(
+        chunks=chunks, messages=[{"role": "user", "content": "hi"}], logging_obj=_stream_builder_logging_obj()
+    )
+
+    assert response is not None
+    prompt_cost, completion_cost = litellm.cost_per_token(model="gpt-4o", usage_object=response.usage)
+    token_price: Final = prompt_cost + completion_cost
+    assert token_price > 0
+    assert getattr(response.usage, "cost", None) == pytest.approx(token_price)
+    assert response._hidden_params["response_cost"] == pytest.approx(token_price)
+
+
 def test_completion_cost_on_a_stamped_stream_still_bills_the_reported_charge():
     usage_chunk: Final = _stream_builder_text_chunk("gpt-4o", "")
     usage_chunk.usage = Usage(prompt_tokens=10, completion_tokens=5, total_tokens=15, cost=0.5)
@@ -10240,9 +10262,10 @@ def test_a_non_numeric_thinking_budget_on_adaptive_claude_is_rejected_with_a_400
 @pytest.mark.parametrize("drop_globally", [False, True])
 @pytest.mark.parametrize("model_info", [None, _OPUS_DECLARING_LOW_AND_HIGH])
 @pytest.mark.parametrize("body_sent", [_anthropic_chat_body_sent, _bedrock_converse_request_fields_sent])
-def test_drop_params_drops_a_non_numeric_thinking_budget_on_adaptive_claude(
+def test_drop_params_drops_a_non_numeric_thinking_budget_on_adaptive_claude_with_one_warning(
     respx_mock: respx.MockRouter,
     monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
     body_sent: Callable[..., Mapping[str, object]],
     model_info: Mapping[str, object] | None,
     drop_globally: bool,
@@ -10250,13 +10273,40 @@ def test_drop_params_drops_a_non_numeric_thinking_budget_on_adaptive_claude(
     monkeypatch.setattr(litellm, "drop_params", drop_globally)
     request_drop: Final = {} if drop_globally else {"drop_params": True}
 
-    dropped: Final = body_sent(
-        respx_mock, model_info, thinking={"type": "enabled", "budget_tokens": "lots"}, **request_drop
-    )
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        dropped: Final = body_sent(
+            respx_mock, model_info, thinking={"type": "enabled", "budget_tokens": "lots"}, **request_drop
+        )
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
     adaptive_alone: Final = body_sent(respx_mock, model_info, thinking={"type": "adaptive"}, **request_drop)
 
     assert "output_config" not in adaptive_alone
     assert dropped == adaptive_alone
+    assert len(drop_warnings) == 1
+    assert all(
+        fragment in drop_warnings[0]
+        for fragment in ("thinking.budget_tokens='lots'", "claude-opus-5-5", "(drop_params=True)")
+    )
+
+
+@pytest.mark.parametrize("model_info", [None, _KIMI_DEPLOYMENT])
+def test_drop_params_drops_a_non_numeric_thinking_budget_on_hosted_vllm_with_one_warning(
+    respx_mock: respx.MockRouter, caplog: pytest.LogCaptureFixture, model_info: Mapping[str, object] | None
+) -> None:
+    with caplog.at_level(logging.WARNING, logger="LiteLLM"):
+        sent: Final = _chat_body_sent(
+            respx_mock,
+            "hosted_vllm/my-kimi",
+            None,
+            model_info,
+            thinking={"type": "enabled", "budget_tokens": "lots"},
+            drop_params=True,
+        )
+
+    assert not {"reasoning_effort", "thinking"} & sent.keys()
+    drop_warnings: Final = [record.getMessage() for record in caplog.records if "Dropping" in record.getMessage()]
+    assert len(drop_warnings) == 1
+    assert all(fragment in drop_warnings[0] for fragment in ("thinking.budget_tokens='lots'", "my-kimi"))
 
 
 @pytest.mark.parametrize("model", ["azure_ai/my-kimi", "hosted_vllm/my-kimi"])
diff --git a/tests/unit/test_router/test_io_token_rate_limits.py b/tests/unit/test_router/test_io_token_rate_limits.py
index e5ff4531f84..819c6b9d4f5 100644
--- a/tests/unit/test_router/test_io_token_rate_limits.py
+++ b/tests/unit/test_router/test_io_token_rate_limits.py
@@ -4,14 +4,19 @@ Tests for separate ITPM/OTPM deployment rate limits (enforce_model_rate_limits).
 
 import asyncio
 from collections.abc import Awaitable, Callable, Mapping
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Final
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
+from fakeredis import FakeRedis, FakeServer
+from fakeredis.aioredis import FakeRedis as FakeAsyncRedis
 
 import litellm
 from litellm import Router
 from litellm.caching.dual_cache import DualCache
+from litellm.caching.in_memory_cache import InMemoryCache
+from litellm.caching.redis_cache import RedisCache, RedisCircuitBreakerOpenError
 from litellm.constants import NO_MAX_TOKENS_TPM_RESERVATION_FRACTION
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObject
 from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER
@@ -22,6 +27,7 @@ from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import (
     OTPM_RESERVED_KEY,
     _explicit_max_tokens,
     _reservation_value,
+    async_admit_io_token_turn,
     async_io_token_pre_call_check,
     async_io_token_reconcile_success,
     build_io_token_rate_limit_headers,
@@ -35,6 +41,7 @@ from litellm.router_utils.pre_call_checks.io_token_rate_limit_check import (
 from litellm.router_utils.pre_call_checks.model_rate_limit_check import (
     ModelRateLimitingCheck,
 )
+from litellm.types.llms.openai import InputTokensDetails, ResponseAPIUsage, ResponsesAPIResponse
 from litellm.types.router import RouterCacheEnum
 from litellm.types.utils import ModelResponse, Usage
 from litellm.utils import get_utc_datetime
@@ -115,7 +122,7 @@ class TestModelRateLimitingCheckIOTokens:
             "max_tokens": 10,
             "metadata": {},
         }
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
         await check.async_pre_call_check(deployment)
 
         minute = get_utc_datetime().strftime("%H-%M")
@@ -173,7 +180,8 @@ class TestModelRateLimitingCheckIOTokens:
                 ],
                 "max_tokens": 10,
                 "metadata": {},
-            }
+            },
+            metadata_channel="metadata",
         )
 
         with pytest.raises(litellm.RateLimitError) as exc_info:
@@ -203,7 +211,8 @@ class TestModelRateLimitingCheckIOTokens:
                 "messages": [{"role": "user", "content": "hi"}],
                 "max_tokens": max_tokens,
                 "metadata": {},
-            }
+            },
+            metadata_channel="metadata",
         )
 
         async def _attempt():
@@ -255,7 +264,8 @@ class TestModelRateLimitingCheckIOTokens:
             {
                 "max_tokens": 5,
                 "metadata": {},
-            }
+            },
+            metadata_channel="metadata",
         )
 
         async def _attempt():
@@ -320,7 +330,7 @@ class TestModelRateLimitingCheckIOTokens:
         }
 
         request_kwargs = {"max_tokens": 5, "metadata": {}}
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
         await check.async_pre_call_check(deployment)
 
         minute = get_utc_datetime().strftime("%H-%M")
@@ -363,15 +373,15 @@ class TestModelRateLimitingCheckIOTokens:
             "model_name": "opus",
         }
         request_kwargs = {"max_tokens": 5, "metadata": {}}
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
         await check.async_pre_call_check(deployment)
 
         # Second zero-estimate call still fits within the itpm=2 limit.
-        set_io_token_rate_limit_request_kwargs({"max_tokens": 5, "metadata": {}})
+        set_io_token_rate_limit_request_kwargs({"max_tokens": 5, "metadata": {}}, metadata_channel="metadata")
         await check.async_pre_call_check(deployment)
 
         # A third exceeds the limit and is rejected.
-        set_io_token_rate_limit_request_kwargs({"max_tokens": 5, "metadata": {}})
+        set_io_token_rate_limit_request_kwargs({"max_tokens": 5, "metadata": {}}, metadata_channel="metadata")
         with pytest.raises(litellm.RateLimitError):
             await check.async_pre_call_check(deployment)
 
@@ -392,7 +402,7 @@ class TestModelRateLimitingCheckIOTokens:
             "max_tokens": 0,
             "metadata": {},
         }
-        set_io_token_rate_limit_request_kwargs(zero_output_kwargs)
+        set_io_token_rate_limit_request_kwargs(zero_output_kwargs, metadata_channel="metadata")
         await check.async_pre_call_check(deployment)
 
         zero_output_otpm_key = zero_output_kwargs["metadata"][OTPM_CACHE_KEY]
@@ -404,7 +414,7 @@ class TestModelRateLimitingCheckIOTokens:
             "max_tokens": 5,
             "metadata": {},
         }
-        set_io_token_rate_limit_request_kwargs(normal_output_kwargs)
+        set_io_token_rate_limit_request_kwargs(normal_output_kwargs, metadata_channel="metadata")
         await check.async_pre_call_check(deployment)
 
         normal_output_otpm_key = normal_output_kwargs["metadata"][OTPM_CACHE_KEY]
@@ -432,7 +442,7 @@ class TestModelRateLimitingCheckIOTokens:
             "model_name": "no-max-tokens",
         }
         request_kwargs: Final = {"messages": [{"role": "user", "content": "hello"}], "metadata": {}}
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
 
         if use_sync_check:
             check.pre_call_check(deployment)
@@ -462,7 +472,7 @@ class TestModelRateLimitingCheckIOTokens:
 
         async def _attempt() -> dict[str, object] | None:
             request_kwargs: Final = {"messages": [{"role": "user", "content": "hi"}], "metadata": {}}
-            set_io_token_rate_limit_request_kwargs(request_kwargs)
+            set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
             try:
                 await check.async_pre_call_check(deployment)
             except litellm.RateLimitError:
@@ -493,7 +503,7 @@ class TestModelRateLimitingCheckIOTokens:
             "model_name": "roomy",
         }
         request_kwargs: Final = {"messages": [{"role": "user", "content": "hello"}], "metadata": {}}
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
 
         await check.async_pre_call_check(deployment)
 
@@ -507,7 +517,7 @@ class TestModelRateLimitingCheckIOTokens:
 
         async def _reserved(model_info: dict[str, str]) -> int:
             request_kwargs: Final = {"messages": [{"role": "user", "content": "hello"}], "metadata": {}}
-            set_io_token_rate_limit_request_kwargs(request_kwargs)
+            set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
             deployment: Final = {
                 "litellm_params": {"model": "azure/litellm-io-custom-deployment", "otpm": otpm_limit},
                 "model_info": model_info,
@@ -536,7 +546,7 @@ class TestModelRateLimitingCheckIOTokens:
         }
 
         async def _pre_call(request_kwargs: dict[str, object]) -> None:
-            set_io_token_rate_limit_request_kwargs(request_kwargs)
+            set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
             if use_sync_check:
                 check.pre_call_check(deployment)
             else:
@@ -563,12 +573,14 @@ class TestModelRateLimitingCheckIOTokens:
             "model_name": "opus",
         }
         request_kwargs: Final = {"messages": [{"role": "user", "content": "hello"}], "max_tokens": 100, "metadata": {}}
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
 
         await check.async_pre_call_check(deployment)
 
         assert request_kwargs["metadata"][OTPM_RESERVED_KEY] == 100
-        set_io_token_rate_limit_request_kwargs({"messages": [{"role": "user", "content": "hi"}], "metadata": {}})
+        set_io_token_rate_limit_request_kwargs(
+            {"messages": [{"role": "user", "content": "hi"}], "metadata": {}}, metadata_channel="metadata"
+        )
         with pytest.raises(litellm.RateLimitError):
             await check.async_pre_call_check(deployment)
 
@@ -585,7 +597,7 @@ class TestModelRateLimitingCheckIOTokens:
         with_cap: Final = {"messages": [{"role": "user", "content": "hello"}], "max_tokens": 300, "metadata": {}}
 
         for request_kwargs in (without_cap, with_cap):
-            set_io_token_rate_limit_request_kwargs(request_kwargs)
+            set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
             if use_sync_check:
                 check.pre_call_check(deployment)
             else:
@@ -602,7 +614,7 @@ class TestModelRateLimitingCheckIOTokens:
 
         async def reserved(deployment_cap: Mapping[str, int], request_shape: Mapping[str, object]) -> int:
             request_kwargs: Final = {**request_shape, "metadata": {}}
-            set_io_token_rate_limit_request_kwargs(request_kwargs)
+            set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
             await check.async_pre_call_check(
                 {
                     "litellm_params": {"model": MANTLE_OPUS, "otpm": 4000, **deployment_cap},
@@ -631,7 +643,7 @@ class TestModelRateLimitingCheckIOTokens:
 
         async def reserved(deployment_cap: Mapping[str, int]) -> int:
             request_kwargs: Final = {"messages": [{"role": "user", "content": "hello"}], "metadata": {}}
-            set_io_token_rate_limit_request_kwargs(request_kwargs)
+            set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
             deployment: Final = {
                 "litellm_params": {"model": UNMAPPED_MODEL, "otpm": otpm_limit, **deployment_cap},
                 "model_info": {"id": f"io-deployment-cap-above-default-{deployment_cap}"},
@@ -667,7 +679,7 @@ class TestModelRateLimitingCheckIOTokens:
             "max_tokens": 10,
             "metadata": {},
         }
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
         check.pre_call_check(deployment)
 
         minute = get_utc_datetime().strftime("%H-%M")
@@ -803,7 +815,7 @@ class TestModelRateLimitingCheckIOTokens:
 
         # The retry proceeds to stash deployment B's own reservation on the
         # same dict; it starts clean, unaffected by A's cleared sentinels.
-        set_io_token_rate_limit_request_kwargs(shared_kwargs)
+        set_io_token_rate_limit_request_kwargs(shared_kwargs, metadata_channel="metadata")
         itpm_key_b = f"global_router:io-retry-b:bedrock_mantle/test-b:itpm:{minute}"
         shared_kwargs["metadata"][ITPM_RESERVED_KEY] = 4
         shared_kwargs["metadata"][ITPM_CACHE_KEY] = itpm_key_b
@@ -819,7 +831,7 @@ class TestModelRateLimitingCheckIOTokens:
             "litellm_metadata": {OTPM_RESERVED_KEY: 7},
             "litellm_params": {"metadata": {OTPM_CACHE_KEY: "attacker:key:otpm:00-00"}},
         }
-        set_io_token_rate_limit_request_kwargs(forged)
+        set_io_token_rate_limit_request_kwargs(forged, metadata_channel="metadata")
         stored = get_io_token_rate_limit_request_kwargs()
 
         assert ITPM_RESERVED_KEY not in stored["metadata"]
@@ -845,7 +857,7 @@ class TestModelRateLimitingCheckIOTokens:
             },
         }
         # The router sanitizes the request kwargs before the call runs.
-        set_io_token_rate_limit_request_kwargs(kwargs)
+        set_io_token_rate_limit_request_kwargs(kwargs, metadata_channel="metadata")
         response = ModelResponse(
             choices=[{"message": {"role": "assistant", "content": "ok"}, "index": 0, "finish_reason": "stop"}],
             usage=Usage(prompt_tokens=1, completion_tokens=1, total_tokens=2),
@@ -880,7 +892,8 @@ class TestModelRateLimitingCheckIOTokens:
                 "messages": [{"role": "user", "content": "hello world"}],
                 "max_tokens": 5,
                 "metadata": {},
-            }
+            },
+            metadata_channel="metadata",
         )
 
         with pytest.raises(RuntimeError):
@@ -945,7 +958,7 @@ class TestModelRateLimitingCheckIOTokens:
             "max_tokens": 5,
             "metadata": {},
         }
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
 
         result = await async_io_token_pre_call_check(dual_cache, deployment)
 
@@ -1147,7 +1160,7 @@ class TestModelRateLimitingCheckIOTokens:
             "max_tokens": 5,
             "metadata": {},
         }
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
 
         with caplog.at_level(logging.WARNING, logger="LiteLLM Router"):
             with pytest.raises(litellm.RateLimitError):
@@ -1495,15 +1508,15 @@ class TestContextSlotRetention:
             "messages": [{"role": "user", "content": "x" * 1000}],
             "metadata": {ITPM_RESERVED_KEY: 999, ITPM_CACHE_KEY: "forged"},
         }
-        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=False)
+        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=False, metadata_channel="metadata")
         assert get_io_token_rate_limit_request_kwargs() is None
         assert ITPM_RESERVED_KEY not in kwargs["metadata"]
         assert ITPM_CACHE_KEY not in kwargs["metadata"]
 
-        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=True)
+        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=True, metadata_channel="metadata")
         assert get_io_token_rate_limit_request_kwargs() is kwargs
 
-        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=False)
+        set_io_token_rate_limit_request_kwargs(kwargs, store_in_context=False, metadata_channel="metadata")
         assert get_io_token_rate_limit_request_kwargs() is None
 
     @pytest.mark.asyncio
@@ -1516,7 +1529,7 @@ class TestContextSlotRetention:
                 }
             ]
         )
-        set_io_token_rate_limit_request_kwargs(None)
+        set_io_token_rate_limit_request_kwargs(None, metadata_channel="metadata")
         kwargs = {"messages": [{"role": "user", "content": "hello"}], "metadata": {}}
         deployment = router.get_deployment_by_model_group_name("plain")
         assert deployment is not None
@@ -1534,7 +1547,7 @@ class TestContextSlotRetention:
             ],
             optional_pre_call_checks=["enforce_model_rate_limits"],
         )
-        set_io_token_rate_limit_request_kwargs(None)
+        set_io_token_rate_limit_request_kwargs(None, metadata_channel="metadata")
         kwargs = {"messages": [{"role": "user", "content": "hello"}], "metadata": {}}
         deployment = router.get_deployment_by_model_group_name("limited")
         assert deployment is not None
@@ -1551,7 +1564,7 @@ async def test_custom_azure_deployment_name_reserves_itpm_on_its_base_models_tok
             "max_tokens": 5,
             "metadata": metadata,
         }
-        set_io_token_rate_limit_request_kwargs(request_kwargs)
+        set_io_token_rate_limit_request_kwargs(request_kwargs, metadata_channel="metadata")
         await async_io_token_pre_call_check(DualCache(), deployment)
         return metadata[ITPM_RESERVED_KEY]
 
@@ -1571,3 +1584,278 @@ async def test_custom_azure_deployment_name_reserves_itpm_on_its_base_models_tok
     )
 
     assert named == served
+
+
+def _reply_using(prompt_tokens: int, completion_tokens: int) -> ModelResponse:
+    return ModelResponse(
+        choices=[{"message": {"role": "assistant", "content": "hi"}, "index": 0, "finish_reason": "stop"}],
+        usage=Usage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=prompt_tokens + completion_tokens,
+        ),
+    )
+
+
+def _proxy_success_kwargs(reservation: Mapping[str, object]) -> dict[str, object]:
+    return {
+        "litellm_params": {"metadata": {**reservation, "user_api_key_hash": "hashed-key"}},
+        "standard_logging_object": {
+            "hidden_params": {"litellm_model_name": "openai/gpt-5-mini"},
+            "metadata": {"user_api_key_hash": "hashed-key"},
+        },
+    }
+
+
+async def _deliver_success(
+    check: ModelRateLimitingCheck, delivery: str, kwargs: dict[str, object], reply: object
+) -> None:
+    if delivery == "async":
+        await check.async_log_success_event(kwargs, reply, None, None)
+        return
+    check.log_success_event(kwargs, reply, None, None)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "deliveries",
+    [("async",), ("sync",), ("async", "async"), ("async", "sync"), ("sync", "async"), ("sync", "sync")],
+)
+async def test_success_settles_a_reservation_held_only_in_litellm_params_metadata_exactly_once(
+    deliveries: tuple[str, ...],
+) -> None:
+    dual_cache: Final = DualCache()
+    check: Final = ModelRateLimitingCheck(dual_cache=dual_cache)
+    itpm_key: Final = "global_router:proxy-shape:openai/gpt-5-mini:itpm:12-34"
+    otpm_key: Final = "global_router:proxy-shape:openai/gpt-5-mini:otpm:12-34"
+    await dual_cache.async_increment_cache(key=itpm_key, value=40, ttl=60)
+    await dual_cache.async_increment_cache(key=otpm_key, value=4096, ttl=60)
+    kwargs: Final = _proxy_success_kwargs(
+        {ITPM_RESERVED_KEY: 40, OTPM_RESERVED_KEY: 4096, ITPM_CACHE_KEY: itpm_key, OTPM_CACHE_KEY: otpm_key}
+    )
+
+    for delivery in deliveries:
+        await _deliver_success(check, delivery, kwargs, _reply_using(prompt_tokens=7, completion_tokens=3))
+
+    assert await dual_cache.async_get_cache(key=itpm_key) == 7
+    assert await dual_cache.async_get_cache(key=otpm_key) == 3
+
+
+_TURN_AT: Final = datetime(2026, 1, 1, 12, 34, 56, tzinfo=timezone.utc)
+_ACTUAL_TOKENS: Final = {"itpm": 5, "otpm": 2}
+
+
+def _turn_deployment(kind: str) -> dict[str, object]:
+    return {"litellm_params": {"model": "openai/gpt-5-mini", kind: 100}, "model_info": {"id": f"ws-turn-{kind}"}}
+
+
+def _turn_key(kind: str, minute: str = "12-34") -> str:
+    return f"global_router:ws-turn-{kind}:openai/gpt-5-mini:{kind}:{minute}"
+
+
+@pytest.fixture
+def settled_on_the_turn_s_minute(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        "litellm.router_utils.pre_call_checks.io_token_rate_limit_check.get_utc_datetime", lambda: _TURN_AT
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+@pytest.mark.parametrize("used", [100, 101, 250])
+async def test_turn_admission_refuses_once_the_minutes_tokens_reach_the_limit(kind: str, used: int) -> None:
+    dual_cache: Final = DualCache()
+    await dual_cache.async_increment_cache(key=_turn_key(kind), value=used, ttl=60)
+
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit=100, current usage={used}"):
+        await async_admit_io_token_turn(dual_cache, _turn_deployment(kind), _TURN_AT)
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("settled_on_the_turn_s_minute")
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+@pytest.mark.parametrize("used", [0, 1, 99])
+async def test_an_admitted_turn_reserves_nothing_and_counts_its_actual_tokens(kind: str, used: int) -> None:
+    dual_cache: Final = DualCache()
+    await dual_cache.async_increment_cache(key=_turn_key(kind), value=used, ttl=60)
+    actual: Final = _ACTUAL_TOKENS
+
+    reservation: Final = await async_admit_io_token_turn(dual_cache, _turn_deployment(kind), _TURN_AT)
+    counter_key: Final = reservation[ITPM_CACHE_KEY if kind == "itpm" else OTPM_CACHE_KEY]
+    assert isinstance(counter_key, str)
+    assert await dual_cache.async_get_cache(key=counter_key) == used
+    await async_io_token_reconcile_success(
+        dual_cache, _proxy_success_kwargs(reservation), _reply_using(actual["itpm"], actual["otpm"])
+    )
+
+    assert await dual_cache.async_get_cache(key=counter_key) == used + actual[kind]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "deployment",
+    [
+        {"litellm_params": {"model": "openai/gpt-5-mini", "tpm": 1}, "model_info": {"id": "ws-turn-unlimited"}},
+        {"litellm_params": {"model": "openai/gpt-5-mini", "otpm": 1}},
+    ],
+)
+async def test_a_turn_without_io_token_counters_is_admitted_with_nothing_to_settle(
+    deployment: dict[str, object],
+) -> None:
+    assert await async_admit_io_token_turn(DualCache(), deployment, _TURN_AT) == {}
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("settled_on_the_turn_s_minute")
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+@pytest.mark.parametrize("used_by_others", [0, 1, 99])
+async def test_a_socket_open_reserves_nothing_and_its_first_turn_counts_its_actual_tokens_on_its_own_minute(
+    kind: str, used_by_others: int
+) -> None:
+    dual_cache: Final = DualCache()
+    await dual_cache.async_increment_cache(key=_turn_key(kind), value=used_by_others, ttl=60)
+    socket_open: Final[dict[str, object]] = {"metadata": {}}
+    set_io_token_rate_limit_request_kwargs(socket_open, opens_responses_socket=True, metadata_channel="metadata")
+
+    assert await async_io_token_pre_call_check(dual_cache, _turn_deployment(kind)) == _turn_deployment(kind)
+    assert await dual_cache.async_get_cache(key=_turn_key(kind)) == used_by_others
+
+    opened_with: Final = socket_open["metadata"]
+    assert isinstance(opened_with, dict)
+    await async_io_token_reconcile_success(
+        dual_cache, _proxy_success_kwargs(opened_with), _reply_using(_ACTUAL_TOKENS["itpm"], _ACTUAL_TOKENS["otpm"])
+    )
+
+    assert await dual_cache.async_get_cache(key=_turn_key(kind)) == used_by_others + _ACTUAL_TOKENS[kind]
+
+
+class _RedisCacheOnFakeServer(RedisCache):
+    def __init__(self, server: FakeServer) -> None:
+        super().__init__(host="io-token-turn-redis", connection_pool=FakeRedis(server=server).connection_pool)
+        self._fake_async_client: Final = FakeAsyncRedis(server=server)
+
+    def init_async_client(self) -> FakeAsyncRedis:
+        return self._fake_async_client
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_a_turn_is_refused_on_this_instance_s_count_when_reading_the_shared_counter_fails(
+    kind: str,
+) -> None:
+    server: Final = FakeServer()
+    dual_cache: Final = DualCache(in_memory_cache=InMemoryCache(), redis_cache=_RedisCacheOnFakeServer(server))
+    server.connected = False
+    await dual_cache.in_memory_cache.async_increment(key=_turn_key(kind), value=100)
+
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit=100, current usage=100"):
+        await async_admit_io_token_turn(dual_cache, _turn_deployment(kind), _TURN_AT)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+@pytest.mark.parametrize("delivery", ["async", "sync"])
+async def test_a_turn_finishing_in_the_next_minute_counts_its_actual_tokens_on_that_minute(
+    kind: str, delivery: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(
+        "litellm.router_utils.pre_call_checks.io_token_rate_limit_check.get_utc_datetime",
+        lambda: datetime(2026, 1, 1, 12, 35, 10, tzinfo=timezone.utc),
+    )
+    dual_cache: Final = DualCache()
+    reservation: Final = await async_admit_io_token_turn(dual_cache, _turn_deployment(kind), _TURN_AT)
+
+    await _deliver_success(
+        ModelRateLimitingCheck(dual_cache=dual_cache),
+        delivery,
+        _proxy_success_kwargs(reservation),
+        _reply_using(_ACTUAL_TOKENS["itpm"], _ACTUAL_TOKENS["otpm"]),
+    )
+
+    assert [await dual_cache.async_get_cache(key=_turn_key(kind, minute)) for minute in ("12-34", "12-35")] == [
+        None,
+        _ACTUAL_TOKENS[kind],
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_a_turn_is_admitted_once_the_shared_counter_drops_below_the_limit_this_instance_last_read(
+    kind: str,
+) -> None:
+    redis_cache: Final = _RedisCacheOnFakeServer(FakeServer())
+    dual_cache: Final = DualCache(in_memory_cache=InMemoryCache(), redis_cache=redis_cache)
+    await dual_cache.in_memory_cache.async_increment(key=_turn_key(kind), value=100)
+    await redis_cache.async_increment(key=_turn_key(kind), value=99)
+
+    admitted: Final = await async_admit_io_token_turn(dual_cache, _turn_deployment(kind), _TURN_AT)
+
+    assert admitted[ITPM_CACHE_KEY if kind == "itpm" else OTPM_CACHE_KEY] == _turn_key(kind)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "responses_reply",
+    [
+        pytest.param(
+            ResponsesAPIResponse(
+                id="resp_cached",
+                created_at=0,
+                output=[],
+                usage=ResponseAPIUsage(
+                    input_tokens=50,
+                    output_tokens=5,
+                    total_tokens=55,
+                    input_tokens_details=InputTokensDetails(cached_tokens=30),
+                ),
+            ),
+            id="usage_object",
+        ),
+        pytest.param(
+            {
+                "usage": {
+                    "input_tokens": 50,
+                    "output_tokens": 5,
+                    "total_tokens": 55,
+                    "input_tokens_details": {"cached_tokens": 30},
+                }
+            },
+            id="usage_dict",
+        ),
+    ],
+)
+@pytest.mark.usefixtures("settled_on_the_turn_s_minute")
+async def test_a_turn_counts_only_its_uncached_responses_input_toward_itpm(responses_reply: object) -> None:
+    dual_cache: Final = DualCache()
+    await dual_cache.async_increment_cache(key=_turn_key("itpm"), value=10, ttl=60)
+
+    reservation: Final = await async_admit_io_token_turn(dual_cache, _turn_deployment("itpm"), _TURN_AT)
+    await async_io_token_reconcile_success(dual_cache, _proxy_success_kwargs(reservation), responses_reply)
+
+    assert await dual_cache.async_get_cache(key=_turn_key("itpm")) == 10 + 50 - 30
+
+
+def _shared_counter_answering(answer: int | Exception) -> DualCache:
+    redis_cache: Final = MagicMock(spec=RedisCache)
+    redis_cache.async_get_cache = AsyncMock(side_effect=[answer])
+    return DualCache(in_memory_cache=InMemoryCache(), redis_cache=redis_cache)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_a_later_turn_is_refused_when_another_instance_filled_the_shared_minute(kind: str) -> None:
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit=100, current usage=100"):
+        await async_admit_io_token_turn(_shared_counter_answering(100), _turn_deployment(kind), _TURN_AT)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_a_later_turn_is_admitted_on_this_instance_s_count_when_the_shared_counter_is_unreachable(
+    kind: str,
+) -> None:
+    dual_cache: Final = _shared_counter_answering(RedisCircuitBreakerOpenError("circuit open"))
+    await dual_cache.in_memory_cache.async_increment(key=_turn_key(kind), value=99)
+
+    admitted: Final = await async_admit_io_token_turn(dual_cache, _turn_deployment(kind), _TURN_AT)
+
+    assert admitted[ITPM_CACHE_KEY if kind == "itpm" else OTPM_CACHE_KEY] == _turn_key(kind)
diff --git a/tests/unit/test_router/test_router.py b/tests/unit/test_router/test_router.py
index 1ac44b5976d..a6436e47507 100644
--- a/tests/unit/test_router/test_router.py
+++ b/tests/unit/test_router/test_router.py
@@ -2200,7 +2200,11 @@ async def test_ageneric_api_call_deployment_model_overrides_alias():
     )
 
     def inject_alias_into_kwargs(
-        deployment: dict, kwargs: dict, function_name: str | None = None, splits_stream_timeout: bool = False
+        deployment: dict,
+        kwargs: dict,
+        function_name: str | None = None,
+        splits_stream_timeout: bool = False,
+        opens_responses_socket: bool = False,
     ) -> None:
         # Simulate the alias leaking into kwargs (as happens when
         # _ageneric_api_call_with_fallbacks sets kwargs["model"] = alias before
diff --git a/tests/unit/test_router/test_router_helper_utils.py b/tests/unit/test_router/test_router_helper_utils.py
index 5f1b6032ca8..5f31ded626d 100644
--- a/tests/unit/test_router/test_router_helper_utils.py
+++ b/tests/unit/test_router/test_router_helper_utils.py
@@ -4,13 +4,15 @@ import gc
 import json
 import os
 import weakref
-from collections.abc import Iterator, Mapping
+from collections.abc import Awaitable, Callable, Iterator, Mapping
 from datetime import datetime, timezone
 from types import MethodType
 from typing import Final
 from unittest.mock import AsyncMock, MagicMock, patch
 
+import httpx
 import pytest
+import respx
 
 import litellm
 from litellm import Router
@@ -538,14 +540,14 @@ async def test_deployment_callback_on_success_counts_a_responses_websocket_turn(
     assert await router.cache.async_get_cache(key=tpm_key) == 17
 
 
-async def _kwargs_routed_to(router: Router, model: str, function_name: str) -> dict[str, object]:
+async def _kwargs_routed_to(router: Router, model: str, function_name: str, **request: object) -> dict[str, object]:
     routed: Final[dict[str, object]] = {}
 
     async def call(**kwargs: object) -> None:
         routed.update(kwargs)
 
     call.__name__ = function_name
-    await router._ageneric_api_call_with_fallbacks_helper(model=model, original_generic_function=call)
+    await router._ageneric_api_call_with_fallbacks_helper(model=model, original_generic_function=call, **request)
     return routed
 
 
@@ -715,6 +717,363 @@ async def test_responses_websocket_turns_do_not_reserve_deployment_otpm():
         await admit_turn()
 
 
+def _io_limited_router(kind: str, **litellm_params: object) -> Router:
+    return Router(
+        model_list=[
+            {
+                "model_name": "ws-io",
+                "litellm_params": {
+                    "model": "openai/ws-io-unpriced",
+                    "api_key": "sk-fake",
+                    kind: 10_000,
+                    **litellm_params,
+                },
+                "model_info": {"id": "ws-io-dep"},
+            }
+        ],
+        optional_pre_call_checks=["enforce_model_rate_limits"],
+    )
+
+
+def _minutes_counter_key(kind: str, minute: datetime, model: str = "openai/ws-io-unpriced") -> str:
+    return f"global_router:ws-io-dep:{model}:{kind}:{minute.strftime('%H-%M')}"
+
+
+async def _count_minutes_tokens(
+    router: Router, kind: str, tokens: int, minute: datetime, model: str = "openai/ws-io-unpriced"
+) -> None:
+    await router.cache.async_increment_cache(key=_minutes_counter_key(kind, minute, model), value=tokens, ttl=120)
+
+
+async def _settle_turn(
+    router: Router, reservation: Mapping[str, object], input_tokens: int, output_tokens: int
+) -> None:
+    from litellm.cost_calculator import ResponsesWebSocketTokenUsageProcessor
+    from litellm.litellm_core_utils.get_litellm_params import get_litellm_params
+    from litellm.router_utils.pre_call_checks.model_rate_limit_check import ModelRateLimitingCheck
+
+    rate_limits: Final = next(
+        check for check in router.optional_callbacks or () if isinstance(check, ModelRateLimitingCheck)
+    )
+    await rate_limits.async_log_success_event(
+        {"litellm_params": get_litellm_params(litellm_metadata=dict(reservation))},
+        ResponsesWebSocketTokenUsageProcessor.create_logging_object(
+            [
+                {
+                    "type": "response.completed",
+                    "response": {"usage": {"input_tokens": input_tokens, "output_tokens": output_tokens}},
+                }
+            ]
+        ),
+        None,
+        None,
+    )
+
+
+_LONG_OUTPUT_MODEL: Final = "openai/gpt-5.4-mini"
+
+
+def _long_output_router() -> tuple[Router, Mapping[str, int]]:
+    max_output: Final = litellm.get_model_info(_LONG_OUTPUT_MODEL)["max_output_tokens"]
+    assert isinstance(max_output, int)
+    limits: Final = {"itpm": 10_000, "otpm": max_output // 2}
+    return _io_limited_router("itpm", model=_LONG_OUTPUT_MODEL, otpm=limits["otpm"]), limits
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_responses_websocket_opens_without_counting_tokens_until_the_minute_reaches_deployment_io_limit(
+    kind: str, router_minute_pinned: datetime
+):
+    router, limits = _long_output_router()
+
+    await _kwargs_routed_to(router, "ws-io", "_aresponses_websocket", websocket=object())
+
+    assert [
+        await router.cache.async_get_cache(key=_minutes_counter_key(counted, router_minute_pinned, _LONG_OUTPUT_MODEL))
+        for counted in ("itpm", "otpm")
+    ] == [None, None]
+    await _count_minutes_tokens(router, kind, limits[kind], router_minute_pinned, _LONG_OUTPUT_MODEL)
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit={limits[kind]}, current usage="):
+        await _kwargs_routed_to(router, "ws-io", "_aresponses_websocket", websocket=object())
+
+
+@pytest.mark.asyncio
+async def test_responses_websocket_first_turn_counts_its_actual_tokens_toward_deployment_itpm_and_otpm(
+    router_minute_pinned: datetime,
+):
+    router, _ = _long_output_router()
+    socket_metadata: Final = (await _kwargs_routed_to(router, "ws-io", "_aresponses_websocket", websocket=object()))[
+        "litellm_metadata"
+    ]
+    assert isinstance(socket_metadata, dict)
+
+    await _settle_turn(router, socket_metadata, input_tokens=20, output_tokens=15)
+
+    assert [
+        await router.cache.async_get_cache(key=_minutes_counter_key(counted, router_minute_pinned, _LONG_OUTPUT_MODEL))
+        for counted in ("itpm", "otpm")
+    ] == [20, 15]
+
+
+_ADMITTED_LATE_IN_THE_MINUTE: Final = datetime(2026, 1, 1, 12, 0, 50, tzinfo=timezone.utc)
+_FINISHED_IN_THE_NEXT_MINUTE: Final = datetime(2026, 1, 1, 12, 1, 15, tzinfo=timezone.utc)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+@pytest.mark.parametrize("turn", ["first", "later"])
+async def test_responses_websocket_turn_finishing_in_the_next_minute_counts_its_tokens_toward_that_minute(
+    kind: str, turn: str, monkeypatch: pytest.MonkeyPatch
+):
+    _pin_router_clock(monkeypatch, _ADMITTED_LATE_IN_THE_MINUTE)
+    router: Final = _io_limited_router(kind)
+    socket: Final = await _kwargs_routed_to(router, "ws-io", "_aresponses_websocket", websocket=object())
+    admit_turn: Final = socket["turn_admission"]
+    assert callable(admit_turn)
+    reservation: Final = socket["litellm_metadata"] if turn == "first" else await admit_turn()
+    assert isinstance(reservation, Mapping)
+    _pin_router_clock(monkeypatch, _FINISHED_IN_THE_NEXT_MINUTE)
+
+    await _settle_turn(router, reservation, input_tokens=10_000, output_tokens=10_000)
+
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit=10000, current usage=10000"):
+        await admit_turn()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("body", [{}, {"websocket": True}], ids=["plain", "websocket_key"])
+async def test_messages_call_reserves_max_tokens_against_deployment_otpm_whatever_websocket_key_its_body_carries(
+    body: Mapping[str, object], router_minute_pinned: datetime
+):
+    router: Final = _io_limited_router("otpm")
+
+    for _ in range(3):
+        await _kwargs_routed_to(router, "ws-io", "anthropic_messages", max_tokens=3_000, **body)
+
+    assert await router.cache.async_get_cache(key=_minutes_counter_key("otpm", router_minute_pinned)) == 9_000
+    with pytest.raises(litellm.RateLimitError, match="OTPM limit=10000, current usage=12000"):
+        await _kwargs_routed_to(router, "ws-io", "anthropic_messages", max_tokens=3_000, **body)
+
+
+async def _realtime_opens_until_refused(monkeypatch: pytest.MonkeyPatch, **socket: object) -> tuple[int, str]:
+    monkeypatch.setattr(litellm, "callbacks", [])
+    router: Final = _io_limited_router("otpm", otpm=50)
+    for opened in range(51):
+        try:
+            await _kwargs_routed_to(router, "ws-io", "_arealtime", **socket)
+        except litellm.RateLimitError as refused:
+            return opened, str(refused)
+    pytest.fail("realtime opens never reached the deployment's otpm")
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("router_minute_pinned")
+async def test_realtime_open_reserves_and_is_refused_at_deployment_otpm_like_an_open_without_a_socket(
+    monkeypatch: pytest.MonkeyPatch,
+):
+    with_socket: Final = await _realtime_opens_until_refused(monkeypatch, websocket=object())
+
+    assert "OTPM limit=50, current usage=" in with_socket[1]
+    assert with_socket == await _realtime_opens_until_refused(monkeypatch)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_responses_websocket_turn_is_refused_once_the_minutes_tokens_reach_deployment_io_limit(
+    kind: str, router_minute_pinned: datetime
+):
+    router: Final = _io_limited_router(kind)
+    admit_turn: Final = (await _kwargs_routed_to(router, "ws-io", "_aresponses_websocket"))["turn_admission"]
+    assert callable(admit_turn)
+    await _count_minutes_tokens(router, kind, 10_000, router_minute_pinned)
+
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit=10000, current usage="):
+        await admit_turn()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["itpm", "otpm"])
+async def test_responses_websocket_turn_refused_for_tokens_leaves_the_daily_request_limit_unused(
+    kind: str, router_minute_pinned: datetime
+):
+    router: Final = _io_limited_router(kind, rpd=2)
+    admit_turn: Final = (await _kwargs_routed_to(router, "ws-io", "_aresponses_websocket"))["turn_admission"]
+    assert callable(admit_turn)
+    await _count_minutes_tokens(router, kind, 10_000, router_minute_pinned)
+    with pytest.raises(litellm.RateLimitError, match=f"{kind.upper()} limit=10000"):
+        await admit_turn()
+    await _count_minutes_tokens(router, kind, -10_000, router_minute_pinned)
+
+    await admit_turn()
+
+    with pytest.raises(litellm.RateLimitError, match="RPD"):
+        await admit_turn()
+
+
+_PROVIDER_RESPONSE: Final = {
+    "id": "resp_io",
+    "object": "response",
+    "created_at": 1767268830,
+    "status": "completed",
+    "model": "ws-io-unpriced",
+    "output": [
+        {
+            "type": "message",
+            "id": "msg_io",
+            "status": "completed",
+            "role": "assistant",
+            "content": [{"type": "output_text", "text": "Done.", "annotations": []}],
+        }
+    ],
+    "parallel_tool_calls": True,
+    "tool_choice": "auto",
+    "tools": [],
+    "usage": {"input_tokens": 10, "output_tokens": 5, "total_tokens": 15},
+}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "client_metadata", [None, {"session": "abc", "team": "search"}], ids=["without_metadata", "with_metadata"]
+)
+async def test_responses_call_sends_the_provider_only_the_client_metadata_and_settles_deployment_io_tokens(
+    client_metadata: Mapping[str, str] | None,
+    router_minute_pinned: datetime,
+    monkeypatch: pytest.MonkeyPatch,
+    respx_mock: respx.MockRouter,
+):
+    from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER
+    from litellm.responses.streaming_iterator import drain_logging_tasks
+
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    litellm.in_memory_llm_clients_cache.flush_cache()
+    provider: Final = respx_mock.post("https://api.openai.com/v1/responses").mock(
+        return_value=httpx.Response(200, json=_PROVIDER_RESPONSE)
+    )
+    router: Final = _io_limited_router("itpm", otpm=10_000)
+
+    await router.aresponses(
+        model="ws-io",
+        input="hi",
+        max_output_tokens=50,
+        **({} if client_metadata is None else {"metadata": dict(client_metadata)}),
+    )
+    await drain_logging_tasks()
+    await asyncio.wait_for(GLOBAL_LOGGING_WORKER.flush(), timeout=10.0)
+
+    assert [json.loads(call.request.read()).get("metadata") for call in provider.calls] == [client_metadata]
+    assert [
+        await router.cache.async_get_cache(key=_minutes_counter_key(kind, router_minute_pinned))
+        for kind in ("itpm", "otpm")
+    ] == [10, 5]
+
+
+@pytest.mark.parametrize(
+    "client_metadata", [None, {"session": "abc", "team": "search"}], ids=["without_metadata", "with_metadata"]
+)
+def test_sync_responses_call_sends_the_provider_only_the_client_metadata(
+    client_metadata: Mapping[str, str] | None, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter
+):
+    litellm.in_memory_llm_clients_cache.flush_cache()
+    provider: Final = respx_mock.post("https://api.openai.com/v1/responses").mock(
+        return_value=httpx.Response(200, json=_PROVIDER_RESPONSE)
+    )
+
+    _io_limited_router("itpm", otpm=10_000).responses(
+        model="ws-io",
+        input="hi",
+        max_output_tokens=50,
+        **({} if client_metadata is None else {"metadata": dict(client_metadata)}),
+    )
+
+    assert [json.loads(call.request.read()).get("metadata") for call in provider.calls] == [client_metadata]
+
+
+_ANTHROPIC_PROVIDER_RESPONSE: Final = {
+    "id": "msg_io",
+    "type": "message",
+    "role": "assistant",
+    "model": "ws-io-unpriced",
+    "content": [{"type": "text", "text": "Done."}],
+    "stop_reason": "end_turn",
+    "stop_sequence": None,
+    "usage": {"input_tokens": 10, "output_tokens": 5},
+}
+
+
+async def _responses_call(router: Router) -> object:
+    return await router.aresponses(model="ws-io", input="hi", max_output_tokens=50)
+
+
+async def _messages_call(router: Router) -> object:
+    return await router.aanthropic_messages(model="ws-io", messages=[{"role": "user", "content": "hi"}], max_tokens=50)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("model", "provider_url", "provider_response", "call"),
+    [
+        pytest.param(
+            "openai/ws-io-unpriced",
+            "https://api.openai.com/v1/responses",
+            _PROVIDER_RESPONSE,
+            _responses_call,
+            id="responses",
+        ),
+        pytest.param(
+            "anthropic/ws-io-unpriced",
+            "https://api.anthropic.com/v1/messages",
+            _ANTHROPIC_PROVIDER_RESPONSE,
+            _messages_call,
+            id="messages",
+        ),
+    ],
+)
+async def test_retried_call_settles_deployment_io_tokens_to_the_successful_attempt_s_tokens(
+    model: str,
+    provider_url: str,
+    provider_response: Mapping[str, object],
+    call: Callable[[Router], Awaitable[object]],
+    router_minute_pinned: datetime,
+    monkeypatch: pytest.MonkeyPatch,
+    respx_mock: respx.MockRouter,
+):
+    from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER
+    from litellm.responses.streaming_iterator import drain_logging_tasks
+
+    monkeypatch.setattr(litellm, "disable_aiohttp_transport", True)
+    litellm.in_memory_llm_clients_cache.flush_cache()
+    provider: Final = respx_mock.post(provider_url).mock(
+        side_effect=[
+            httpx.Response(500, json={"error": {"message": "upstream failed", "type": "server_error"}}),
+            httpx.Response(200, json=provider_response),
+        ]
+    )
+    router: Final = Router(
+        model_list=[
+            {
+                "model_name": "ws-io",
+                "litellm_params": {"model": model, "api_key": "sk-fake", "itpm": 10_000, "otpm": 10_000},
+                "model_info": {"id": "ws-io-dep"},
+            }
+        ],
+        optional_pre_call_checks=["enforce_model_rate_limits"],
+        num_retries=1,
+        retry_after=0,
+    )
+
+    await call(router)
+    await drain_logging_tasks()
+    await asyncio.wait_for(GLOBAL_LOGGING_WORKER.flush(), timeout=10.0)
+
+    assert provider.call_count == 2
+    assert [
+        await router.cache.async_get_cache(key=_minutes_counter_key(kind, router_minute_pinned, model))
+        for kind in ("itpm", "otpm")
+    ] == [10, 5]
+
+
 @pytest.mark.asyncio
 async def test_deployment_callback_on_success_tracks_tpm_for_io_deployment():
     """
@@ -1194,10 +1553,17 @@ def _rpm_tpm_router(model_id: str) -> Router:
     )
 
 
+def _pin_router_clock(monkeypatch: pytest.MonkeyPatch, pinned: datetime) -> None:
+    monkeypatch.setattr("litellm.router.get_utc_datetime", lambda: pinned)
+    monkeypatch.setattr(
+        "litellm.router_utils.pre_call_checks.io_token_rate_limit_check.get_utc_datetime", lambda: pinned
+    )
+
+
 @pytest.fixture
 def router_minute_pinned(monkeypatch: pytest.MonkeyPatch) -> datetime:
     pinned: Final = datetime(2026, 1, 1, 12, 0, 30, tzinfo=timezone.utc)
-    monkeypatch.setattr("litellm.router.get_utc_datetime", lambda: pinned)
+    _pin_router_clock(monkeypatch, pinned)
     return pinned
 
 
diff --git a/ui/litellm-dashboard/public/assets/logos/aiand.svg b/ui/litellm-dashboard/public/assets/logos/aiand.svg
new file mode 100644
index 00000000000..486c73b8dbc
--- /dev/null
+++ b/ui/litellm-dashboard/public/assets/logos/aiand.svg
@@ -0,0 +1,4 @@
+<svg width="154" height="170" viewBox="0 0 154 170" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M142.201 58.0338C147.015 54.3129 153.925 57.8127 153.925 63.9711V162.493C153.925 166.608 150.654 169.944 146.617 169.944H142.131C141.665 169.944 141.22 169.751 140.896 169.411L112.255 139.292C109.89 136.807 106.099 136.452 103.331 138.459L60.3523 169.62C60.0612 169.831 59.7129 169.944 59.3559 169.944H19.1938C12.1908 169.944 9.19832 160.871 14.7784 156.556L142.201 58.0338Z" fill="#151517"/>
+<path d="M142.474 1.14602C146.28 -1.75046 151.759 1.18386 151.457 6.14031L149.665 35.5148C149.561 37.2177 148.728 38.7803 147.4 39.7908L8.99184 145.042C5.31127 147.841 0.000248842 145.196 0 140.407V112.48C2.31386e-05 110.648 0.848057 108.933 2.27475 107.846L142.474 1.14602Z" fill="#C70007"/>
+</svg>
diff --git a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx
index 7ab757cfed9..d7394b1f949 100644
--- a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx
+++ b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.test.tsx
@@ -775,6 +775,39 @@ describe("ModelSelect", () => {
     expect(mockOnChange).toHaveBeenCalledWith(["gpt-4"]);
   });
 
+  it.each([
+    { value: "all-proxy-models", label: "All Proxy Models", includeSpecialOptions: true },
+    { value: "no-default-models", label: "No Default Models", includeSpecialOptions: false },
+  ])(
+    "should label retained $value without offering it again after removal",
+    async ({ value, label, includeSpecialOptions }) => {
+      const user = userEvent.setup();
+      mockUseOrganization.mockReturnValue({
+        data: createMockOrganization(["gpt-4"]),
+        isLoading: false,
+      } as unknown as ReturnType<typeof useOrganization>);
+      const props = {
+        onChange: mockOnChange,
+        context: "team" as const,
+        organizationID: "org-1",
+        options: { includeSpecialOptions },
+      };
+      const { rerender } = renderWithProviders(<ModelSelect {...props} value={[value]} />);
+
+      expect(screen.getByLabelText(label)).toBeInTheDocument();
+      await openModelList(user);
+      const retainedGroup = within(screen.getByRole("listbox")).getAllByRole("group")[0];
+      expect(within(retainedGroup).getByText("Unavailable")).toBeInTheDocument();
+      await user.click(within(retainedGroup).getByRole("option", { name: label }));
+      expect(mockOnChange).toHaveBeenCalledWith([]);
+
+      rerender(<ModelSelect {...props} value={[]} />);
+      expectNotOffered(label);
+      expectNotOffered("claude-3");
+      expectOffered("gpt-4");
+    },
+  );
+
   it("should keep the other selections when removing one unavailable model alongside a special option", async () => {
     const user = userEvent.setup();
     renderWithProviders(
diff --git a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx
index f169382b4ed..c7c428f2ccf 100644
--- a/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx
+++ b/ui/litellm-dashboard/src/components/ModelSelect/ModelSelect.tsx
@@ -240,7 +240,10 @@ export const ModelSelect = (props: ModelSelectProps) => {
   ];
 
   const offeredByValue = new Map(offeredGroups.flatMap((group) => group.items).map((option) => [option.value, option]));
-  const selectedOptions = value.map((v) => offeredByValue.get(v) ?? { label: v, value: v });
+  const selectedOptions = value.map(
+    (v) =>
+      offeredByValue.get(v) ?? MODEL_SENTINEL_OPTIONS.find((option) => option.value === v) ?? { label: v, value: v },
+  );
   const groups: ModelOptionGroup[] = [
     ...unavailableGroups(
       selectedOptions,
diff --git a/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx b/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx
index 810b010f25e..02c31ecc082 100644
--- a/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx
+++ b/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx
@@ -32,6 +32,18 @@ describe("provider_info_helpers", () => {
     expect(getPlaceholder(Providers.BIGMODEL)).toMatch(/^bigmodel\//);
   });
 
+  it("resolves ai& metadata, name, logo and model placeholder", () => {
+    const metadata = PROVIDER_CREATE_FIELDS.find((provider) => provider.provider === "AIAND");
+    expect(provider_map.AIAND).toBe(metadata?.litellm_provider);
+    expect(getProviderLogoAndName("aiand")).toEqual({
+      displayName: "ai&",
+      logo: providerLogoMap[Providers.AIAND],
+    });
+    expect(getProviderLogoAndName("AIAND")).toEqual(getProviderLogoAndName("aiand"));
+    expect(providerLogoMap[Providers.AIAND]).toContain("aiand");
+    expect(getPlaceholder(Providers.AIAND)).toBe("aiand/openai/gpt-oss-120b");
+  });
+
   it("maps Microsoft 365 Copilot to its chat model provider and placeholder", () => {
     expect(provider_map.MICROSOFT_365_COPILOT).toBe("microsoft_365_copilot");
     expect(getPlaceholder(Providers.MICROSOFT_365_COPILOT)).toBe("microsoft_365_copilot/chat");
diff --git a/ui/litellm-dashboard/src/components/provider_info_helpers.tsx b/ui/litellm-dashboard/src/components/provider_info_helpers.tsx
index 1ed32c160e6..6448bd936cc 100644
--- a/ui/litellm-dashboard/src/components/provider_info_helpers.tsx
+++ b/ui/litellm-dashboard/src/components/provider_info_helpers.tsx
@@ -1,6 +1,7 @@
 import { resolveLogoSrc } from "@/lib/assetPaths";
 import a2aAgentLogo from "../../public/assets/logos/a2a_agent.png";
 import ai21Logo from "../../public/assets/logos/ai21.svg";
+import aiandLogo from "../../public/assets/logos/aiand.svg";
 import aimlApiLogo from "../../public/assets/logos/aiml_api.svg";
 import anthropicLogo from "../../public/assets/logos/anthropic.svg";
 import assemblyaiSmallLogo from "../../public/assets/logos/assemblyai_small.png";
@@ -76,6 +77,7 @@ export enum Providers {
   A2A_Agent = "A2A Agent",
   AI21 = "Ai21",
   AI21_CHAT = "Ai21 Chat",
+  AIAND = "ai&",
   AIML = "AI/ML API",
   AIOHTTP_OPENAI = "Aiohttp Openai",
   Anthropic = "Anthropic",
@@ -207,6 +209,7 @@ export const provider_map: Record<string, string> = {
   A2A_Agent: "a2a_agent",
   AI21: "ai21",
   AI21_CHAT: "ai21_chat",
+  AIAND: "aiand",
   AIML: "aiml",
   AIOHTTP_OPENAI: "aiohttp_openai",
   Anthropic: "anthropic",
@@ -344,6 +347,7 @@ export const providerLogoMap: Partial<Record<Providers, string>> = {
   [Providers.A2A_Agent]: a2aAgentLogo.src,
   [Providers.AI21]: ai21Logo.src,
   [Providers.AI21_CHAT]: ai21Logo.src,
+  [Providers.AIAND]: aiandLogo.src,
   [Providers.AIML]: aimlApiLogo.src,
   [Providers.AIOHTTP_OPENAI]: openaiSmallLogo.src,
   [Providers.Anthropic]: anthropicLogo.src,
@@ -472,6 +476,7 @@ export const getProviderLogoAndName = (providerValue: string): { logo: string; d
 
 const providerPlaceholderMap: Partial<Record<Providers, string>> = {
   [Providers.AIML]: "aiml/flux-pro/v1.1",
+  [Providers.AIAND]: "aiand/openai/gpt-oss-120b",
   [Providers.Anthropic]: "claude-3-opus",
   [Providers.Azure]: "my-deployment",
   [Providers.Azure_AI_Studio]: "azure_ai/command-r-plus",
diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx
index fc054e51e5b..545c504281b 100644
--- a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx
+++ b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx
@@ -1,6 +1,6 @@
 import { useTeamMetadataSchema } from "@/app/(dashboard)/hooks/teams/useTeamMetadataSchema";
 import * as networking from "@/components/networking";
-import { fireEvent, screen, waitFor } from "@testing-library/react";
+import { fireEvent, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { renderWithProviders } from "../../../tests/test-utils";
@@ -817,7 +817,7 @@ describe("TeamInfoView - member budget reset prompt", () => {
   });
 });
 
-describe("TeamInfoView - model rate limit picker", () => {
+describe("TeamInfoView - model settings", () => {
   const props = {
     teamId: "123",
     onUpdate: vi.fn(),
@@ -836,6 +836,61 @@ describe("TeamInfoView - model rate limit picker", () => {
     vi.clearAllMocks();
   });
 
+  it.each([
+    { name: "unrestricted", models: [], organizationId: null },
+    { name: "explicit all models", models: ["all-proxy-models"], organizationId: null },
+    { name: "access groups only", models: ["no-default-models"], organizationId: null },
+    { name: "retained explicit models", models: ["retired-model", "openai/*"], organizationId: null },
+    { name: "unrestricted within an organization", models: [], organizationId: "org-1" },
+  ])("preserves $name model grants when saving only a budget", async ({ models, organizationId }) => {
+    const user = userEvent.setup({ delay: null });
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(
+      createMockTeamData({ models, organization_id: organizationId }),
+    );
+    mockUseTeam.mockReturnValue({
+      data: { team_id: "123", organization_models: organizationId ? ["gpt-4"] : undefined },
+      isLoading: false,
+    } as unknown as ReturnType<typeof useTeam>);
+
+    renderWithProviders(<TeamInfoView {...props} userModels={["gpt-4"]} />);
+    await user.click(await screen.findByRole("tab", { name: "Settings" }));
+    await user.click(await screen.findByRole("button", { name: /edit settings/i }));
+    if (models.length === 0) {
+      expect(await screen.findByLabelText("All Proxy Models")).toBeInTheDocument();
+    }
+    fireEvent.change(await screen.findByLabelText("Max Budget (USD)"), { target: { value: "100" } });
+    await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+    await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1));
+    const payload = vi.mocked(networking.teamUpdateCall).mock.calls[0][1];
+    expect(payload).toMatchObject({ team_id: "123", max_budget: 100 });
+    expect(payload).not.toHaveProperty("models");
+  });
+
+  it("discards a cancelled model clear but saves an intentional clear of unrestricted access", async () => {
+    const user = userEvent.setup({ delay: null });
+    vi.mocked(networking.teamInfoCall).mockResolvedValue(createMockTeamData({ models: [] }));
+
+    renderWithProviders(<TeamInfoView {...props} userModels={["gpt-4"]} />);
+    await user.click(await screen.findByRole("tab", { name: "Settings" }));
+    await user.click(await screen.findByRole("button", { name: /edit settings/i }));
+    await user.click(within(await screen.findByLabelText("All Proxy Models")).getByRole("button"));
+    await user.click(screen.getByRole("button", { name: "Cancel" }));
+    await user.click(await screen.findByRole("button", { name: /edit settings/i }));
+    expect(await screen.findByLabelText("All Proxy Models")).toBeInTheDocument();
+    fireEvent.change(screen.getByLabelText("Max Budget (USD)"), { target: { value: "100" } });
+    await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+    await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1]).not.toHaveProperty("models");
+    await user.click(await screen.findByRole("button", { name: /edit settings/i }));
+    await user.click(within(await screen.findByLabelText("All Proxy Models")).getByRole("button"));
+    await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+    await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(2));
+    expect(vi.mocked(networking.teamUpdateCall).mock.calls[1][1].models).toEqual(["no-default-models"]);
+  });
+
   it("offers access-group models, not no-default-models, in the model rate limit picker", async () => {
     const user = userEvent.setup({ delay: null });
     vi.mocked(networking.teamInfoCall).mockResolvedValue(
diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx
index e4bf67ab72f..46081ae96f5 100644
--- a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx
+++ b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx
@@ -2421,7 +2421,6 @@ describe("TeamInfoView - the exact bytes the update call sends", () => {
   const alwaysSent = {
     team_id: "123",
     team_alias: "Test Team",
-    models: ["gpt-4"],
     tpm_limit: 1000,
     rpm_limit: 1000,
     tpd_limit: null,
diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
index 0d20d160283..329552d735a 100644
--- a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
+++ b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
@@ -72,6 +72,7 @@ import {
 } from "../key_team_helpers/ModelMaxBudgetEditor";
 import { modelMaxBudgetUpdate, StoredModelMaxBudget } from "../key_team_helpers/modelMaxBudgetPayload";
 import {
+  ALL_PROXY_MODELS,
   computeTeamModelBadges,
   normalizeTeamModelSelection,
   TeamAccessGroupModelGrant,
@@ -515,7 +516,7 @@ const computeEffectiveGuardrails = (info: TeamInfoRecord, globalGuardrailNames:
 
 const toTeamFormValues = (info: TeamInfoRecord, effectiveGuardrails: string[]): TeamUpdateFormValues => ({
   team_alias: info.team_alias,
-  models: info.models,
+  models: info.models.length === 0 ? [ALL_PROXY_MODELS] : info.models,
   max_budget: info.max_budget,
   soft_budget: info.soft_budget,
   soft_budget_alerting_emails: Array.isArray(info.metadata?.soft_budget_alerting_emails)
@@ -1064,7 +1065,7 @@ const TeamInfoView: React.FC<TeamInfoProps> = ({
       const updateData: any = {
         team_id: teamId,
         team_alias: values.team_alias,
-        models: normalizeTeamModelSelection(values.models),
+        ...(form.getFieldState("models").isDirty ? { models: normalizeTeamModelSelection(values.models) } : {}),
         tpm_limit: numberOrNull(values.tpm_limit),
         rpm_limit: numberOrNull(values.rpm_limit),
         tpd_limit: numberOrNull(values.tpd_limit),
diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts
index 960616e2631..aafa732276b 100644
--- a/ui/litellm-dashboard/src/lib/http/schema.d.ts
+++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts
@@ -27870,7 +27870,10 @@ export interface components {
             entities?: {
                 [key: string]: components["schemas"]["MetricWithMetadata"];
             };
-            /** Guardrails */
+            /**
+             * Guardrails
+             * @description Spend by guardrail ID, already included in key and model spend. Populated on user, team and organization aggregated activity only, without a model filter
+             */
             guardrails?: {
                 [key: string]: components["schemas"]["GuardrailMetric"];
             };
@@ -33448,32 +33451,44 @@ export interface components {
         };
         /** GuardrailKeyMetric */
         GuardrailKeyMetric: {
+            /** @description API key alias and existence information */
             metadata: components["schemas"]["KeyMetadata"];
+            /** @description Guardrail spend and unpriced units for this API key */
             metrics: components["schemas"]["GuardrailSpendMetrics"];
         };
         /** GuardrailMetadata */
         GuardrailMetadata: {
-            /** Guardrail Name */
+            /**
+             * Guardrail Name
+             * @description Guardrail display name, falling back to the guardrail ID
+             */
             guardrail_name: string;
         };
         /** GuardrailMetric */
         GuardrailMetric: {
-            /** Api Key Breakdown */
+            /**
+             * Api Key Breakdown
+             * @description Per-key guardrail spend and unpriced units, limited to keys in the day's API key breakdown
+             */
             api_key_breakdown?: {
                 [key: string]: components["schemas"]["GuardrailKeyMetric"];
             };
+            /** @description Guardrail name information */
             metadata: components["schemas"]["GuardrailMetadata"];
+            /** @description Guardrail spend and unpriced units across all matching API keys */
             metrics: components["schemas"]["GuardrailSpendMetrics"];
         };
         /** GuardrailSpendMetrics */
         GuardrailSpendMetrics: {
             /**
              * Spend
+             * @description Guardrail spend in USD, already included in key and model spend
              * @default 0
              */
             spend: number;
             /**
              * Untracked Units
+             * @description Guardrail units with no known price, excluded from spend
              * @default 0
              */
             untracked_units: number;
@@ -76633,7 +76648,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76682,7 +76697,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76727,7 +76742,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76773,7 +76788,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76820,7 +76835,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76866,7 +76881,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76912,7 +76927,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
@@ -76958,7 +76973,7 @@ export interface operations {
                 end_date?: string | null;
                 /** @description Filter by specific model */
                 model?: string | null;
-                /** @description Filter by specific API key */
+                /** @description Filter by reporting API key ID. Missing keys are reported as unattributed. For a literal key unattributed or a key starting with raw:, add an extra raw: prefix */
                 api_key?: string | null;
                 /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */
                 user_id?: string | null;
diff --git a/ui/litellm-dashboard/src/lib/logoTreatments.ts b/ui/litellm-dashboard/src/lib/logoTreatments.ts
index fc19c5c364d..4cd6f65a613 100644
--- a/ui/litellm-dashboard/src/lib/logoTreatments.ts
+++ b/ui/litellm-dashboard/src/lib/logoTreatments.ts
@@ -32,6 +32,7 @@ const TREATMENT_BY_ASSET: Readonly<Record<string, LogoTreatment>> = {
   "v0.svg": "invert",
   "vercel.svg": "invert",
   "watsonx.svg": "invert",
+  "aiand.svg": "plate",
   "aiml_api.svg": "plate",
   "akto.svg": "plate",
   "aws.svg": "plate",