Staging - 12/17/2025

docker/Dockerfile.alpine

@@ -34,8 +34,8 @@ RUN pip wheel --no-cache-dir --wheel-dir=/wheels/ -r requirements.txt
 # Runtime stage
 FROM $LITELLM_RUNTIME_IMAGE AS runtime
 
-# Update dependencies and clean up
-RUN apk upgrade --no-cache
+# Update dependencies and clean up, install libsndfile for audio processing
+RUN apk upgrade --no-cache && apk add --no-cache libsndfile
 
 WORKDIR /app
 

litellm/images/main.py

@@ -795,6 +795,8 @@ def image_edit(
                 model=model,
                 image_edit_provider_config=image_edit_provider_config,
                 image_edit_optional_params=image_edit_optional_params,
+                drop_params=kwargs.get("drop_params"),
+                additional_drop_params=kwargs.get("additional_drop_params"),
             )
         )
 

litellm/images/utils.py

@@ -1,5 +1,5 @@
 from io import BufferedReader, BytesIO
-from typing import Any, Dict, cast, get_type_hints
+from typing import Any, Dict, List, Optional, cast, get_type_hints
 
 import litellm
 from litellm.litellm_core_utils.token_counter import get_image_type
@@ -14,41 +14,53 @@ def get_optional_params_image_edit(
         model: str,
         image_edit_provider_config: BaseImageEditConfig,
         image_edit_optional_params: ImageEditOptionalRequestParams,
+        drop_params: Optional[bool] = None,
+        additional_drop_params: Optional[List[str]] = None,
     ) -> Dict:
         """
         Get optional parameters for the image edit API.
 
         Args:
-            params: Dictionary of all parameters
             model: The model name
             image_edit_provider_config: The provider configuration for image edit API
+            image_edit_optional_params: The optional parameters for the image edit API
+            drop_params: If True, silently drop unsupported parameters instead of raising
+            additional_drop_params: List of additional parameter names to drop
 
         Returns:
             A dictionary of supported parameters for the image edit API
         """
-        # Remove None values and internal parameters
-
-        # Get supported parameters for the model
         supported_params = image_edit_provider_config.get_supported_openai_params(model)
 
-        # Check for unsupported parameters
+        should_drop = litellm.drop_params is True or drop_params is True
+
+        filtered_optional_params = dict(image_edit_optional_params)
+        if additional_drop_params:
+            for param in additional_drop_params:
+                filtered_optional_params.pop(param, None)
+
         unsupported_params = [
             param
-            for param in image_edit_optional_params
+            for param in filtered_optional_params
             if param not in supported_params
         ]
 
         if unsupported_params:
-            raise litellm.UnsupportedParamsError(
-                model=model,
-                message=f"The following parameters are not supported for model {model}: {', '.join(unsupported_params)}",
-            )
+            if should_drop:
+                for param in unsupported_params:
+                    filtered_optional_params.pop(param, None)
+            else:
+                raise litellm.UnsupportedParamsError(
+                    model=model,
+                    message=f"The following parameters are not supported for model {model}: {', '.join(unsupported_params)}",
+                )
 
-        # Map parameters to provider-specific format
         mapped_params = image_edit_provider_config.map_openai_params(
-            image_edit_optional_params=image_edit_optional_params,
+            image_edit_optional_params=cast(
+                ImageEditOptionalRequestParams, filtered_optional_params
+            ),
             model=model,
-            drop_params=litellm.drop_params,
+            drop_params=should_drop,
         )
 
         return mapped_params

litellm/integrations/prometheus.py

@@ -815,7 +815,20 @@ async def async_log_success_event(self, kwargs, response_obj, start_time, end_ti
         user_api_key_auth_metadata: Optional[dict] = standard_logging_payload[
             "metadata"
         ].get("user_api_key_auth_metadata")
+
+        # Include top-level metadata fields (excluding nested dictionaries)
+        # This allows accessing fields like requester_ip_address from top-level metadata
+        top_level_metadata = standard_logging_payload.get("metadata", {})
+        top_level_fields: Dict[str, Any] = {}
+        if isinstance(top_level_metadata, dict):
+            top_level_fields = {
+                k: v
+                for k, v in top_level_metadata.items()
+                if not isinstance(v, dict)  # Exclude nested dicts to avoid conflicts
+            }
+
         combined_metadata: Dict[str, Any] = {
+            **top_level_fields,  # Include top-level fields first
             **(_requester_metadata if _requester_metadata else {}),
             **(user_api_key_auth_metadata if user_api_key_auth_metadata else {}),
         }

litellm/llms/anthropic/chat/guardrail_translation/handler.py

@@ -253,20 +253,39 @@ async def process_output_response(
         task_mappings: List[Tuple[int, Optional[int]]] = []
         # Track (content_index, None) for each text
 
-        response_content = response.get("content", [])
+        # Handle both dict and object responses
+        response_content: List[Any] = []
+        if isinstance(response, dict):
+            response_content = response.get("content", []) or []
+        elif hasattr(response, "content"):
+            content = getattr(response, "content", None)
+            response_content = content or []
+        else:
+            response_content = []
+
         if not response_content:
             return response
 
         # Step 1: Extract all text content and tool calls from response
         for content_idx, content_block in enumerate(response_content):
-            # Check if this is a text or tool_use block by checking the 'type' field
-            if isinstance(content_block, dict) and content_block.get("type") in [
-                "text",
-                "tool_use",
-            ]:
-                # Cast to dict to handle the union type properly
+            # Handle both dict and Pydantic object content blocks
+            block_dict: Dict[str, Any] = {}
+            if isinstance(content_block, dict):
+                block_type = content_block.get("type")
+                block_dict = cast(Dict[str, Any], content_block)
+            elif hasattr(content_block, "type"):
+                block_type = getattr(content_block, "type", None)
+                # Convert Pydantic object to dict for processing
+                if hasattr(content_block, "model_dump"):
+                    block_dict = content_block.model_dump()
+                else:
+                    block_dict = {"type": block_type, "text": getattr(content_block, "text", None)}
+            else:
+                continue
+
+            if block_type in ["text", "tool_use"]:
                 self._extract_output_text_and_images(
-                    content_block=cast(Dict[str, Any], content_block),
+                    content_block=block_dict,
                     content_idx=content_idx,
                     texts_to_check=texts_to_check,
                     images_to_check=images_to_check,
@@ -530,7 +549,11 @@ def _has_text_content(self, response: "AnthropicMessagesResponse") -> bool:
 
         Override this method to customize text content detection.
         """
-        response_content = response.get("content", [])
+        if isinstance(response, dict):
+            response_content = response.get("content", [])
+        else:
+            response_content = getattr(response, "content", None) or []
+
         if not response_content:
             return False
         for content_block in response_content:
@@ -590,7 +613,16 @@ async def _apply_guardrail_responses_to_output(
             mapping = task_mappings[task_idx]
             content_idx = cast(int, mapping[0])
 
-            response_content = response.get("content", [])
+            # Handle both dict and object responses
+            response_content: List[Any] = []
+            if isinstance(response, dict):
+                response_content = response.get("content", []) or []
+            elif hasattr(response, "content"):
+                content = getattr(response, "content", None)
+                response_content = content or []
+            else:
+                continue
+
             if not response_content:
                 continue
 
@@ -601,7 +633,11 @@ async def _apply_guardrail_responses_to_output(
             content_block = response_content[content_idx]
 
             # Verify it's a text block and update the text field
-            if isinstance(content_block, dict) and content_block.get("type") == "text":
-                # Cast to dict to handle the union type properly for assignment
-                content_block = cast("AnthropicResponseTextBlock", content_block)
-                content_block["text"] = guardrail_response
+            # Handle both dict and Pydantic object content blocks
+            if isinstance(content_block, dict):
+                if content_block.get("type") == "text":
+                    cast(Dict[str, Any], content_block)["text"] = guardrail_response
+            elif hasattr(content_block, "type") and getattr(content_block, "type", None) == "text":
+                # Update Pydantic object's text attribute
+                if hasattr(content_block, "text"):
+                    content_block.text = guardrail_response

litellm/llms/openai/responses/guardrail_translation/handler.py

@@ -30,7 +30,7 @@
 
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
 
-from openai.types.responses import ResponseFunctionToolCall
+from openai.types.responses.response_function_tool_call import ResponseFunctionToolCall
 from pydantic import BaseModel
 
 from litellm._logging import verbose_proxy_logger
@@ -299,8 +299,25 @@ async def process_output_response(
         task_mappings: List[Tuple[int, int]] = []
         # Track (output_item_index, content_index) for each text
 
+        # Handle both dict and Pydantic object responses
+        if isinstance(response, dict):
+            response_output = response.get("output", [])
+        elif hasattr(response, "output"):
+            response_output = response.output or []
+        else:
+            verbose_proxy_logger.debug(
+                "OpenAI Responses API: No output found in response"
+            )
+            return response
+
+        if not response_output:
+            verbose_proxy_logger.debug(
+                "OpenAI Responses API: Empty output in response"
+            )
+            return response
+
         # Step 1: Extract all text content and tool calls from response output
-        for output_idx, output_item in enumerate(response.output):
+        for output_idx, output_item in enumerate(response_output):
             self._extract_output_text_and_images(
                 output_item=output_item,
                 output_idx=output_idx,
@@ -538,13 +555,18 @@ def _extract_output_text_and_images(
         content: Optional[Union[List[OutputText], List[dict]]] = None
         if isinstance(output_item, BaseModel):
             try:
+                output_item_dump = output_item.model_dump()
                 generic_response_output_item = GenericResponseOutputItem.model_validate(
-                    output_item.model_dump()
+                    output_item_dump
                 )
                 if generic_response_output_item.content:
                     content = generic_response_output_item.content
             except Exception:
-                return
+                # Try to extract content directly from output_item if validation fails
+                if hasattr(output_item, "content") and output_item.content:
+                    content = output_item.content
+                else:
+                    return
         elif isinstance(output_item, dict):
             content = output_item.get("content", [])
         else:
@@ -582,22 +604,53 @@ async def _apply_guardrail_responses_to_output(
 
         Override this method to customize how responses are applied.
         """
+        # Handle both dict and Pydantic object responses
+        if isinstance(response, dict):
+            response_output = response.get("output", [])
+        elif hasattr(response, "output"):
+            response_output = response.output or []
+        else:
+            return
+
         for task_idx, guardrail_response in enumerate(responses):
             mapping = task_mappings[task_idx]
             output_idx = cast(int, mapping[0])
             content_idx = cast(int, mapping[1])
 
-            output_item = response.output[output_idx]
+            if output_idx >= len(response_output):
+                continue
+
+            output_item = response_output[output_idx]
 
-            # Handle both GenericResponseOutputItem and dict
+            # Handle both GenericResponseOutputItem, BaseModel, and dict
             if isinstance(output_item, GenericResponseOutputItem):
-                content_item = output_item.content[content_idx]
-                if isinstance(content_item, OutputText):
-                    content_item.text = guardrail_response
-                elif isinstance(content_item, dict):
-                    content_item["text"] = guardrail_response
+                if output_item.content and content_idx < len(output_item.content):
+                    content_item = output_item.content[content_idx]
+                    if isinstance(content_item, OutputText):
+                        content_item.text = guardrail_response
+                    elif isinstance(content_item, dict):
+                        content_item["text"] = guardrail_response
+            elif isinstance(output_item, BaseModel):
+                # Handle other Pydantic models by converting to GenericResponseOutputItem
+                try:
+                    generic_item = GenericResponseOutputItem.model_validate(
+                        output_item.model_dump()
+                    )
+                    if generic_item.content and content_idx < len(generic_item.content):
+                        content_item = generic_item.content[content_idx]
+                        if isinstance(content_item, OutputText):
+                            content_item.text = guardrail_response
+                            # Update the original response output
+                            if hasattr(output_item, "content") and output_item.content:
+                                original_content = output_item.content[content_idx]
+                                if hasattr(original_content, "text"):
+                                    original_content.text = guardrail_response
+                except Exception:
+                    pass
             elif isinstance(output_item, dict):
                 content = output_item.get("content", [])
                 if content and content_idx < len(content):
                     if isinstance(content[content_idx], dict):
                         content[content_idx]["text"] = guardrail_response
+                    elif hasattr(content[content_idx], "text"):
+                        content[content_idx].text = guardrail_response

litellm/llms/vertex_ai/image_edit/vertex_gemini_transformation.py

@@ -114,19 +114,24 @@ def get_complete_url(
         """
         Get the complete URL for Vertex AI Gemini generateContent API
         """
-        vertex_project = self._resolve_vertex_project()
-        vertex_location = self._resolve_vertex_location()
+        vertex_project = (
+            litellm_params.get("vertex_project") or self._resolve_vertex_project()
+        )
+        vertex_location = (
+            litellm_params.get("vertex_location") or self._resolve_vertex_location()
+        )
 
         if not vertex_project or not vertex_location:
             raise ValueError("vertex_project and vertex_location are required for Vertex AI")
 
-        # Use the model name as provided, handling vertex_ai prefix
         model_name = model
         if model.startswith("vertex_ai/"):
             model_name = model.replace("vertex_ai/", "")
 
         if api_base:
             base_url = api_base.rstrip("/")
+        elif vertex_location == "global":
+            base_url = "https://aiplatform.googleapis.com"
         else:
             base_url = f"https://{vertex_location}-aiplatform.googleapis.com"
 

litellm/proxy/auth/auth_utils.py

@@ -616,6 +616,14 @@ def get_model_from_request(
         if match:
             model = match.group(1)
 
+    # If still not found, extract from Vertex AI passthrough route
+    # Pattern: /vertex_ai/.../models/{model_id}:*
+    # Example: /vertex_ai/v1/.../models/gemini-1.5-pro:generateContent
+    if model is None and "/vertex" in route.lower():
+        vertex_match = re.search(r"/models/([^/:]+)", route)
+        if vertex_match:
+            model = vertex_match.group(1)
+
     return model
 
 

litellm/proxy/guardrails/guardrail_hooks/grayswan/__init__.py

@@ -40,6 +40,12 @@ def initialize_guardrail(
         ),
         categories=_get_config_value(litellm_params, optional_params, "categories"),
         policy_id=_get_config_value(litellm_params, optional_params, "policy_id"),
+        streaming_end_of_stream_only=_get_config_value(
+            litellm_params, optional_params, "streaming_end_of_stream_only"
+        ) or False,
+        streaming_sampling_rate=_get_config_value(
+            litellm_params, optional_params, "streaming_sampling_rate"
+        ) or 5,
         event_hook=litellm_params.mode,
         default_on=litellm_params.default_on,
     )