berriai-litellm-20666-22884

AGENTS.md
ARCHITECTURE.md
CLAUDE.md
CONTRIBUTING.md
Dockerfile
GEMINI.md
LICENSE
Makefile
README.md
ci_cd
codecov.yaml
cookbook

db_scripts
deploy
dist
docker
docker-compose.hardened.yml
docker-compose.yml
docs
enterprise
index.yaml
litellm
litellm-js
litellm-proxy-extras
mcp_servers.json
model_prices_and_context_window.json
package-lock.json
package.json
poetry.lock
prometheus.yml
provider_endpoints_support.json
proxy_server_config.yaml
pyproject.toml
pyrightconfig.json
render.yaml
requirements.txt
ruff.toml
schema.prisma
scripts
security.md
taplo.toml
tests
ui
uv.lock
5f39c83 base
On branch master

It took 2.02 seconds to enumerate untracked files.
See 'git help status' for information on how to improve this.

nothing to commit, working tree clean

litellm/integrations/dotprompt/prompt_manager.py:30:        self.output_format = self.metadata.get("output", {}).get("format")
litellm/llms/aiml/image_generation/transformation.py:56:                        optional_params["output_format"] = non_default_params[k] 
litellm/llms/anthropic/chat/transformation.py:207:        Filter out unsupported fields from JSON schema for Anthropic's output_format API.
litellm/llms/anthropic/chat/transformation.py:209:        Anthropic's output_format doesn't support certain JSON schema properties:
litellm/llms/anthropic/chat/transformation.py:709:    def map_response_format_to_anthropic_output_format(
litellm/llms/anthropic/chat/transformation.py:718:        # Filter out unsupported fields for Anthropic's output_format API
litellm/llms/anthropic/chat/transformation.py:838:                    _output_format = (
litellm/llms/anthropic/chat/transformatio
…[8629 chars omitted]…
t", None)
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:143:        VertexAI doesn't support the output_format parameter, so we force all models
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:147:        # This ensures Claude Sonnet 4.5 uses tools instead of output_format

litellm/proxy/client/cli/commands/credentials.py:21:    "output_format",

"""
This file contains common utils for anthropic calls.
"""

from typing import Dict, List, Optional, Union

import httpx

import litellm
from litellm.litellm_core_utils.prompt_templates.common_utils import (
    get_file_ids_from_messages,
)

from litellm.llms.base_llm.base_utils import BaseLLMModelInfo, BaseTokenCounter
from litellm.llms.base_llm.chat.transformation import BaseLLMException
from litellm.types.llms.anthropic import (
    ANTHROPIC_HOSTED_TOOLS,
    ANTHROPIC_OAUTH_BETA_HEADER,
    ANTHROPIC_OAUTH_TOKEN_PREFIX,
    AllAnthropicToolsValues,
    AnthropicMcpServerTool,
)
from litellm.types.llms.openai import AllMessageValues


def optionally_handle_anthropic_oauth(
    headers: dict, api_key: Optional[str]
) -> tuple[dict, Optional[str]]:
    """
    Handle Anthropic OAuth token detection and header setup.

    If an OAuth token is detected in the Authorization header, e
…[8629 chars omitted]…
 if api_base is None or api_key is None:
            raise ValueError(
                "ANTHROPIC_API_BASE or ANTHROPIC_API_KEY is not set. Please set the environment variable, to query Anthropic's `/models` endpoint."
            )
        response = litellm.module_level_client.get(
            url=f"{api_base}/v1/models",
            headers={"x-api-key": api_key, "anthropic-version": "2023-06-01"},

name="web_search",
        )
        user_location = value_typed.get("user_location")
        if user_location is not None:
            anthropic_user_location = AnthropicWebSearchUserLocation(type="approximate")
            anthropic_user_location_keys = (
                AnthropicWebSearchUserLocation.__annotations__.keys()
            )
            user_location_approximate = user_location.get("approximate")
            if user_location_approximate is not None:
                for key, user_location_value in user_location_approximate.items():
                    if key in anthropic_user_location_keys and key != "type":

                        anthropic_user_location[key] = user_location_value  # type: ignore
                hosted_web_search_tool["user_location"] = anthropic_user_location

        ## MAP SEARCH CONTEXT SIZE
        search_context_size = value_typed.get(
…[8629 chars omitted]…
      tool_calls=tool_calls,
                )
        return _message

    def extract_response_content(self, completion_response: dict) -> Tuple[
        str,
        Optional[List[Any]],
        Optional[
            List[
                Union[ChatCompletionThinkingBlock, ChatCompletionRedactedThinkingBlock]
            ]
        ],
        Optional[str],
        List[ChatCompletionToolCallChunk],

tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1454:def test_effort_output_config_preservation():
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1455:    """Test that output_config with effort is preserved in transformation."""
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1460:        "output_config": {
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1473:    assert "output_config" in result
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1474:    assert result["output_config"]["effort"] == "medium"
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1478:    """Test that effort beta header is automatically added when output_config is detected."""
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transfo
…[803 chars omitted]…
ult["output_config"]["effort"] == "high"
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1578:        "output_config": {
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1597:    assert "output_config" in result
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1598:    assert result["output_config"]["effort"] == "low"

- For all other edits, add context-management-2025-06-27 header
        """
        edits = context_management.get("edits", [])
        
        has_compact = False
        has_other = False
        
        for edit in edits:
            edit_type = edit.get("type", "")
            if edit_type == "compact_20260112":
                has_compact = True
            else:

                has_other = True
        
        # Add compact header if any compact edits exist
        if has_compact:
            self._ensure_beta_header(
                headers, ANTHROPIC_BETA_HEADER_VALUES.COMPACT_2026_01_12.value
            )
        
        # Add context management header if any other edits exist
        if has_other:
            self._ensure_beta_header(
                headers, ANTHROPIC_BETA_HEADER_VALUES.CONTEXT_MANAGEMENT_2025_06_27.value
            )

    def update_headers_w
…[4623 chars omitted]…
om_llm_provider or "anthropic",
            )
        except Exception as e:
            raise AnthropicError(
                status_code=400,
                message="{}\nReceived Messages={}".format(str(e), messages),
            )  # don't use verbose_logger.exception, if exception is raised

        ## Add code_execution tool if container_upload is in messages
        _tools = (
            cast(

messages=[{"role": "user", "content": [{"type": "text", "text": "Hi"}]}],
        optional_params={"context_management": _sample_context_management_payload()},
        litellm_params={},
    )
    assert headers["anthropic-beta"] == "context-management-2025-06-27"


def test_anthropic_messages_transform_includes_context_management():
    config = AnthropicMessagesConfig()
    payload = _sample_context_management_payload()
    headers = {
        "x-api-key": "test",

        "anthropic-version": "2023-06-01",
        "content-type": "application/json",
    }
    result = config.transform_anthropic_messages_request(
        model="claude-sonnet-4-20250514",
        messages=[{"role": "user", "content": [{"type": "text", "text": "Hi"}]}],
        anthropic_messages_optional_request_params={
            "max_tokens": 512,
            "context_management": payload,
        },
     
…[8628 chars omitted]…
t content blocks must be non-empty"
    """
    config = AnthropicConfig()

    # Test empty string content - should not produce any anthropic system message content
    messages = [
        {"role": "system", "content": ""},
        {"role": "user", "content": "Hello"},
    ]

    result = config.translate_system_message(messages)

    # Empty system message should produce no anthropic content blocks

from typing import Any, Dict, List, Optional, Tuple

from litellm.anthropic_beta_headers_manager import (
    update_headers_with_filtered_beta,
)
from litellm.llms.anthropic.common_utils import AnthropicModelInfo
from litellm.llms.anthropic.experimental_pass_through.messages.transformation import (
    AnthropicMessagesConfig,
)
from litellm.types.llms.anthropic import (
    ANTHROPIC_BETA_HEADER_VALUES,
    ANTHROPIC_HOSTED_TOOLS,

)
from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
from litellm.types.llms.vertex_ai import VertexPartnerProvider
from litellm.types.router import GenericLiteLLMParams

from ....vertex_llm_base import VertexBase


class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, VertexBase):
    def validate_anthropic_messages_environment(
        self,
        headers: dict,
        model: str,
        messages: L
…[3656 chars omitted]…
anthropic_version"] = "vertex-2023-10-16"

        anthropic_messages_request.pop(
            "model", None
        )  # do not pass model in request body to vertex ai

        anthropic_messages_request.pop(
            "output_format", None
        )  # do not pass output_format in request body to vertex ai - vertex ai does not support output_format as yet

        return anthropic_messages_request

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:3:from litellm.anthropic_beta_headers_manager import (
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:111:        auto_betas = self.get_anthropic_beta_list(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:130:            data["anthropic_beta"] = list(beta_set)
litellm/llms/bedrock/chat/converse_transformation.py:14:from litellm.anthropic_beta_headers_manager import (
litellm/llms/bedrock/chat/converse_transformation.py:70:    get_anthropic_beta_from_headers,
litellm/llms/bedrock/chat/converse_transformation.py:1059:        """Process tools and collect anthropic_beta values."""
litellm/llms/bedrock/chat/converse_transformation.py:1062:        # Collect anthropic_beta values from user headers
litellm/llms/bedrock/chat/converse_tra
…[3708 chars omitted]…
ation.py:465:        beta_set = set(get_anthropic_beta_from_headers(headers))
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:466:        auto_betas = anthropic_model_info.get_anthropic_beta_list(
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:493:            anthropic_messages_request["anthropic_beta"] = list(beta_set)

bash: line 44: curl: command not found
rc=127

URLError <urlopen error [Errno -3] Temporary failure in name resolution>

import json
import re
import time
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast

import httpx

import litellm
from litellm.constants import (
    ANTHROPIC_WEB_SEARCH_TOOL_MAX_USES,
    DEFAULT_ANTHROPIC_CHAT_MAX_TOKENS,
    DEFAULT_REASONING_EFFORT_HIGH_THINKING_BUDGET,

    DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET,
    DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET,
    DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET,
    RESPONSE_FORMAT_TOOL_NAME,
)
from litellm.litellm_core_utils.core_helpers import map_finish_reason
from litellm.llms.base_llm.base_utils import type_to_response_format_param
from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
from litellm.types.llms.anthropic import (
    ANTHROPIC_BETA_HEADER_VALUES,
    ANTHROPIC_HOSTED_TOOLS,
    AllAnthropicMessageValues,
    AllAnthropicToolsValues,
    Anth
…[8629 chars omitted]…
 context_management: dict
    ) -> None:
        """
        Add appropriate beta headers based on context_management edits.
        - If any edit has type "compact_20260112", add compact-2026-01-12 header
        - For all other edits, add context-management-2025-06-27 header
        """
        edits = context_management.get("edits", [])
        
        has_compact = False
        has_other = False

litellm/llms/anthropic/chat/transformation.py:178:    def get_supported_openai_params(self, model: str):
litellm/llms/anthropic/chat/transformation.py:709:    def map_response_format_to_anthropic_output_format(
litellm/llms/anthropic/chat/transformation.py:726:    def map_response_format_to_anthropic_tool(
litellm/llms/anthropic/chat/transformation.py:1073:        is_vertex_request = optional_params.get("is_vertex_request", False)
litellm/llms/anthropic/chat/transformation.py:1074:        if is_vertex_request:
litellm/llms/anthropic/chat/transformation.py:1210:        optional_params.pop("is_vertex_request", None)
litellm/llms/anthropic/common_utils.py:194:    def is_effort_used(self, optional_params: Optional[dict], model: Optional[str] = None) -> bool:
litellm/llms/anthropic/common_utils.py:318:    def get_anthropic_headers(
litellm/llms/anthropic/common_utils.py:332:        is_vertex_request: bool = False,
litellm/llms/anthropic/common_utils.py:380:        if is_vertex_request is True:
litellm/llms/anthropic/common_utils.py:390:    def validate_environment(
litellm/llms/anthropic/common_utils.py:434:            is_vertex_request=optional_params.get("is_vertex_request", False),

def is_input_examples_used(self, tools: Optional[List]) -> bool:
        """
        Check if input_examples is being used in any tools.
        
        Returns True if any tool has input_examples field.
        """
        if not tools:
            return False
        
        for tool in tools:
            # Check top-level input_examples
            input_examples = tool.get("input_examples", None)

            if input_examples and isinstance(input_examples, list) and len(input_examples) > 0:
                return True
            
            # Check function.input_examples for OpenAI format tools
            function = tool.get("function", {})
            if isinstance(function, dict):
                function_input_examples = function.get("input_examples", None)
                if function_input_examples and isinstance(function_input_examples, list) and len(function_input
…[8433 chars omitted]…

        if search_context_size is not None:
            hosted_web_search_tool["max_uses"] = ANTHROPIC_WEB_SEARCH_TOOL_MAX_USES[
                search_context_size
            ]

        return hosted_web_search_tool

    def map_openai_params(  # noqa: PLR0915
        self,
        non_default_params: dict,
        optional_params: dict,
        model: str,
        drop_params: bool,
    ) -> dict:

litellm/llms/anthropic/chat/handler.py:319:        is_vertex_request: bool = optional_params.pop("is_vertex_request", False)
litellm/llms/anthropic/chat/handler.py:328:            optional_params={**optional_params, "is_vertex_request": is_vertex_request},
litellm/llms/anthropic/chat/handler.py:344:            optional_params={**optional_params, "is_vertex_request": is_vertex_request},
litellm/llms/anthropic/chat/transformation.py:1073:        is_vertex_request = optional_params.get("is_vertex_request", False)
litellm/llms/anthropic/chat/transformation.py:1074:        if is_vertex_request:
litellm/llms/anthropic/chat/transformation.py:1210:        optional_params.pop("is_vertex_request", None)
litellm/llms/anthropic/common_utils.py:332:        is_vertex_request: bool = False,
litellm/llms/anthropic/common_utils.py:380:        if is_vertex_request is True:
litellm/llms/anthropic/common
…[194 chars omitted]…
is_vertex_request", False)
litellm/llms/azure_ai/anthropic/handler.py:73:            optional_params={**optional_params, "is_vertex_request": is_vertex_request},

litellm/llms/azure_ai/anthropic/transformation.py:82:            is_vertex_request=optional_params.get("is_vertex_request", False),
litellm/llms/vertex_ai/vertex_ai_partner_models/main.py:206:                        "is_vertex_request": True,

optional_params["stream"] = stream

            if self.should_use_openai_handler(model):
                partner = VertexPartnerProvider.llama
            elif "mistral" in model or "codestral" in model:
                partner = VertexPartnerProvider.mistralai
            elif "jamba" in model:
                partner = VertexPartnerProvider.ai21
            elif "claude" in model:
                partner = VertexPartnerProvider.claude
            else:
                raise ValueError(f"Unknown partner model: {model}")

            api_base = self.get_complete_vertex_url(
                custom_api_base=api_base,
                vertex_location=vertex_location,
                vertex_project=vertex_project,
                project_id=project_id,
                partner=partner,
                stream=stream,
                model=model,
            )

            if "c
…[6211 chars omitted]…
on call - fake the streaming (need complete blocks for output parsing in openai format)
                print_verbose("makes async anthropic streaming POST request")
                data["stream"] = stream
                return self.acompletion_stream_function(
                    model=model,
                    messages=messages,
                    data=data,
                    api_base=api_base,

Refused: `find /` walks the whole container FS. Scope under /repo.

litellm/litellm_core_utils/get_supported_openai_params.py:193:                return litellm.VertexAIAnthropicConfig().get_supported_openai_params(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:21:class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, VertexBase):
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:28:class VertexAIAnthropicConfig(AnthropicConfig):
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:37:    The class `VertexAIAnthropicConfig` provides configuration for the VertexAI's Anthropic API interface. Below are the parameters:
litellm/llms/vertex_ai/vertex_ai_partner_models/__init__.py:9:        from .anthropic.transformation import VertexAIAnthropicConfig
litellm/llms/vertex_ai/vertex_ai_partner_models/__init__.py:11:        return Vertex
…[425 chars omitted]…
erModelsAnthropicMessagesConfig()
litellm/_lazy_imports_registry.py:176:    "VertexAIAnthropicConfig",
litellm/_lazy_imports_registry.py:712:    "VertexAIAnthropicConfig": (
litellm/_lazy_imports_registry.py:714:        "VertexAIAnthropicConfig",
litellm/__init__.py:1348:    from .llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation import VertexAIAnthropicConfig as VertexAIAnthropicConfig

from enum import Enum
from typing import Any, Dict, Iterable, List, Optional, Union

from pydantic import BaseModel, ConfigDict
from typing_extensions import Literal, Required, TypedDict

from .openai import (
    ChatCompletionCachedContent,
    ChatCompletionRedactedThinkingBlock,
    ChatCompletionThinkingBlock,
)

class AnthropicMessagesToolChoice(TypedDict, total=False):
    type: Required[Literal["auto", "any", "tool", "none"]]
    name: str
    disable_parallel_tool_use: bool  # default is false


AnthropicInputSchema = TypedDict(
    "AnthropicInputSchema",
    {
        "type": Optional[str],
        "properties": Optional[dict],
        "additionalProperties": Optional[bool],
        "required": Optional[List[str]],
        "$defs": Optional[Dict],
        "strict": Optional[bool],
    },
    total=False,
)


class AnthropicOutputSchema(TypedDict, total=False):
    type: Re
…[7044 chars omitted]…
ream,
                model=model,
            )

            if "codestral" in model or "mistral" in model:
                model = model.split("@")[0]

            if "codestral" in model and litellm_params.get("text_completion") is True:
                optional_params["model"] = model
                text_completion_model_response = litellm.TextCompletionResponse(
                    stream=stream

litellm/litellm_core_utils/get_provider_specific_headers.py:27:            return provider_specific_header.get("extra_headers", {})
litellm/litellm_core_utils/litellm_logging.py:4900:        extra_headers: List[str] = (
litellm/litellm_core_utils/litellm_logging.py:4903:        if not extra_headers:
litellm/litellm_core_utils/litellm_logging.py:4911:        for header_name in extra_headers:
litellm/utils.py:3836:    extra_headers=None,
litellm/main.py:413:    extra_headers: Optional[dict] = None,
litellm/main.py:558:        "extra_headers": extra_headers,
litellm/main.py:1033:    extra_headers: Optional[dict] = None,
litellm/main.py:1081:        extra_headers (dict, optional): Additional headers to include in the request.
litellm/main.py:1164:                extra_headers=extra_headers,
litellm/main.py:1187:    headers = kwargs.get("headers", None) or extra_headers
litellm/main.py:120

…[2808 chars omitted]…
extra_headers:
litellm/main.py:6715:                optional_params["extra_headers"] = extra_headers
litellm/main.py:6782:            extra_headers=extra_headers,
litellm/main.py:6834:            extra_headers=headers,
litellm/main.py:6882:            extra_headers=extra_headers,
litellm/main.py:6923:            extra_headers=extra_headers,
litellm/main.py:6949:            extra_headers=extra_headers,

from typing import Any, AsyncIterator, Dict, List, Optional, Tuple

import httpx

from litellm.anthropic_beta_headers_manager import (
    update_headers_with_filtered_beta,
)
from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
from litellm.litellm_core_utils.litellm_logging import verbose_logger
from litellm.llms.base_llm.anthropic_messages.transformation import (
    BaseAnthropicMessagesConfig,
)

from litellm.types.llms.anthropic import (
    ANTHROPIC_BETA_HEADER_VALUES,
    AnthropicMessagesRequest,
)
from litellm.types.llms.anthropic_messages.anthropic_response import (
    AnthropicMessagesResponse,
)
from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
from litellm.types.router import GenericLiteLLMParams

from ...common_utils import (
    AnthropicError,
    AnthropicModelInfo,
    optionally_handle_anthropic_oauth,

…[7324 chars omitted]…
o = AnthropicModelInfo()
            if anthropic_model_info.is_tool_search_used(tools):
                # Use provider-specific tool search header
                tool_search_header = get_tool_search_beta_header(custom_llm_provider)
                beta_values.add(tool_search_header)

        if beta_values:
            headers["anthropic-beta"] = ",".join(sorted(beta_values))

        return headers

347:class AnthropicMessagesRequestOptionalParams(TypedDict, total=False):
348-    max_tokens: Optional[int]
349-    metadata: Optional[Union[AnthropicMetadata, Dict]]
350-    stop_sequences: Optional[List[str]]
351-    stream: Optional[bool]
352-    system: Optional[Union[str, List]]
353-    temperature: Optional[float]
354-    thinking: Optional[Dict]
355-    tool_choice: Optional[Union[AnthropicMessagesToolChoice, Dict]]
356-    tools: Optional[List[Union[AllAnthropicToolsValues, Dict]]]
357-    top_k: Optional[int]
358-    top_p: Optional[float]

359-    mcp_servers: Optional[List[AnthropicMcpServerTool]]
360-    context_management: Optional[Dict[str, Any]]
361-    container: Optional[Dict[str, Any]]  # Container config with skills for code execution
362-    output_format: Optional[AnthropicOutputSchema]  # Structured outputs support
363-
364-
365:class AnthropicMessagesRequest(Anth
…[1463 chars omitted]…
ckDelta,
418-        ContentJsonBlockDelta,
419-        ContentCitationsBlockDelta,
420-        ContentThinkingBlockDelta,
421-        ContentThinkingSignatureBlockDelta,
422-    ]
423-
424-
425-class ContentBlockStop(TypedDict):
316:    anthropic_messages_optional_request_params = (
325:        anthropic_messages_optional_request_params=dict(
326:            anthropic_messages_optional_request_params

tests/pass_through_unit_tests/test_vertex_ai_anthropic_streaming_cost_injection.py
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_anthropic_image_url_handling.py
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py
tests/unified_google_tests/test_vertex_anthropic.py
tests/test_litellm/llms/vertex_ai/test_vertex_image_generation.py:71:            "output_format": "png",
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py:6:    VertexAIPartnerModelsAnthropicMessagesConfig,
tests/test_litellm/llms/vertex_ai/ver
…[2903 chars omitted]…
st_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:291:        assert "output_format" not in final_data, "output_format should be removed for VertexAI"
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:343:        VertexAIPartnerModelsAnthropicMessagesConfig,

import asyncio
import json
import sys
import os
from typing import Any, AsyncIterator, Dict, List, Optional, Union
import pytest
from unittest.mock import MagicMock, AsyncMock, patch
import httpx

sys.path.insert(
    0, os.path.abspath("../../..")
)  # Adds the parent directory to the system path

import litellm
from litellm.google_genai import (
    agenerate_content,
    agenerate_content_stream
)
from google.genai.types import ContentDict, PartDict, GenerateContentResponse
from litellm.integrations.custom_logger import CustomLogger
from litellm.types.utils import StandardLoggingPayload


async def vertex_anthropic_mock_response(*args, **kwargs):
    """Mock response for vertex AI anthropic call"""
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.headers = {"Content-Type": "application/json"}
    mock_response.json.return_value = {
        "id":
…[8394 chars omitted]…
   )
        
        # Verify the call was made
        assert mock_post.call_count == 1
        
        # Get the call arguments
        call_args = mock_post.call_args
        call_kwargs = call_args.kwargs if call_args else {}
        
        # Extract URL (could be in args[0] or kwargs['url'])
        if call_args and len(call_args[0]) > 0:
            actual_url = call_args[0][0]
        else:

./docs/my-website/blog/anthropic_opus_4_5_and_advanced_features/index.md:979:LiteLLM automatically maps `reasoning_effort` to Anthropic's `output_config` format and adds the required `effort-2025-11-24` beta header for Claude Opus 4.5.
./docs/my-website/blog/claude_opus_4_6/index.md:373:Four effort levels available: `low`, `medium`, `high` (default), and `max`. Pass directly via the `output_config` parameter:
./docs/my-website/blog/claude_opus_4_6/index.md:387:  "output_config": {
./docs/my-website/blog/claude_opus_4_6/index.md:394:You can use reasoning effort plus output_config to have more control on the model.
./docs/my-website/docs/providers/anthropic.md:53:- `reasoning_effort` is automatically mapped to `output_config={"effort": ...}` for Claude Opus 4.5 models (see [Effort Parameter](./anthropic_effort.md))
./docs/my-website/docs/providers/anthropic_effort.md:58:    reasoning_ef
…[4923 chars omitted]…
utput_config"]["effort"] == "high"
./tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1578:        "output_config": {
./tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1597:    assert "output_config" in result
./tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1598:    assert result["output_config"]["effort"] == "low"

print(response.choices[0].message.content)
```

</TabItem>
<TabItem value="typescript" label="TypeScript">

```typescript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

const response = await client.messages.create({
  model: "claude-opus-4-5-20251101",
  max_tokens: 4096,
  messages: [{
    role: "user",
    content: "Analyze the trade-offs between microservices and monolithic architectures"
  }],
  output_config: {
    effort: "medium"
  }
});

console.log(response.content[0].text);
```

</TabItem>
</Tabs>

### Using LiteLLM Proxy

```bash
curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $LITELLM_API_KEY" \
  -d '{
    "model": "anthropic/claude-opus-4-5-20251101",
    "messages": [{
      "role": "user",
      "content": "Analyze the trade-o
…[2141 chars omitted]…

You can use reasoning effort plus output_config to have more control on the model.

## 1M Token Context (Beta)

Opus 4.6 supports 1M token context. Premium pricing applies for prompts exceeding 200k tokens ($10/$37.50 per million input/output tokens). LiteLLM supports cost calculations for 1M token contexts.

## US-Only Inference

Available at 1.1× token pricing. LiteLLM supports this pricing model.

==================================== ERRORS ====================================
_ ERROR collecting tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py _
ImportError while importing test module '/repo/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/local/lib/python3.12/importlib/__init__.py:90: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:6: in <module>
    from fastapi.testclient import TestClient
E   ModuleNotFoundError: No module named 'fastapi'
=========================== short test summary info ============================

ERROR tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!

............                                                             [100%]
12 passed, 2 warnings in 1.70s

5f39c83 refs/heads/master@{0}: commit (initial): base
5f39c83 HEAD@{0}: commit (initial): base
5f39c83 (HEAD -> master) base

http-v2
selfcheck

api_base = kwargs.get("api_base", None)
    mock_response: Optional[MOCK_RESPONSE_TYPE] = kwargs.get("mock_response", None)
    mock_tool_calls = kwargs.get("mock_tool_calls", None)
    mock_timeout = cast(Optional[bool], kwargs.get("mock_timeout", None))
    force_timeout = kwargs.get("force_timeout", 600)  ## deprecated
    logger_fn = kwargs.get("logger_fn", None)
    verbose = kwargs.get("verbose", False)
    custom_llm_provider = kwargs.get("custom_llm_provider", None)
    litellm_logging_obj = kwargs.get("litellm_logging_obj", None)
    id = kwargs.get("id", None)
    metadata = kwargs.get("metadata", None)
    model_info = kwargs.get("model_info", None)

    proxy_server_request = kwargs.get("proxy_server_request", None)
    fallbacks = kwargs.get("fallbacks", None)
    provider_specific_header = cast(
        Optional[ProviderSpecificHeader], kwargs.get("provider_specific_h
…[1535 chars omitted]…
al extra_headers
4809:                optional_params["extra_headers"] = headers
4901:                optional_params["extra_headers"] = headers
5058:                extra_headers=headers,
5101:                extra_headers=headers,
6372:        optional_params["extra_headers"] = extra_headers
6715:                optional_params["extra_headers"] = extra_headers
6834:            extra_headers=headers,

227:from .llms.vertex_ai.vertex_ai_partner_models.main import VertexAIPartnerModels
224:                    headers=headers,
241:                    headers=headers,

litellm/main.py:227:from .llms.vertex_ai.vertex_ai_partner_models.main import VertexAIPartnerModels
litellm/main.py:284:vertex_partner_models_chat_completion = VertexAIPartnerModels()
litellm/llms/vertex_ai/common_utils.py:72:    from litellm.llms.vertex_ai.vertex_ai_partner_models.main import (
litellm/llms/vertex_ai/common_utils.py:73:        VertexAIPartnerModels,
litellm/llms/vertex_ai/common_utils.py:91:    if VertexAIPartnerModels.is_vertex_partner_model(model=model):
litellm/llms/vertex_ai/common_utils.py:1017:        from litellm.llms.vertex_ai.vertex_ai_partner_models.main import (
litellm/llms/vertex_ai/common_utils.py:1018:            VertexAIPartnerModels,
litellm/llms/vertex_ai/common_utils.py:1027:        if VertexAIPartnerModels.is_vertex_partner_model(model_to_use):
litellm/llms/vertex_ai/common_utils.py:1029:            partner_models_handler = VertexAIPartnerModels()

litellm/llms/anthropic/experimental_pass_through/messages/transformation.py:67:    def validate_anthropic_messages_environment(
litellm/llms/anthropic/experimental_pass_through/messages/transformation.py:103:    def transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:22:    def validate_anthropic_messages_environment(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:108:    def transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:116:        anthropic_messages_request = super().transform_anthropic_messages_request(

litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:416:        anthropic_messages_request = AnthropicMessagesConfig.transform_anthropic_messages_request(
litellm/llms/custom_httpx/llm_http_handler.py:1870:        request_body = anthropic_messages_provider_config.transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:116:        anthropic_messages_request = super().transform_anthropic_messages_request(

kwargs = kwargs or {}
        provider_specific_header = cast(
            Optional[litellm.types.utils.ProviderSpecificHeader],
            kwargs.get("provider_specific_header", None),
        )
        provider_specific_headers = ProviderSpecificHeaderUtils.get_provider_specific_headers(
            provider_specific_header=provider_specific_header,
            custom_llm_provider=custom_llm_provider,
        )
        forwarded_headers = kwargs.get("headers", None)
        # Also check for extra_headers in kwargs (from config or direct calls)
        extra_headers_from_kwargs = kwargs.get("extra_headers", None)

        # Merge all header sources: forwarded < extra_headers < provider_specific
        merged_headers = {}
        if forwarded_headers:
            merged_headers.update(forwarded_headers)
        if extra_headers_from_kwargs:
            merged_headers.update(e
…[3729 chars omitted]…
rovider_config=anthropic_messages_provider_config
            )

        # used for logging + cost tracking
        logging_obj.model_call_details["httpx_response"] = response

        initial_response: Union[AsyncIterator, AnthropicMessagesResponse]
        if stream:
            completion_stream = anthropic_messages_provider_config.get_async_streaming_response_iterator(
                model=model,

"""
Centralized manager for Anthropic beta headers across different providers.

This module provides utilities to:
1. Load beta header configuration from JSON (lists unsupported headers per provider)
2. Filter out unsupported beta headers
3. Handle provider-specific header name mappings (e.g., advanced-tool-use -> tool-search-tool)

Design:
- JSON config lists UNSUPPORTED headers for each provider
- Headers not in the unsupported list are passed through
- Header mappings allow renaming headers for specific providers

"""

import json
import os
from typing import Dict, List, Optional, Set

from litellm.litellm_core_utils.litellm_logging import verbose_logger

# Cache for the loaded configuration
_BETA_HEADERS_CONFIG: Optional[Dict] = None


def _load_beta_headers_config() -> Dict:
    """
    Load the beta headers configuration from JSON file.
    Uses caching to avoid repeated file rea
…[7070 chars omitted]…
deError:
                pass  # Fall through to comma-separated parsing

        # Fall back to comma-separated values
        return [beta.strip() for beta in anthropic_beta_header.split(",")]

    return []


class CommonBatchFilesUtils:
    """
    Common utilities for Bedrock batch and file operations.
    Provides shared functionality to reduce code duplication between batches and files.
    """

{
  "description": "Unsupported Anthropic beta headers for each provider. Headers listed here will be dropped. Headers not listed are passed through as-is.",
  "anthropic": [],
  "azure_ai": [],
  "bedrock_converse": [
    "prompt-caching-scope-2026-01-05",
    "bash_20250124",
    "bash_20241022",
    "text_editor_20250124",
    "text_editor_20241022",
    "compact-2026-01-12",
    "advanced-tool-use-2025-11-20",

    "web-fetch-2025-09-10",
    "code-execution-2025-08-25",
    "skills-2025-10-02",
    "files-api-2025-04-14"
  ],
  "bedrock": [
    "advanced-tool-use-2025-11-20",
    "prompt-caching-scope-2026-01-05",
    "structured-outputs-2025-11-13",
    "web-fetch-2025-09-10",
    "code-execution-2025-08-25",
    "skills-2025-10-02",
    "files-api-2025-04-14"
  ],
  "vertex_ai": [
    "prompt-caching-scope-2026-01-05"
  ]
}

tests/llm_translation/test_anthropic_completion.py:393:def test_anthropic_beta_header(
tests/llm_translation/test_bedrock_anthropic_regression.py:239:        if "anthropic_beta" in result:
tests/llm_translation/test_bedrock_anthropic_regression.py:240:            assert "prompt-caching-2024-07-31" not in result["anthropic_beta"], (
tests/llm_translation/test_bedrock_anthropic_regression.py:248:            if "anthropic_beta" in additional_fields:
tests/llm_translation/test_bedrock_anthropic_regression.py:249:                assert "prompt-caching-2024-07-31" not in additional_fields["anthropic_beta"]
tests/llm_translation/test_bedrock_anthropic_regression.py:304:            assert "anthropic_beta" in additional_fields, (
tests/llm_translation/test_bedrock_anthropic_regression.py:305:                f"{model_prefix}: anthropic_beta should be in additionalModelRequestFields"
tests/llm_t
…[8629 chars omitted]…
 Converse API transformation includes anthropic_beta in additionalModelRequestFields."""
tests/test_litellm/llms/bedrock/test_anthropic_beta_support.py:82:        assert "anthropic_beta" in additional_fields
tests/test_litellm/llms/bedrock/test_anthropic_beta_support.py:84:        assert sorted(additional_fields["anthropic_beta"]) == sorted(["context-1m-2025-08-07", "interleaved-thinking-2025-05-14"])

"""
Test anthropic_beta header support for AWS Bedrock.

Tests that anthropic-beta headers are correctly processed and passed to AWS Bedrock
for enabling beta features like 1M context window, computer use tools, etc.
"""

import json
from unittest.mock import MagicMock, patch

import pytest

from litellm.llms.bedrock.chat.converse_transformation import AmazonConverseConfig
from litellm.llms.bedrock.chat.invoke_transformations.anthropic_claude3_transformation import (
    AmazonAnthropicClaudeConfig,
)
from litellm.llms.bedrock.common_utils import get_anthropic_beta_from_headers
from litellm.llms.bedrock.messages.invoke_transformations.anthropic_claude3_transformation import (
    AmazonAnthropicClaudeMessagesConfig,
)


class TestAnthropicBetaHeaderSupport:
    """Test anthropic_beta header functionality across Bedrock APIs."""

    def test_get_anthropic_beta_from_headers_empty(self)
…[8630 chars omitted]…
   headers=headers
        )

        beta_headers = result.get("anthropic_beta", [])

        # advanced-tool-use should be removed
        assert "advanced-tool-use-2025-11-20" not in beta_headers

        # Bedrock-specific headers should NOT be added for unsupported models
        assert "tool-search-tool-2025-10-19" not in beta_headers
        assert "tool-examples-2025-10-29" not in beta_headers

for k, v in optional_params.items()
            if k not in self.aws_authentication_params
        }
        filtered_params = self._normalize_bedrock_tool_search_tools(filtered_params)
        
        _anthropic_request = AnthropicConfig.transform_request(
            self,
            model=model,
            messages=messages,
            optional_params=filtered_params, 
            litellm_params=litellm_params,
            headers=headers,

        )

        _anthropic_request.pop("model", None)
        _anthropic_request.pop("stream", None)
        # Bedrock Invoke doesn't support output_format parameter
        _anthropic_request.pop("output_format", None)
        if "anthropic_version" not in _anthropic_request:
            _anthropic_request["anthropic_version"] = self.anthropic_version

        tools = optional_params.get("tools")
        tool_search_used = sel
…[5886 chars omitted]…
 litellm_logging_obj: LiteLLMLoggingObj,
    ) -> AsyncIterator:
        aws_decoder = AmazonAnthropicClaudeMessagesStreamDecoder(
            model=model,
        )
        completion_stream = aws_decoder.aiter_bytes(
            httpx_response.aiter_bytes(chunk_size=aws_decoder.DEFAULT_CHUNK_SIZE)
        )
        # Convert decoded Bedrock events to Server-Sent Events expected by Anthropic clients.

docs/my-website/docs/providers/anthropic.md:52:- `response_format` is fully supported for Claude Sonnet 4.5 and Opus 4.1 models (see [Structured Outputs](#structured-outputs) section)
docs/my-website/docs/providers/anthropic.md:59:LiteLLM supports Anthropic's [structured outputs feature](https://platform.claude.com/docs/en/build-with-claude/structured-outputs) for Claude Sonnet 4.5 and Opus 4.1 models. When you use `response_format` with these models, LiteLLM automatically:
docs/my-website/docs/providers/anthropic.md:60:- Adds the required `structured-outputs-2025-11-13` beta header
docs/my-website/docs/providers/anthropic.md:61:- Transforms OpenAI's `response_format` to Anthropic's `output_format` format
docs/my-website/docs/providers/anthropic.md:152:When using structured outputs with supported models, LiteLLM automatically:
docs/my-website/docs/providers/anthropic.md:154:- Adds the `anthropic-beta: structured-outputs-2025-11-13` header

Provider List: https://docs.litellm.ai/docs/providers

beta 'user-beta' => body None header user-beta

Provider List: https://docs.litellm.ai/docs/providers

beta 'user-beta,other-beta' => body None header user-beta,other-beta

Provider List: https://docs.litellm.ai/docs/providers

beta ' user-beta , other-beta ' => body None header  user-beta , other-beta 

Provider List: https://docs.litellm.ai/docs/providers

auto+user ['effort-2025-11-24'] output_config in body True
mapped keys dict_keys(['tool_choice', 'tools', 'json_mode', 'max_tokens'])

Provider List: https://docs.litellm.ai/docs/providers

structured body keys dict_keys(['messages', 'tool_choice', 'tools', 'json_mode', 'max_tokens'])
anthropic_beta None
tools [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'a': {'type': 'string'}}}}]

'user-beta' {'messages': [{'role': 'user', 'content': 'hi'}], 'max_tokens': 10, 'output_config': {'effort': 'high'}, 'tools': [{'type': 'web_search_20250305', 'name': 'web_search'}], 'anthropic_version': 'vertex-2023-10-16'} header {'anthropic-beta': 'user-beta'}
'user-beta,other-beta' {'messages': [{'role': 'user', 'content': 'hi'}], 'max_tokens': 10, 'output_config': {'effort': 'high'}, 'tools': [{'type': 'web_search_20250305', 'name': 'web_search'}], 'anthropic_version': 'vertex-2023-10-16'} header {'anthropic-beta': 'user-beta,other-beta'}

"""
Tests for structured outputs support in Anthropic /v1/messages endpoint.
"""
import pytest
from litellm.llms.anthropic.experimental_pass_through.messages.transformation import (
    AnthropicMessagesConfig,
)


def test_output_format_supported_and_transforms_correctly():
    """Test that output_format is supported and properly transformed with beta header."""
    config = AnthropicMessagesConfig()

    # 1. Verify it's in supported parameters
    supported_params = config.get_supported_anthropic_messages_params("claude-sonnet-4-5")
    assert "output_format" in supported_params

    # 2. Verify transformation preserves output_format and adds beta header
    output_format = {
        "type": "json_schema",
        "schema": {"type": "object", "properties": {"result": {"type": "string"}}}
    }

    optional_params = {"max_tokens": 1024, "output_format": output_format}
    headers =
…[2045 chars omitted]…

tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_messages_structured_outputs.py
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_content_after_stop_reason.py
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_parallel_tool_calls.py
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_sse_wrapper.py

validated headers {'anthropic-beta': 'web-search-2025-03-05', 'anthropic-version': '2023-06-01', 'x-api-key': 'k', 'accept': 'application/json', 'content-type': 'application/json'}
body beta None final headers {'anthropic-beta': 'web-search-2025-03-05', 'anthropic-version': '2023-06-01', 'x-api-key': 'k', 'accept': 'application/json', 'content-type': 'application/json'}

total 0
-rw-r--r-- 1 root root 64 Nov  5 07:16 litellm-1.79.1.tar.gz
bash: line 179: file: command not found

commit 5f39c8352e0d612442094bfb17b2e132a0262989
Author:     benchgen <sandbox@benchgen>
AuthorDate: Thu Nov 5 07:34:01 2026 +0000
Commit:     benchgen <sandbox@benchgen>
CommitDate: Thu Nov 5 07:34:01 2026 +0000

    base
count: 0
size: 0
in-pack: 7836
packs: 1
size-pack: 278084

prune-packable: 0
garbage: 0
size-garbage: 0

961:    if custom_llm_provider == "anthropic":
2734:        elif custom_llm_provider == "anthropic":
        elif custom_llm_provider == "cohere_chat" or custom_llm_provider == "cohere":
            cohere_key = (
                api_key
                or litellm.cohere_key
                or get_secret_str("COHERE_API_KEY")
                or get_secret_str("CO_API_KEY")
                or litellm.api_key
            )

            cohere_route = CohereModelInfo.get_cohere_route(model)

            verbose_logger.debug(f"Cohere route: {cohere_route}")
            # Set API base based on route
            if cohere_route == "v2":
                api_base = (
                    api_base
                    or litellm.api_base
                    or get_secret_str("COHERE_API_BASE")
                    or "https://api.cohere.com/v2/chat"
                )
                # Remove v2/ p
…[1290 chars omitted]…
ng=_get_encoding(),
                api_key=cohere_key,
                provider_config=provider_config,
                logging_obj=logging,  # model call logging done inside the class as we make need to modify I/O to fit aleph alpha's requirements
            )
        elif custom_llm_provider == "maritalk":
            maritalk_key = (
                api_key
                or litellm.maritalk_key

or get_secret("ANTHROPIC_BASE_URL")
                or "https://api.anthropic.com/v1/complete"
            )

            # Check if we should disable automatic URL suffix appending
            disable_url_suffix = get_secret_bool("LITELLM_ANTHROPIC_DISABLE_URL_SUFFIX")
            if (
                api_base is not None
                and not disable_url_suffix
                and not api_base.endswith("/v1/complete")
            ):
                api_base += "/v1/complete"

            elif disable_url_suffix:
                verbose_logger.debug(
                    "LITELLM_ANTHROPIC_DISABLE_URL_SUFFIX is set, skipping /v1/complete suffix"
                )

            response = base_llm_http_handler.completion(
                model=model,
                stream=stream,
                messages=messages,
                acompletion=acompletion,
              
…[3457 chars omitted]…
 isinstance(function, dict):
        function = function.copy()
        function.pop("input_examples", None)
        tool_copy["function"] = function
    return tool_copy


def _drop_input_examples_from_tools(
    tools: Optional[List[dict]],
) -> Optional[List[dict]]:
    if tools is None:
        return None
    cleaned_tools: List[dict] = []
    for tool in tools:
        if isinstance(tool, dict):

logger_fn=logger_fn,
                encoding=_get_encoding(),  # for calculating input/output tokens
                api_key=api_key,
                logging_obj=logging,
                headers=headers,
                timeout=timeout,
                client=client,
                custom_llm_provider=custom_llm_provider,
            )
            if optional_params.get("stream", False) or acompletion is True:
                ## LOGGING
                logging.post_call(

                    input=messages,
                    api_key=api_key,
                    original_response=response,
                )
            response = response
        elif custom_llm_provider == "nlp_cloud":
            nlp_cloud_key = (
                api_key
                or litellm.nlp_cloud_key
                or get_secret("NLP_CLOUD_API_KEY")
                or litellm.api_key
  
…[188 chars omitted]…
oud.io/v1/gpu/"
            )

            response = nlp_cloud_chat_completion(
                model=model,
                messages=messages,
                api_base=api_base,
                model_response=model_response,
                print_verbose=print_verbose,
                optional_params=optional_params,
                litellm_params=litellm_params,
                logger_fn=logger_fn,

api_base=api_base,
                model_response=model_response,
                optional_params=optional_params,
                litellm_params=litellm_params,
                shared_session=shared_session,
                custom_llm_provider="vercel_ai_gateway",
                timeout=timeout,
                headers=headers,
                encoding=_get_encoding(),
                api_key=api_key,
                logging_obj=logging,  # model call logging done inside the class as we make need to modify I/O to fit aleph alpha's requirements
                client=client,

            )
            ## LOGGING
            logging.post_call(
                input=messages, api_key=openai.api_key, original_response=response
            )
        elif (
            custom_llm_provider == "together_ai"
            or ("togethercomputer" in model)
            or (model in
…[3321 chars omitted]…
x_credentials", None)
                or optional_params.pop("vertex_ai_credentials", None)
                or get_secret("VERTEXAI_CREDENTIALS")
            )

            api_base = api_base or litellm.api_base or get_secret("VERTEXAI_API_BASE")

284:vertex_partner_models_chat_completion = VertexAIPartnerModels()
3387:                model_response = vertex_partner_models_chat_completion.completion(

new_params = safe_deep_copy(optional_params or {})
            model_route = get_vertex_ai_model_route(
                model=model, litellm_params=litellm_params
            )

            if model_route == VertexAIModelRoute.PARTNER_MODELS:
                model_response = vertex_partner_models_chat_completion.completion(
                    model=model,
                    messages=messages,
                    model_response=model_response,
                    print_verbose=print_verbose,
                    optional_params=new_params,

                    litellm_params=litellm_params,  # type: ignore
                    logger_fn=logger_fn,
                    encoding=_get_encoding(),
                    api_base=api_base,
                    vertex_location=vertex_ai_location,
                    vertex_project=vertex_ai_project,
                    vertex_credenti
…[2009 chars omitted]…
vertex_ai_location,
                    vertex_project=vertex_ai_project,
                    vertex_credentials=vertex_credentials,
                    logging_obj=logging,
                    acompletion=acompletion,
                    headers=headers,
                    custom_prompt_dict=custom_prompt_dict,
                    timeout=timeout,
                    client=client,
                )

3836:    extra_headers=None,
                    status_code=500,
                    message=f"Function calling is not supported by {custom_llm_provider}.",
                )

    return optional_params


def get_optional_params(  # noqa: PLR0915
    # use the openai defaults
    # https://platform.openai.com/docs/api-reference/chat/create
    model: str,

    functions=None,
    function_call=None,
    temperature=None,
    top_p=None,
    n=None,
    stream=False,
    stream_options=None,
    stop=None,
    max_tokens=None,
    max_completion_tokens=None,
    modalities=None,
    prediction=None,
    audio=None,
    presence_penalty=None,
    frequency_penalty=None,
    logit_bias=None,
    user=None,
    custom_llm_provider="",
    response_format=None,
    seed=None,
    tools=None,
    tool_choice=None,
    max_retries=None,
    logprobs=None,
    top_logprobs=None,
    extra_hea
…[489 chars omitted]…
y()
    special_params = passed_params.pop("kwargs")
    non_default_params = pre_process_non_default_params(
        passed_params=passed_params,
        special_params=special_params,
        custom_llm_provider=custom_llm_provider,
        additional_drop_params=additional_drop_params,
        model=model,
    )
    optional_params = pre_process_optional_params(
        passed_params=passed_params,

3624:def pre_process_non_default_params(
3836:    extra_headers=None,
    @staticmethod
    def embedding_pre_process_non_default_params(
        passed_params: dict,
        special_params: dict,
        custom_llm_provider: str,
        additional_drop_params: Optional[List[str]],
        model: str,
        remove_sensitive_keys: bool = False,
        add_provider_specific_params: bool = False,
    ) -> dict:

        non_default_params = (
            PreProcessNonDefaultParams.base_pre_process_non_default_params(
                passed_params=passed_params,
                special_params=special_params,
                custom_llm_provider=custom_llm_provider,
                additional_drop_params=additional_drop_params,
                default_param_values={k: None for k in OPENAI_EMBEDDING_PARAMS},
                additional_endpoint_specific_params=["input"],
            )
    
…[2715 chars omitted]…
itional_drop_params,
        )

    if remove_sensitive_keys:
        non_default_params = remove_sensitive_keys_from_dict(non_default_params)
    return non_default_params


def remove_sensitive_keys_from_dict(d: dict) -> dict:
    """
    Remove sensitive keys from a dictionary
    """
    sensitive_key_phrases = ["key", "secret", "access", "credential"]
    remove_keys = []
    for key in d.keys():

/repo/tests/pass_through_unit_tests/base_anthropic_messages_tool_search_test.py
/repo/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
/repo/tests/test_litellm/llms/anthropic/chat/__pycache__/test_anthropic_chat_transformation.cpython-312-pytest-9.2.0.pyc

/root:
total 24
drwx------ 1 root root 4096 Nov  5 07:34 .
drwxr-xr-x 1 root root 4096 Nov  5 07:34 ..
-rw-r--r-- 1 root root  607 Jul  4 09:05 .bashrc
drwxr-xr-x 3 root root 4096 Nov  5 07:34 .cache
-rw-r--r-- 1 root root  132 Jul  4 09:05 .profile
-rw-r--r-- 1 root root  169 Aug  5 01:04 .wget-hsts

/tmp:
total 8
drwxrwxrwt 1 root root 4096 Nov  5 07:38 .

drwxr-xr-x 1 root root 4096 Nov  5 07:34 ..
-rw-r--r-- 1 root root    0 Nov  5 07:36 install.log
OLDPWD=/repo
PWD=/repo

# HSTS 1.0 Known Hosts database for GNU Wget.
# Edit at your own risk.
# <hostname>	<port>	<incl. subdomains>	<created>	<max-age>
www.python.org	0	1	1785891873	63072000
# Generated by Docker Engine.
# This file can be edited; Docker Engine will not make further changes once it
# has been modified.

nameserver 192.168.65.7

# Based on host file: '/etc/resolv.conf' (legacy)
# Overrides: []

127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::	ip6-localnet
ff00::	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters

bash: line 205: wget: command not found
rc=127

185.199.108.133 OSError [Errno 101] Network is unreachable
185.199.109.133 OSError [Errno 101] Network is unreachable
185.199.110.133 OSError [Errno 101] Network is unreachable
185.199.111.133 OSError [Errno 101] Network is unreachable

"""
Azure Anthropic transformation config - extends AnthropicConfig with Azure authentication
"""
from typing import TYPE_CHECKING, Dict, List, Optional, Union

from litellm.anthropic_beta_headers_manager import (
    update_headers_with_filtered_beta,
)
from litellm.llms.anthropic.chat.transformation import AnthropicConfig
from litellm.llms.azure.common_utils import BaseAzureLLM
from litellm.types.llms.openai import AllMessageValues
from litellm.types.router import GenericLiteLLMParams

if TYPE_CHECKING:
    pass


class AzureAnthropicConfig(AnthropicConfig):
    """
    Azure Anthropic configuration that extends AnthropicConfig.
    The only difference is authentication - Azure uses api-key header or Azure AD token
    instead of x-api-key header.
    """

    @property
    def custom_llm_provider(self) -> Optional[str]:
        return "azure_ai"

    def validate_environment(
     
…[7437 chars omitted]…
pi_key,
                    logging_obj=logging_obj,
                    optional_params=optional_params,
                    stream=stream,
                    _is_function_call=_is_function_call,
                    json_mode=json_mode,
                    litellm_params=litellm_params,
                    logger_fn=logger_fn,
                    headers=headers,
                    timeout=timeout,

elif param == "extra_headers":
                optional_params["extra_headers"] = value
            elif param == "context_management" and isinstance(value, dict):
                # Pass through Anthropic-specific context_management parameter
                optional_params["context_management"] = value

        ## handle thinking tokens
        self.update_optional_params_with_thinking_tokens(
            non_default_params=non_default_params, optional_params=optional_params
        )

        return optional_params

    def _create_json_tool_call_for_response_format(
        self,
        json_schema: Optional[dict] = None,
    ) -> AnthropicMessagesTool:
        """
        Handles creating a tool call for getting responses in JSON format.

        Args:
            json_schema (Optional[dict]): The JSON schema the response should be in

        Returns:
            Ant
…[4314 chars omitted]…
ontent_type == "container_upload":
                        add_code_execution_tool = True
                        break

        if add_code_execution_tool:
            ## check if code_execution tool is already in tools
            for tool in tools:
                tool_type = tool.get("type", None)
                if (
                    tool_type
                    and isinstance(tool_type, str)

200:            params.append("reasoning_effort")
662:    def _map_reasoning_effort(
663:        reasoning_effort: Optional[Union[REASONING_EFFORT, str]], 
671:            if reasoning_effort is None:
673:            elif reasoning_effort == "low":
678:            elif reasoning_effort == "medium":
683:            elif reasoning_effort == "high":
688:            elif reasoning_effort == "minimal":
694:                raise ValueError(f"Unmapped reasoning effort: {reasoning_effort}")
869:            elif param == "reasoning_effort" and isinstance(value, str):
870:                optional_params["thinking"] = AnthropicConfig._map_reasoning_effort(
871:                    reasoning_effort=value, model=model

                    substring in model
                    for substring in {
                        "sonnet-4.5",
                        "sonnet-4-5",
                        "opus
…[2191 chars omitted]…

            elif param == "context_management" and isinstance(value, dict):
                # Pass through Anthropic-specific context_management parameter
                optional_params["context_management"] = value

        ## handle thinking tokens
        self.update_optional_params_with_thinking_tokens(
            non_default_params=non_default_params, optional_params=optional_params
        )

tests/llm_translation/test_anthropic_completion.py:396:    headers = litellm.AnthropicConfig().get_anthropic_headers(
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:908:    headers = config.get_anthropic_headers(
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1203:    headers = model_info.get_anthropic_headers(
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1351:    headers = model_info.get_anthropic_headers(
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1493:    headers = model_info.get_anthropic_headers(
tests/test_litellm/llms/azure_ai/claude/test_azure_anthropic_transformation.py:120:                config, "get_anthropic_headers", return_value={}
tests/test_litellm/llms/azure_ai/claude/test_azure_anthropic_transformation.py:147:            with patch.object(con
…[346 chars omitted]…
attr(config, "get_anthropic_headers")
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:57:    headers = model_info.get_anthropic_headers(
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:69:    headers_non_vertex = model_info.get_anthropic_headers(

"function": {"name": "get_weather"}
        }
    ]
    assert config.is_tool_search_used(tools) is False


def test_tool_search_bm25_detection():
    """Test that tool search BM25 tools are properly detected"""
    from litellm.llms.anthropic.common_utils import AnthropicModelInfo
    
    config = AnthropicModelInfo()
    

    # Test with tool search BM25 tool
    tools = [
        {
            "type": "tool_search_tool_bm25_20251119",
            "name": "tool_search_tool_bm25"
        }
    ]
    assert config.is_tool_search_used(tools) is True


def test_tool_search_beta_header():
    """Test that tool search beta header is automatically added"""
    from litellm.llms.anthropic.common_utils import AnthropicModelInfo
    
    config = AnthropicModelInfo()
    
    headers = config.get_anthropic_headers(
        api_key="test-key",
        tool_search_used=True,
    )

…[3387 chars omitted]…
_beta_header
):
    headers = litellm.AnthropicConfig().get_anthropic_headers(
        api_key="fake-api-key",
        computer_tool_used=computer_tool_used,
        prompt_caching_set=prompt_caching_set,
    )

    if expected_beta_header:
        assert "anthropic-beta" in headers
    else:
        assert "anthropic-beta" not in headers


@pytest.mark.parametrize(
    "cache_control_location",
    [

{'max_tokens': 10, 'tools': [{'type': 'web_search_20250305', 'name': 'web_search'}], 'extra_headers': {'anthropic-beta': 'user-beta'}}

litellm/llms/anthropic/chat/transformation.py:188:            "extra_headers",
litellm/llms/anthropic/chat/transformation.py:880:            elif param == "extra_headers":
litellm/llms/anthropic/chat/transformation.py:881:                optional_params["extra_headers"] = value

{'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'hi'}]}], 'max_tokens': 10, 'extra_headers': {'anthropic-beta': 'user-beta'}}

litellm/integrations/lunary.py:122:                template_id = extra.pop("extra_headers", {}).get("Template-Id", None)

1457:        optional_params = get_optional_params(
                custom_llm_provider=custom_llm_provider,
                encoding=_get_encoding(),
                stream=stream,
            )

        if custom_llm_provider == "azure":
            # azure configs
            ## check dynamic params ##
            dynamic_params = False
            if client is not None and (
                isinstance(client, openai.AzureOpenAI)

                or isinstance(client, openai.AsyncAzureOpenAI)
            ):
                dynamic_params = _check_dynamic_azure_params(
                    azure_client_params={"api_version": api_version},
                    azure_client=client,
                )

            api_type = get_secret("AZURE_API_TYPE") or "azure"

            api_base = api_base or litellm.api_base or get_secret("AZURE_API_BASE")

            api_version = (
             
…[1473 chars omitted]…
mpletions.completion(
                    model=model,
                    messages=messages,
                    headers=headers,
                    api_key=api_key,
                    api_base=api_base,
                    api_version=api_version,
                    dynamic_params=dynamic_params,
                    azure_ad_token=azure_ad_token,
                    model_response=model_response,

"logit_bias": logit_bias,
            "user": user,
            # params to identify the model
            "model": model,
            "custom_llm_provider": custom_llm_provider,
            "response_format": response_format,
            "seed": seed,
            "tools": tools,
            "tool_choice": tool_choice,
            "max_retries": max_retries,
            "logprobs": logprobs,
            "top_logprobs": top_logprobs,

            "api_version": api_version,
            "parallel_tool_calls": parallel_tool_calls,
            "messages": messages,
            "reasoning_effort": reasoning_effort,
            "thinking": thinking,
            "web_search_options": web_search_options,
            "safety_identifier": safety_identifier,
            "service_tier": service_tier,
            "allowed_openai_params": kwargs.get("allowed_openai_params"),
        }
  
…[859 chars omitted]…
tions_unsupported_model"
            )
            messages = function_call_prompt(
                messages=messages, functions=functions_unsupported_model
            )

        # For logging - save the values of the litellm-specific params passed in
        litellm_params = get_litellm_params(
            acompletion=acompletion,
            api_key=api_key,
            force_timeout=force_timeout,

629:class ANTHROPIC_BETA_HEADER_VALUES(str, Enum):
630-    """
631-    Known beta header values for Anthropic.
632-    """
633-    WEB_FETCH_2025_09_10 = "web-fetch-2025-09-10"
634-    WEB_SEARCH_2025_03_05 = "web-search-2025-03-05"
635-    CONTEXT_MANAGEMENT_2025_06_27 = "context-management-2025-06-27"
636-    COMPACT_2026_01_12 = "compact-2026-01-12"
637-    STRUCTURED_OUTPUT_2025_09_25 = "structured-outputs-2025-11-13"
638-    ADVANCED_TOOL_USE_2025_11_20 = "advanced-tool-use-2025-11-20"
639-
640-

641-# Tool search beta header constant (for Anthropic direct API and Microsoft Foundry)
642-ANTHROPIC_TOOL_SEARCH_BETA_HEADER = "advanced-tool-use-2025-11-20"
643-
644-# Effort beta header constant
645-ANTHROPIC_EFFORT_BETA_HEADER = "effort-2025-11-24"
646-
647-# OAuth constants
648-ANTHROPIC_OAUTH_TOKEN_PREFIX = "sk-ant-oat"
649-ANTHROPIC_OAUTH_BETA_HEADER = "oauth-2025-04-20"
650-
651-A
…[426 chars omitted]…
nthropic.
632-    """
633-    WEB_FETCH_2025_09_10 = "web-fetch-2025-09-10"
634-    WEB_SEARCH_2025_03_05 = "web-search-2025-03-05"
635-    CONTEXT_MANAGEMENT_2025_06_27 = "context-management-2025-06-27"
636-    COMPACT_2026_01_12 = "compact-2026-01-12"
637-    STRUCTURED_OUTPUT_2025_09_25 = "structured-outputs-2025-11-13"
638-    ADVANCED_TOOL_USE_2025_11_20 = "advanced-tool-use-2025-11-20"
639-
640-

common_utils updated

def transform_request(
        self,
        model: str,
        messages: List[AllMessageValues],
        optional_params: dict,
        litellm_params: dict,
        headers: dict,
    ) -> dict:
        data = super().transform_request(
            model=model,
            messages=messages,
            optional_params=optional_params,

            litellm_params=litellm_params,
            headers=headers,
        )

        data.pop("model", None)  # vertex anthropic doesn't accept 'model' parameter
        
        # VertexAI doesn't support output_format parameter, remove it if present
        data.pop("output_format", None)
        
        tools = optional_params.get("tools")
        tool_search_used = self.is_tool_search_used(tools)
        auto_betas = self.get_anthropic_beta_list(
            model=model,
            optional_params=optional_params,
            computer
…[489 chars omitted]…
ers (compact and/or context-management)
        context_management = optional_params.get("context_management")
        if context_management:
            self._add_context_management_beta_headers(beta_set, context_management)

        if beta_set:
            data["anthropic_beta"] = list(beta_set)
        
        return data

    def map_openai_params(
        self,
        non_default_params: dict,

vertex chat updated

Provider List: https://docs.litellm.ai/docs/providers

beta 'user-beta' => body ['user-beta'] header None

Provider List: https://docs.litellm.ai/docs/providers

beta 'user-beta,other-beta' => body ['user-beta', 'other-beta'] header None

Provider List: https://docs.litellm.ai/docs/providers

beta ' user-beta , other-beta ' => body ['user-beta', 'other-beta'] header None

Provider List: https://docs.litellm.ai/docs/providers

auto+user ['effort-2025-11-24', 'user-beta'] output_config in body False header {}
validated headers {'anthropic-beta': 'user-beta,web-search-2025-03-05', 'anthropic-version': '2023-06-01', 'x-api-key': 'k', 'accept': 'application/json', 'content-type': 'application/json'}
body beta ['user-beta', 'web-search-2025-03-05'] final headers {'anthropic-version': '2023-06-01', 'x-api-key': 'k', 'accept': 'application/json', 'content-type': 'application/json'}
nonvertex body None header {'anthropic-beta': 'user-beta'}

Provider List: https://docs.litellm.ai/docs/providers

structured body keys dict_keys(['messages', 'tool_choice', 'tools', 'json_mode', 'max_tokens', 'anthropic_beta'])
anthropic_beta ['effort-2025-11-24', 'user-beta'] tools True

............                                                             [100%]
12 passed, 2 warnings in 1.41s

experimental updated

Traceback (most recent call last):
  File "<stdin>", line 7, in <module>
  File "/repo/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py", line 143, in transform_anthropic_messages_request
    user_betas = self._get_user_anthropic_beta_headers(
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'VertexAIPartnerModelsAnthropicMessagesConfig' object has no attribute '_get_user_anthropic_beta_headers'. Did you mean: '_get_anthropic_beta_header_value'?

fixed helper
'user-beta' {'anthropic_version': 'vertex-2023-10-16', 'anthropic_beta': ['user-beta']} header {}
'user-beta,other-beta' {'anthropic_version': 'vertex-2023-10-16', 'anthropic_beta': ['other-beta', 'user-beta']} header {}
' user-beta , other-beta ' {'anthropic_version': 'vertex-2023-10-16', 'anthropic_beta': ['other-beta', 'user-beta']} header {}
auto ['compact-2026-01-12', 'web-search-2025-03-05', 'user-beta'] header {}

.......................                                                  [100%]
23 passed, 2 warnings in 1.99s

litellm/llms/anthropic/common_utils.py             | 26 +++++--
 .../experimental_pass_through/transformation.py    | 81 +++++++++++++++++++++-
 .../anthropic/transformation.py                    | 59 ++++++++++++++--
 3 files changed, 153 insertions(+), 13 deletions(-)
diff --git a/litellm/llms/anthropic/common_utils.py b/litellm/llms/anthropic/common_utils.py
index cb23d21..f2eca3c 100644
--- a/litellm/llms/anthropic/common_utils.py
+++ b/litellm/llms/anthropic/common_utils.py
@@ -247,11 +247,24 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         return False
 
     def _get_user_anthropic_beta_headers(

-        self, anthropic_beta_header: Optional[str]
+        self, anthropic_beta_header: Optional[Union[str, List[str]]]
     ) -> Optional[List[str]]:
         if anthropic_beta_header is None:
             return None
-        return anthropic_beta_header.split(",")
+
+      
…[8628 chars omitted]…
-beta header value, matching the header name case-insensitively."""
+        if not headers:
+            return None
+        for header_name, header_value in headers.items():
+            if isinstance(header_name, str) and header_name.lower() == "anthropic-beta":
+                return header_value
+        return None
+
     def map_openai_params(
         self,
         non_default_params: dict,

For variant 'global', will try loading '/etc/xdg/pip/pip.conf'
For variant 'global', will try loading '/etc/pip.conf'
For variant 'user', will try loading '/root/.pip/pip.conf'
For variant 'user', will try loading '/root/.config/pip/pip.conf'
For variant 'site', will try loading '/usr/local/pip.conf'
0
1
2
3
4
5
6

7
8
9

/root/.cache/pip/http-v2/b/5/9/2/8/b5928498db9932d4c4f8392f87a765c22f5a8b8e8fc5209e6224cfd0.body
72M	/root/.cache/pip

-rw-r--r-- 1 root root 51857 Nov  5 07:35 /root/.cache/pip/http-v2/b/5/9/2/8/b5928498db9932d4c4f8392f87a765c22f5a8b8e8fc5209e6224cfd0.body
0000000   M   e   t   a   d   a   t   a   -   V   e   r   s   i   o   n
0000020   :       2   .
0000024
False False

[]

0

/usr/local/bin/python: No module named ruff
rc=1

==================================== ERRORS ====================================
_ ERROR collecting tests/test_litellm/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py _
ImportError while importing test module '/repo/tests/test_litellm/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/local/lib/python3.12/importlib/__init__.py:90: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/test_litellm/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py:20: in <module>
    from litellm.llms.anthropic.chat.guardrail_translation.handler import (
litellm/llms/anthropic/chat/guardrail_translation/__init__.py:1: in <module>
    from 

…[2255 chars omitted]…
s/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py
ERROR tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
ERROR tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_experimental_pass_through_messages_handler.py
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 3 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
2 warnings, 3 errors in 4.53s

import json
import os
import sys

import pytest
from fastapi.testclient import TestClient

sys.path.insert(
    0, os.path.abspath("../../../../..")
)  # Adds the parent directory to the system path
from unittest.mock import MagicMock, patch

from litellm.llms.anthropic.chat.transformation import AnthropicConfig
from litellm.llms.anthropic.experimental_pass_through.messages.transformation import (
    AnthropicMessagesConfig,
)
from litellm.types.utils import PromptTokensDetailsWrapper, ServerToolUse


def test_response_format_transformation_unit_test():
    config = AnthropicConfig()

    response_format_json_schema = {
        "description": 'Progress report for the thinking process\n\nThis model represents a snapshot of the agent\'s current progress during\nthe thinking process, providing a brief description of the current activity.\n\nAttributes:\n    agent_doing: Brief descriptio
…[259 chars omitted]…
 "title": "ThinkingStep",
        "type": "object",
        "additionalProperties": False,
    }

    result = config._create_json_tool_call_for_response_format(
        json_schema=response_format_json_schema
    )

    assert result["input_schema"]["properties"] == {
        "agent_doing": {"title": "Agent Doing", "type": "string"}
    }
    print(result)

6:from fastapi.testclient import TestClient

api_base=api_base,
                    custom_prompt_dict=custom_prompt_dict,
                    model_response=model_response,
                    print_verbose=print_verbose,
                    encoding=encoding,
                    api_key=api_key,
                    logging_obj=logging_obj,
                    optional_params=optional_params,
                    stream=stream,
                    _is_function_call=_is_function_call,
                    json_mode=json_mode,
                    litellm_params=litellm_params,

                    logger_fn=logger_fn,
                    headers=headers,
                    timeout=timeout,
                    client=(
                        client
                        if client is not None and isinstance(client, AsyncHTTPHandler)
                        else None
                    ),
                )
    
…[3261 chars omitted]…
_response(
            model=model,
            raw_response=response,
            model_response=model_response,
            logging_obj=logging_obj,
            api_key=api_key,
            request_data=data,
            messages=messages,
            optional_params=optional_params,
            litellm_params=litellm_params,
            encoding=encoding,
            json_mode=json_mode,
        )

tests/test_litellm/llms/vertex_ai/image_edit/test_vertex_ai_image_edit_transformation.py:146:            self.config, "_ensure_access_token", return_value=("test-token", "test-expiry")
tests/test_litellm/llms/vertex_ai/image_generation/test_vertex_ai_image_generation_transformation.py:446:            config, "_ensure_access_token", return_value=("token", None)
tests/test_litellm/llms/vertex_ai/image_generation/test_vertex_ai_image_generation_transformation.py:469:            config, "_ensure_access_token", return_value=("token", None)
tests/test_litellm/llms/vertex_ai/rerank/test_vertex_ai_rerank_integration.py:19:    @patch('litellm.llms.vertex_ai.rerank.transformation.VertexAIRerankConfig._ensure_access_token')
tests/test_litellm/llms/vertex_ai/rerank/test_vertex_ai_rerank_integration.py:20:    def test_end_to_end_rerank_flow(self, mock_ensure_access_token):
tests/test_litellm/llms/
…[7650 chars omitted]…
sure_access_token_async(
tests/test_litellm/llms/vertex_ai/test_vertex_llm_base.py:49:                token, project = vertex_base._ensure_access_token(
tests/test_litellm/llms/vertex_ai/test_vertex_llm_base.py:62:                result = await vertex_base._ensure_access_token_async(
tests/test_litellm/llms/vertex_ai/test_vertex_llm_base.py:68:                result = vertex_base._ensure_access_token(

"""
Base test class for Anthropic Messages API tool search E2E tests.

Tests that tool search works correctly via litellm.anthropic.messages interface
by making actual API calls and validating that tool search discovers deferred tools.

Reference: https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool
"""

import json
import os
import sys

from abc import ABC, abstractmethod
from typing import Any, Dict, List

sys.path.insert(0, os.path.abspath("../../.."))

import pytest
import litellm


# Sample tools for tool search testing
def get_deferred_tools() -> List[Dict[str, Any]]:
    """
    Returns a list of tools with defer_loading: true.
    These tools should only be discovered via tool search.
    """
    return [
        {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "input_schema": {
     
…[4408 chars omitted]…
_discovers_tool(self):
        """
        E2E test: Tool search should discover and use a deferred tool.
        
        This validates that when the user asks about weather, the model
        discovers the get_weather tool via tool search and attempts to use it.
        """
        litellm._turn_on_debug()
        
        tools = self.get_tools_with_tool_search()
        messages = [
            {

litellm/llms/anthropic/common_utils.py:287:    def get_anthropic_beta_list(
litellm/llms/bedrock/chat/invoke_transformations/anthropic_claude3_transformation.py:117:        auto_betas = self.get_anthropic_beta_list(
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:466:        auto_betas = anthropic_model_info.get_anthropic_beta_list(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:113:        auto_betas = self.get_anthropic_beta_list(

........................................................................ [ 80%]
.................                                                        [100%]
89 passed, 3 warnings in 1.60s

hierarchy within that package. Only one import is needed in this form. If
        it ends with the colon, then a module object is returned.
    
        The function will return an object (which might be a module), or raise one
        of the following exceptions:
    
        ValueError - if `name` isn't in a recognised format
        ImportError - if an import failed when it shouldn't have
        AttributeError - if a failure occurred when traversing the object hierarchy
                         within the imported package to get to the desired object.
        """
        global _NAME_PATTERN

        if _NAME_PATTERN is None:
            # Lazy import to speedup Python startup time
            import re
            dotted_words = r'(?!\d)(\w+)(\.(?!\d)(\w+))*'
            _NAME_PATTERN = re.compile(f'^(?P<pkg>{dotted_words})'
                                       f'(?P<cln
…[1746 chars omitted]…
pic/experimental_pass_through/messages/test_anthropic_experimental_pass_through_messages_handler.py::test_bedrock_converse_budget_tokens_preserved
FAILED tests/test_litellm/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py::TestAnthropicMessagesHandlerInputProcessing::test_process_input_messages_preserves_litellm_metadata_guardrails
2 failed, 231 passed, 5 warnings in 9.32s

/repo
total 2468
drwxr-xr-x 1 root root    4096 Nov  2 12:06 .
drwxr-xr-x 1 root root    4096 Nov  2 12:07 ..
drwxr-xr-x 1 root root    4096 Nov  2 11:55 .circleci
drwxr-xr-x 1 root root    4096 Nov  2 11:55 .devcontainer
-rw-r--r-- 1 root root     635 Nov  2 11:55 .dockerignore
-rw-r--r-- 1 root root     624 Nov  2 11:55 .env.example
-rw-r--r-- 1 root root    1477 Nov  2 11:55 .flake8
drwxr-xr-x 1 root root    4096 Nov  2 12:08 .git
-rw-r--r-- 1 root root     386 Nov  2 11:55 .git-blame-ignore-revs
-rw-r--r-- 1 root root      25 Nov  2 11:55 .gitattributes

-rw-r--r-- 1 root root    3970 Nov  2 11:55 .gitguardian.yaml
drwxr-xr-x 1 root root    4096 Nov  2 11:55 .github
-rw-r--r-- 1 root root    2511 Nov  2 11:55 .gitignore
-rw-r--r-- 1 root root    1309 Nov  2 11:55 .pre-commit-config.yaml
-rw-r--r-- 1 root root     346 Nov  2 11:55 .trivyignore
-rw-r--r-- 1 root root    7699 Nov  2 1
…[5160 chars omitted]…
/Dockerfile.alpine
./docker/Dockerfile.custom_ui
./docker/Dockerfile.database
./docker/Dockerfile.dev
./docker/Dockerfile.health_check
./docker/Dockerfile.non_root
./docker/entrypoint.sh
./docker/install_auto_router.sh
./docker/prod_entrypoint.sh
./docker/README.md
./docker/supervisord.conf
./docker-compose.hardened.yml
./docker-compose.yml
./Dockerfile
./enterprise/LICENSE.md
./enterprise/poetry.lock

litellm/anthropic_beta_headers_config.json
litellm/anthropic_beta_headers_manager.py
litellm/anthropic_interface
litellm/integrations/anthropic_cache_control_hook.py
litellm/litellm_core_utils/tokenizers/anthropic_tokenizer.json
litellm/llms/anthropic
litellm/llms/azure_ai/anthropic
litellm/llms/base_llm/anthropic_messages
litellm/llms/bedrock/chat/invoke_transformations/anthropic_claude2_transformation.py
litellm/llms/bedrock/chat/invoke_transformations/anthropic_claude3_transformation.py
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py
litellm/llms/vertex_ai

litellm/llms/vertex_ai/context_caching/vertex_ai_context_caching.py
litellm/llms/vertex_ai/gemini/vertex_and_google_ai_studio_gemini.py
litellm/llms/vertex_ai/image_edit/vertex_gemini_transformation.py
litellm/llms/vertex_ai/image_edit/vertex_imagen_transformation.py
litellm/llms/vertex_ai
…[963 chars omitted]…

litellm/types/llms/anthropic_messages
litellm/types/llms/anthropic_messages/anthropic_request.py
litellm/types/llms/anthropic_messages/anthropic_response.py
litellm/types/llms/anthropic_skills.py
litellm/types/llms/anthropic_tool_search.py
litellm/types/llms/vertex_ai.py
litellm/types/llms/vertex_ai_text_to_speech.py
litellm/types/passthrough_endpoints/vertex_ai.py
bash: line 8: rg: command not found

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
tests/agent_tests/local_only_agent_tests/local_vertex_agent.py
tests/audio_tests/speech_vertex.mp3
tests/batches_tests/vertex_batch_completions.jsonl
tests/image_gen_tests/vertex_key.json
tests/litellm/llms/vertex_ai
tests/litellm_utils_tests/vertex_key.json
tests/load_tests/test_vertex_embeddings_load_test.py
tests/load_tests/test_vertex_load_tests.py
tests/load_tests/vertex_key.json
tests/local_testing/speech_vertex.mp3

tests/local_testing/test_amazing_vertex_completion.py
tests/local_testing/vertex_ai.jsonl
tests/local_testing/vertex_batch_completions.jsonl
tests/local_testing/vertex_key.json
tests/logging_callback_tests/langfuse_expected_request_body/completion_with_vertex_call.json
tests/ocr_tests/test_oc
…[8630 chars omitted]…
 headers["anthropic-beta"]:
litellm/llms/anthropic/skills/transformation.py:61:                headers["anthropic-beta"] = [headers["anthropic-beta"], ANTHROPIC_SKILLS_API_BETA_VERSION]
litellm/llms/anthropic/skills/transformation.py:80:            return f"{api_base}/v1/skills/{skill_id}?beta=true"
litellm/llms/anthropic/skills/transformation.py:81:        return f"{api_base}/v1/{endpoint}?beta=true"

# What is this?
## Handler file for calling claude-3 on vertex ai
from typing import Any, List, Optional

import httpx

import litellm
from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
from litellm.types.llms.openai import AllMessageValues
from litellm.types.utils import ModelResponse

from ....anthropic.chat.transformation import AnthropicConfig

class VertexAIError(Exception):
    def __init__(self, status_code, message):
        self.status_code = status_code
        self.message = message
        self.request = httpx.Request(
            method="POST", url=" https://cloud.google.com/vertex-ai/"
        )
        self.response = httpx.Response(status_code=status_code, request=self.request)
        super().__init__(
            self.message
        )  # Call the base class constructor with the parameters it needs


class VertexAIAnthropicConfig(AnthropicConfig
…[8629 chars omitted]…
ing_iterator.py
litellm/llms/anthropic/experimental_pass_through/messages/transformation.py
litellm/llms/anthropic/experimental_pass_through/messages/utils.py
litellm/llms/anthropic/files/handler.py
litellm/llms/anthropic/files/__init__.py
litellm/llms/anthropic/skills/readme.md
litellm/llms/anthropic/skills/transformation.py
litellm/llms/anthropic/skills/__init__.py
litellm/llms/anthropic/__init__.py

# What is this?
## Handler file for calling claude-3 on vertex ai
from typing import Any, List, Optional

import httpx

import litellm
from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
from litellm.types.llms.openai import AllMessageValues
from litellm.types.utils import ModelResponse

from ....anthropic.chat.transformation import AnthropicConfig

class VertexAIError(Exception):
    def __init__(self, status_code, message):
        self.status_code = status_code
        self.message = message
        self.request = httpx.Request(
            method="POST", url=" https://cloud.google.com/vertex-ai/"
        )
        self.response = httpx.Response(status_code=status_code, request=self.request)
        super().__init__(
            self.message
        )  # Call the base class constructor with the parameters it needs


class VertexAIAnthropicConfig(AnthropicConfig
…[8629 chars omitted]…
anthropic_version"] = "vertex-2023-10-16"

        anthropic_messages_request.pop(
            "model", None
        )  # do not pass model in request body to vertex ai

        anthropic_messages_request.pop(
            "output_format", None
        )  # do not pass output_format in request body to vertex ai - vertex ai does not support output_format as yet

        return anthropic_messages_request

1	# What is this?
     2	## Handler file for calling claude-3 on vertex ai
     3	from typing import Any, List, Optional
     4	
     5	import httpx
     6	
     7	import litellm
     8	from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
     9	from litellm.types.llms.openai import AllMessageValues
    10	from litellm.types.utils import ModelResponse
    11	
    12	from ....anthropic.chat.transformation import AnthropicConfig

    13	
    14	
    15	class VertexAIError(Exception):
    16	    def __init__(self, status_code, message):
    17	        self.status_code = status_code
    18	        self.message = message
    19	        self.request = httpx.Request(
    20	            method="POST", url=" https://cloud.google.com/vertex-ai/"
    21	        )
    22	        self.response = httpx.Response(status_code=status_code, request=self.request)
    23	        sup
…[8630 chars omitted]…
ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:363:    headers2 = update_headers_with_filtered_beta(headers2, "vertex_ai")
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:364:    assert "anthropic-beta" not in headers2, "Header should be removed if no supported values remain"

def transform_request(
        self,
        model: str,
        messages: List[AllMessageValues],
        optional_params: dict,
        litellm_params: dict,
        headers: dict,
    ) -> dict:
        data = super().transform_request(
            model=model,
            messages=messages,
            optional_params=optional_params,

            litellm_params=litellm_params,
            headers=headers,
        )

        data.pop("model", None)  # vertex anthropic doesn't accept 'model' parameter
        
        # VertexAI doesn't support output_format parameter, remove it if present
        data.pop("output_format", None)
        
        tools = optional_params.get("tools")
        tool_search_used = self.is_tool_search_used(tools)
        auto_betas = self.get_anthropic_beta_list(
            model=model,
            optional_params=optional_params,
            computer
…[8629 chars omitted]…
 {
        "type": "json_schema",
        "json_schema": {
            "name": "questions",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "question": {
                        "type": "string"
                    },
                    "response": {
                        "type": "string"
                    }

import json
import re
import time
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast

import httpx

import litellm
from litellm.constants import (
    ANTHROPIC_WEB_SEARCH_TOOL_MAX_USES,
    DEFAULT_ANTHROPIC_CHAT_MAX_TOKENS,
    DEFAULT_REASONING_EFFORT_HIGH_THINKING_BUDGET,

    DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET,
    DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET,
    DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET,
    RESPONSE_FORMAT_TOOL_NAME,
)
from litellm.litellm_core_utils.core_helpers import map_finish_reason
from litellm.llms.base_llm.base_utils import type_to_response_format_param
from litellm.llms.base_llm.chat.transformation import BaseConfig, BaseLLMException
from litellm.types.llms.anthropic import (
    ANTHROPIC_BETA_HEADER_VALUES,
    ANTHROPIC_HOSTED_TOOLS,
    AllAnthropicMessageValues,
    AllAnthropicToolsValues,
    Anth
…[8629 chars omitted]…
anthropic_version"] = "vertex-2023-10-16"

        anthropic_messages_request.pop(
            "model", None
        )  # do not pass model in request body to vertex ai

        anthropic_messages_request.pop(
            "output_format", None
        )  # do not pass output_format in request body to vertex ai - vertex ai does not support output_format as yet

        return anthropic_messages_request

188:            "extra_headers",
207:        Filter out unsupported fields from JSON schema for Anthropic's output_format API.
209:        Anthropic's output_format doesn't support certain JSON schema properties:
709:    def map_response_format_to_anthropic_output_format(
718:        # Filter out unsupported fields for Anthropic's output_format API
838:                    _output_format = (
839:                        self.map_response_format_to_anthropic_output_format(value)
841:                    if _output_format is not None:
842:                        optional_params["output_format"] = _output_format
880:            elif param == "extra_headers":
881:                optional_params["extra_headers"] = value
1019:        Ensure a beta header value is present in the anthropic-beta header.

1026:        existing_beta = headers.get("anthropic-beta")
1028:            headers["anthropic
…[1575 chars omitted]…
tput_format") is not None:
1218:        ## Handle output_config (Anthropic-specific parameter)
1219:        if "output_config" in optional_params:
1220:            output_config = optional_params.get("output_config")
1221:            if output_config and isinstance(output_config, dict):
1222:                effort = output_config.get("effort")
1227:                data["output_config"] = output_config

id=anthropic_tool_content["id"],
            type="function",
            function=ChatCompletionToolCallFunctionChunk(
                name=anthropic_tool_content["name"],
                arguments=json.dumps(anthropic_tool_content["input"]),
            ),
            index=index,
        )
        # Include caller information if present (for programmatic tool calling)
        if "caller" in anthropic_tool_content:
            tool_call["caller"] = cast(Dict[str, Any], anthropic_tool_content["caller"])  # type: ignore[typeddict-item]
        return tool_call

    @staticmethod
    def _is_claude_opus_4_6(model: str) -> bool:
        """Check if the model is Claude Opus 4.5."""
        return "opus-4-6" in model.lower() or "opus_4_6" in model.lower()

    def get_supported_openai_params(self, model: str):
        params = [
            "stream",
            "stop",
      
…[8630 chars omitted]…
   # check if tool name is the default tool name
            json_mode_content_str: Optional[str] = None
            if (
                "name" in tool_calls[0]["function"]
                and tool_calls[0]["function"]["name"] == RESPONSE_FORMAT_TOOL_NAME
            ):
                json_mode_content_str = tool_calls[0]["function"].get("arguments")
            if json_mode_content_str is not None:

]

        return hosted_web_search_tool

    def map_openai_params(  # noqa: PLR0915
        self,
        non_default_params: dict,
        optional_params: dict,
        model: str,
        drop_params: bool,
    ) -> dict:
        is_thinking_enabled = self.is_thinking_enabled(

            non_default_params=non_default_params
        )

        for param, value in non_default_params.items():
            if param == "max_tokens":
                optional_params["max_tokens"] = value
            if param == "max_completion_tokens":
                optional_params["max_tokens"] = value
            if param == "tools":
                # check if optional params already has tools
                anthropic_tools, mcp_servers = self._map_tools(value)
                optional_params = self._add_tools_to_optional_params(
                    optional_params=optional_params, too
…[8629 chars omitted]…
sform_response_for_json_mode(
        self,
        json_mode: Optional[bool],
        tool_calls: List[ChatCompletionToolCallChunk],
    ) -> Optional[LitellmMessage]:
        _message: Optional[LitellmMessage] = None
        if json_mode is True and len(tool_calls) == 1:
            # check if tool name is the default tool name
            json_mode_content_str: Optional[str] = None
            if (

for message in messages:
            message_content = message.get("content", None)
            if message_content and isinstance(message_content, list):
                for content in message_content:
                    content_type = content.get("type", None)
                    if content_type == "container_upload":
                        add_code_execution_tool = True
                        break

        if add_code_execution_tool:
            ## check if code_execution tool is already in tools
            for tool in tools:

                tool_type = tool.get("type", None)
                if (
                    tool_type
                    and isinstance(tool_type, str)
                    and tool_type.startswith("code_execution")
                ):
                    return tools
            tools.append(
                AnthropicCodeExecutionTool(
            
…[8630 chars omitted]…
rtex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:3:from litellm.anthropic_beta_headers_manager import (
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:111:        auto_betas = self.get_anthropic_beta_list(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:130:            data["anthropic_beta"] = list(beta_set)

import os
import sys

import pytest

sys.path.insert(
    0, os.path.abspath("../../../../../..")
)  # Adds the parent directory to the system path
from litellm.anthropic_beta_headers_manager import (
    update_headers_with_filtered_beta,
)
from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation import (

    VertexAIAnthropicConfig,
)


@pytest.mark.parametrize(
    "model, expected_thinking",
    [
        ("claude-sonnet-4@20250514", True),
    ],
)
def test_vertex_ai_anthropic_thinking_param(model, expected_thinking):
    supported_openai_params = VertexAIAnthropicConfig().get_supported_openai_params(
        model=model
    )

    if expected_thinking:
        assert "thinking" in supported_openai_params
    else:
        assert "thinking" not in supported_openai_params


def test_get_supported_params_thinking():
    config = VertexAIAnthropicConfig()
    pa
…[8629 chars omitted]…
-03-05" in (beta_header or ""), \
        "Other non-excluded beta headers should remain"
    # If prompt-caching was the only value, header should be removed completely
    headers2 = {"anthropic-beta": PROMPT_CACHING_BETA_HEADER}
    headers2 = update_headers_with_filtered_beta(headers2, "vertex_ai")
    assert "anthropic-beta" not in headers2, "Header should be removed if no supported values remain"

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:21:class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, VertexBase):
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:28:class VertexAIAnthropicConfig(AnthropicConfig):
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py:37:    The class `VertexAIAnthropicConfig` provides configuration for the VertexAI's Anthropic API interface. Below are the parameters:
litellm/llms/vertex_ai/vertex_ai_partner_models/__init__.py:9:        from .anthropic.transformation import VertexAIAnthropicConfig
litellm/llms/vertex_ai/vertex_ai_partner_models/__init__.py:11:        return VertexAIAnthropicConfig()
litellm/litellm_core_utils/get_supported_openai_params.py:193:                return litellm.VertexAIAnthropicConfig().get_suppo
…[8228 chars omitted]…
sformation.py:103:    def transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:108:    def transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:116:        anthropic_messages_request = super().transform_anthropic_messages_request(

optional_params["stream"] = stream

            if self.should_use_openai_handler(model):
                partner = VertexPartnerProvider.llama
            elif "mistral" in model or "codestral" in model:
                partner = VertexPartnerProvider.mistralai
            elif "jamba" in model:
                partner = VertexPartnerProvider.ai21
            elif "claude" in model:
                partner = VertexPartnerProvider.claude
            else:
                raise ValueError(f"Unknown partner model: {model}")

            api_base = self.get_complete_vertex_url(
                custom_api_base=api_base,
                vertex_location=vertex_location,
                vertex_project=vertex_project,
                project_id=project_id,
                partner=partner,
                stream=stream,
                model=model,
            )

            if "c
…[5021 chars omitted]…
_models_anthropic_transformation.py:169:    result_vertex = config.update_headers_with_optional_anthropic_beta(headers_vertex, optional_params_vertex)
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:186:    result_non_vertex = config.update_headers_with_optional_anthropic_beta(headers_non_vertex, optional_params_non_vertex)

error_headers = getattr(error_response, "headers", None)
            if error_response and hasattr(error_response, "text"):
                error_text = getattr(error_response, "text", error_text)
            raise AnthropicError(
                message=error_text,
                status_code=status_code,
                headers=error_headers,
            )

        return provider_config.transform_response(
            model=model,
            raw_response=response,

            model_response=model_response,
            logging_obj=logging_obj,
            api_key=api_key,
            request_data=data,
            messages=messages,
            optional_params=optional_params,
            litellm_params=litellm_params,
            encoding=encoding,
            json_mode=json_mode,
        )

    def completion(
        self,
        model: str,
        messages: li
…[8629 chars omitted]…
:
        from litellm.secret_managers.main import get_secret_str

        return api_key or get_secret_str("ANTHROPIC_API_KEY")

    @staticmethod
    def get_base_model(model: Optional[str] = None) -> Optional[str]:
        return model.replace("anthropic/", "") if model else None

    def get_models(
        self, api_key: Optional[str] = None, api_base: Optional[str] = None
293:    def completion(

file_id_used: bool = False,
        mcp_server_used: bool = False,
    ) -> List[str]:
        """
        Get list of common beta headers based on the features that are active.
        
        Returns:
            List of beta header strings
        """
        from litellm.types.llms.anthropic import (
            ANTHROPIC_EFFORT_BETA_HEADER,
        )

        
        betas = []
        
        # Detect features
        effort_used = self.is_effort_used(optional_params, model)
        
        if effort_used:
            betas.append(ANTHROPIC_EFFORT_BETA_HEADER)  # effort-2025-11-24
        
        if computer_tool_used:
            beta_header = self.get_computer_tool_beta_header(computer_tool_used)
            betas.append(beta_header)
        
        # Anthropic no longer requires the prompt-caching beta header
        # Prompt caching now works automatically when 
…[8629 chars omitted]…
o = AnthropicModelInfo()
            if anthropic_model_info.is_tool_search_used(tools):
                # Use provider-specific tool search header
                tool_search_header = get_tool_search_beta_header(custom_llm_provider)
                beta_values.add(tool_search_header)

        if beta_values:
            headers["anthropic-beta"] = ",".join(sorted(beta_values))

        return headers

# What is this?
## API Handler for calling Vertex AI Partner Models
from enum import Enum
from typing import Callable, Optional, Union

import httpx  # type: ignore

import litellm
from litellm import LlmProviders
from litellm.types.llms.vertex_ai import VertexPartnerProvider
from litellm.utils import ModelResponse

from ...custom_httpx.llm_http_handler import BaseLLMHTTPHandler
from ..vertex_llm_base import VertexBase

base_llm_http_handler = BaseLLMHTTPHandler()


class VertexAIError(Exception):
    def __init__(self, status_code, message):
        self.status_code = status_code
        self.message = message
        self.request = httpx.Request(
            method="POST", url=" https://cloud.google.com/vertex-ai/"
        )
        self.response = httpx.Response(status_code=status_code, request=self.request)
        super().__init__(
            self.message
        )  # Call the b
…[8629 chars omitted]…
er = CustomStreamWrapper(
            completion_stream=completion_stream,
            model=model,
            custom_llm_provider="anthropic",
            logging_obj=logging_obj,
            _response_headers=process_anthropic_headers(headers),
        )
        return streamwrapper

    async def acompletion_function(
        self,
        model: str,
        messages: list,
        api_base: str,

"""
This file contains common utils for anthropic calls.
"""

from typing import Dict, List, Optional, Union

import httpx

import litellm
from litellm.litellm_core_utils.prompt_templates.common_utils import (
    get_file_ids_from_messages,
)

from litellm.llms.base_llm.base_utils import BaseLLMModelInfo, BaseTokenCounter
from litellm.llms.base_llm.chat.transformation import BaseLLMException
from litellm.types.llms.anthropic import (
    ANTHROPIC_HOSTED_TOOLS,
    ANTHROPIC_OAUTH_BETA_HEADER,
    ANTHROPIC_OAUTH_TOKEN_PREFIX,
    AllAnthropicToolsValues,
    AnthropicMcpServerTool,
)
from litellm.types.llms.openai import AllMessageValues


def optionally_handle_anthropic_oauth(
    headers: dict, api_key: Optional[str]
) -> tuple[dict, Optional[str]]:
    """
    Handle Anthropic OAuth token detection and header setup.

    If an OAuth token is detected in the Authorization header, e
…[8629 chars omitted]…
_chat_config(
litellm/llms/openai_like/chat/handler.py:264:            provider_config = ProviderConfigManager.get_provider_chat_config(
litellm/main.py:1400:            provider_config = ProviderConfigManager.get_provider_chat_config(
litellm/utils.py:3868:        provider_config = ProviderConfigManager.get_provider_chat_config(
litellm/utils.py:7973:    def get_provider_chat_config(  # noqa: PLR0915

timeout=timeout,
                    headers=headers,
                    encoding=encoding,
                    api_key=access_token,
                    logging_obj=logging_obj,  # model call logging done inside the class as we make need to modify I/O to fit aleph alpha's requirements
                    client=client,
                )
            return openai_like_chat_completions.completion(
                model=model,
                messages=messages,
                api_base=api_base,
                api_key=access_token,

                custom_prompt_dict=custom_prompt_dict,
                model_response=model_response,
                print_verbose=print_verbose,
                logging_obj=logging_obj,
                optional_params=optional_params,
                acompletion=acompletion,
                litellm_params=litellm_params,
              
…[8630 chars omitted]…
7:        extra_headers: Optional[Dict[str, Any]] = None,
litellm/interactions/http_handler.py:215:            headers=extra_headers or {},
litellm/interactions/http_handler.py:331:        extra_headers: Optional[Dict[str, Any]] = None,
litellm/interactions/http_handler.py:344:                extra_headers=extra_headers,
litellm/interactions/http_handler.py:356:            headers=extra_headers or {},

litellm/llms/anthropic/chat/transformation.py:881:                optional_params["extra_headers"] = value
litellm/llms/anthropic/chat/transformation.py:881:                optional_params["extra_headers"] = value
litellm/llms/azure/azure.py:210:            optional_params["extra_headers"] = headers
litellm/llms/azure/azure.py:746:            optional_params["extra_headers"] = headers
litellm/llms/custom_httpx/llm_http_handler.py:1821:        extra_headers_from_kwargs = kwargs.get("extra_headers", None)
litellm/llms/custom_httpx/llm_http_handler.py:2063:            headers=response_api_optional_request_params.get("extra_headers", {}) or {},
litellm/llms/custom_httpx/llm_http_handler.py:2208:            headers=response_api_optional_request_params.get("extra_headers", {}) or {},
litellm/llms/custom_httpx/llm_http_handler.py:4625:            headers=image_edit_optional_request_params.ge
…[4421 chars omitted]…
ders=None,
litellm/litellm_core_utils/get_provider_specific_headers.py:27:            return provider_specific_header.get("extra_headers", {})
litellm/litellm_core_utils/litellm_logging.py:4900:        extra_headers: List[str] = (

litellm/litellm_core_utils/litellm_logging.py:4903:        if not extra_headers:
litellm/litellm_core_utils/litellm_logging.py:4911:        for header_name in extra_headers:

headers=headers,
                model_response=model_response,
                api_key=api_key,
                api_base=api_base,
                acompletion=acompletion,
                logging_obj=logging,
                optional_params=optional_params,
                litellm_params=litellm_params,
                timeout=timeout,  # type: ignore
                client=client,  # pass AsyncOpenAI, OpenAI client
                custom_llm_provider=custom_llm_provider,
                encoding=_get_encoding(),

                stream=stream,
            )

        if custom_llm_provider == "azure":
            # azure configs
            ## check dynamic params ##
            dynamic_params = False
            if client is not None and (
                isinstance(client, openai.AzureOpenAI)
                or isinstance(client, openai.AsyncAzureOpenAI)
            
…[8629 chars omitted]…
programmatic_tool_calling_used=programmatic_tool_calling_used,
439-            input_examples_used=input_examples_used,
440-            effort_used=effort_used,
441-            code_execution_tool_used=code_execution_tool_used,
442-            container_with_skills_used=container_with_skills_used,
443-        )
444-
445-        headers = {**headers, **anthropic_headers}
446-
447-        return headers

227:from .llms.vertex_ai.vertex_ai_partner_models.main import VertexAIPartnerModels
284:vertex_partner_models_chat_completion = VertexAIPartnerModels()
966:        or custom_llm_provider == "vertex_ai"
3360:        elif custom_llm_provider == "vertex_ai":
5104:        elif custom_llm_provider == "vertex_ai":
6786:    elif custom_llm_provider == "vertex_ai" or custom_llm_provider == "vertex_ai_beta":
210:                return anthropic_chat_completions.completion(
                    custom_llm_provider="vertex_ai",
                    provider_config=vertex_agent_engine_config,
                    headers=headers or {},
                )
            else:  # VertexAIModelRoute.NON_GEMINI

                model_response = vertex_ai_non_gemini.completion(
                    model=model,
                    messages=messages,
                    model_response=model_response,
          
…[8629 chars omitted]…
de: bool,
        litellm_params: dict,
        provider_config: "BaseConfig",
        logger_fn=None,
        headers={},
        client: Optional[AsyncHTTPHandler] = None,
    ) -> Union[ModelResponse, "CustomStreamWrapper"]:
        async_handler = client or get_async_httpx_client(
            llm_provider=litellm.LlmProviders.ANTHROPIC
litellm/llms/anthropic/__init__.py:9:def get_anthropic_config(

or (model in litellm.together_ai_models)
        ):
            """
            Deprecated. We now do together ai calls via the openai client - https://docs.together.ai/docs/openai-api-compatibility
            """
            pass
        elif custom_llm_provider == "palm":
            raise ValueError(
                "Palm was decommisioned on October 2024. Please use the `gemini/` route for Gemini Google AI Studio Models. Announcement: https://ai.google.dev/palm_docs/palm?hl=en"
            )
        elif custom_llm_provider == "vertex_ai_beta" or custom_llm_provider == "gemini":
            vertex_ai_project = (

                optional_params.pop("vertex_project", None)
                or optional_params.pop("vertex_ai_project", None)
                or litellm.vertex_project
                or get_secret("VERTEXAI_PROJECT")
            )
            vertex_ai_locati
…[8629 chars omitted]…
formation import AnthropicBatchesConfig
from .chat.transformation import AnthropicConfig

__all__ = ["AnthropicBatchesConfig", "AnthropicConfig"]


def get_anthropic_config(
    url_route: str,
) -> Union[Type[AnthropicBatchesConfig], Type[AnthropicConfig]]:
    if "messages/batches" in url_route and "results" in url_route:
        return AnthropicBatchesConfig
    else:
        return AnthropicConfig

or litellm.vertex_location
                or get_secret("VERTEXAI_LOCATION")
            )
            vertex_credentials = (
                optional_params.pop("vertex_credentials", None)
                or optional_params.pop("vertex_ai_credentials", None)
                or get_secret("VERTEXAI_CREDENTIALS")
            )

            api_base = api_base or litellm.api_base or get_secret("VERTEXAI_API_BASE")

            new_params = safe_deep_copy(optional_params or {})

            model_route = get_vertex_ai_model_route(
                model=model, litellm_params=litellm_params
            )

            if model_route == VertexAIModelRoute.PARTNER_MODELS:
                model_response = vertex_partner_models_chat_completion.completion(
                    model=model,
                    messages=messages,
                    model_response=model_response,
  
…[8629 chars omitted]…
          raise AnthropicError(
                message="max_tokens is required for Anthropic /v1/messages API",
                status_code=400,
            )
        ####### get required params for all anthropic messages requests ######
        verbose_logger.debug(f"TRANSFORMATION DEBUG - Messages: {messages}")
        anthropic_messages_request: AnthropicMessagesRequest = AnthropicMessagesRequest(

route = CohereModelInfo.get_cohere_route(model)
        if route == "v2":
            return litellm.CohereV2ChatConfig()
        return litellm.CohereChatConfig()

    @staticmethod
    def _get_langgraph_config() -> BaseConfig:
        """Get LangGraph config."""
        from litellm.llms.langgraph.chat.transformation import LangGraphConfig

        return LangGraphConfig()

    @staticmethod
    def get_provider_chat_config(  # noqa: PLR0915
        model: str, provider: LlmProviders
    ) -> Optional[BaseConfig]:
        """
        Returns the provider config for a given provider.

        Uses O(1) dictionary lookup for fast provider resolution.
        """
        # Check JSON providers FIRST (these override standard mappings)
        from litellm.llms.openai_like.dynamic_config import create_config_class
        from litellm.llms.openai_like.json_loader import JSONProv
…[8630 chars omitted]…
tool_call_args(self) -> bool:
        """
        Check if the tool call block so far has been an empty string
        """
        args = ""
        # if text content block -> skip
        if len(self.content_blocks) == 0:
            return False

        if (
            self.content_blocks[0]["delta"]["type"] == "text_delta"
            or self.content_blocks[0]["delta"]["type"] == "thinking_delta"

presence_penalty (float, optional): It is used to penalize new tokens based on their existence in the text so far.
        frequency_penalty: It is used to penalize new tokens based on their frequency in the text so far.
        logit_bias (dict, optional): Used to modify the probability of specific tokens appearing in the completion.
        user (str, optional):  A unique identifier representing your end-user. This can help the LLM provider to monitor and detect abuse.
        logprobs (bool, optional): Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message
        top_logprobs (int, optional): An integer between 0 and 5 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if th
…[8629 chars omitted]…
s n=1 as a default value
                    continue  # skip this param
                if (
                    k == "max_retries"
                ):  # TODO: This is a patch. We support max retries for OpenAI, Azure. For non OpenAI LLMs we need to add support for max retries

                    continue  # skip this param
                # Always keeps this in elif code blocks
                else:

413:    extra_headers: Optional[dict] = None,
1033:    extra_headers: Optional[dict] = None,
1187:    headers = kwargs.get("headers", None) or extra_headers
4615:    extra_headers = kwargs.get("extra_headers", None)
4616:    headers = kwargs.get("headers", None) or extra_headers
5474:                headers = extra_headers
6283:    extra_headers = kwargs.get("extra_headers", None)
6524:    headers: Optional[dict] = None,
6532:    extra_headers = kwargs.get("extra_headers", None)
1457:        optional_params = get_optional_params(
4668:    optional_params = get_optional_params_embeddings(
6315:    optional_params = get_optional_params_transcription(

413:    extra_headers: Optional[dict] = None,
558:        "extra_headers": extra_headers,
1033:    extra_headers: Optional[dict] = None,
1081:        extra_headers (dict, optional): Additional headers to include in the request.
1164:       
…[2247 chars omitted]…
eaders=extra_headers,
6714:            if extra_headers:
6715:                optional_params["extra_headers"] = extra_headers
6782:            extra_headers=extra_headers,
6834:            extra_headers=headers,
6882:            extra_headers=extra_headers,
6923:            extra_headers=extra_headers,
6949:            extra_headers=extra_headers,
1625:            headers = headers or litellm.headers

"functions": functions,
            "function_call": function_call,
            "temperature": temperature,
            "top_p": top_p,
            "n": n,
            "stream": stream,
            "stream_options": stream_options,
            "stop": stop,
            "max_tokens": max_tokens,
            "max_completion_tokens": max_completion_tokens,
            "modalities": modalities,
            "prediction": prediction,

            "audio": audio,
            "presence_penalty": presence_penalty,
            "frequency_penalty": frequency_penalty,
            "logit_bias": logit_bias,
            "user": user,
            # params to identify the model
            "model": model,
            "custom_llm_provider": custom_llm_provider,
            "response_format": response_format,
            "seed": seed,
            "tools": tools,
            "tool_choice": too
…[8628 chars omitted]…
                 else False
                        ),
                    )
                )
            else:
                optional_params = litellm.MistralConfig().map_openai_params(
                    model=model,
                    non_default_params=non_default_params,
                    optional_params=optional_params,
                    drop_params=(
                        drop_params

tools=tools,
                tool_choice=tool_choice,
                parallel_tool_calls=parallel_tool_calls,
                logprobs=logprobs,
                top_logprobs=top_logprobs,
                deployment_id=deployment_id,
                reasoning_effort=reasoning_effort,
                verbosity=verbosity,
                safety_identifier=safety_identifier,
                service_tier=service_tier,
                base_url=base_url,
                api_version=api_version,

                api_key=api_key,
                model_list=model_list,
                extra_headers=extra_headers,
                thinking=thinking,
                web_search_options=web_search_options,
                shared_session=shared_session,
                **kwargs,
            )
    api_base = kwargs.get("api_base", None)
    mock_response: Optional[MOCK_RESPONSE_TYPE] =
…[8629 chars omitted]…
s,
                    api_key=api_key,
                    api_base=api_base,
                    api_version=api_version,
                    dynamic_params=dynamic_params,
                    azure_ad_token=azure_ad_token,
                    model_response=model_response,
1187:    headers = kwargs.get("headers", None) or extra_headers
4616:    headers = kwargs.get("headers", None) or extra_headers

7764:    def _build_provider_config_map() -> dict[LlmProviders, tuple[Callable, bool]]:
7765-        """Build the provider-to-config mapping dictionary.
7766-
7767-        Returns a dict mapping provider to (factory_function, needs_model_parameter).
7768-        This avoids expensive inspect.signature() calls at runtime.
7769-        """
7770-        return {
7771-            # Most common providers first for readability
7772-            # Format: (factory_function, needs_model_parameter: bool)
7773-            LlmProviders.OPENAI: (lambda: litellm.OpenAIGPTConfig(), False),
7774-            LlmProviders.ANTHROPIC: (lambda: litellm.AnthropicConfig(), False),
7775-            LlmProviders.AZURE: (

7776-                lambda model: ProviderConfigManager._get_azure_config(model),
7777-                True,
7778-            ),
7779-            LlmProviders.AZURE_AI: (
7780-              
…[8629 chars omitted]…
litellm.VertexAIAnthropicConfig()
litellm/_lazy_imports_registry.py:176:    "VertexAIAnthropicConfig",
litellm/_lazy_imports_registry.py:712:    "VertexAIAnthropicConfig": (
litellm/_lazy_imports_registry.py:714:        "VertexAIAnthropicConfig",
litellm/__init__.py:1348:    from .llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation import VertexAIAnthropicConfig as VertexAIAnthropicConfig

LlmProviders.NSCALE: (lambda: litellm.NscaleConfig(), False),
            LlmProviders.HEROKU: (lambda: litellm.HerokuChatConfig(), False),
            LlmProviders.OCI: (lambda: litellm.OCIChatConfig(), False),
            LlmProviders.HYPERBOLIC: (lambda: litellm.HyperbolicChatConfig(), False),
            LlmProviders.OVHCLOUD: (lambda: litellm.OVHCloudChatConfig(), False),
            LlmProviders.AMAZON_NOVA: (lambda: litellm.AmazonNovaChatConfig(), False),
            LlmProviders.LANGGRAPH: (
                lambda: ProviderConfigManager._get_langgraph_config(),
                False,
            ),
        }

    @staticmethod
    def _get_azure_config(model: str) -> BaseConfig:
        """Get Azure config based on model type."""
        if litellm.AzureOpenAIO1Config().is_o_series_model(model=model):
            return litellm.AzureOpenAIO1Config()
        if lite
…[6354 chars omitted]…
ult["output_config"]["effort"] == "high"
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1578:        "output_config": {
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1597:    assert "output_config" in result
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:1598:    assert result["output_config"]["effort"] == "low"

from enum import Enum
from typing import Any, Dict, Iterable, List, Optional, Union

from pydantic import BaseModel, ConfigDict
from typing_extensions import Literal, Required, TypedDict

from .openai import (
    ChatCompletionCachedContent,
    ChatCompletionRedactedThinkingBlock,
    ChatCompletionThinkingBlock,
)

class AnthropicMessagesToolChoice(TypedDict, total=False):
    type: Required[Literal["auto", "any", "tool", "none"]]
    name: str
    disable_parallel_tool_use: bool  # default is false


AnthropicInputSchema = TypedDict(
    "AnthropicInputSchema",
    {
        "type": Optional[str],
        "properties": Optional[dict],
        "additionalProperties": Optional[bool],
        "required": Optional[List[str]],
        "$defs": Optional[Dict],
        "strict": Optional[bool],
    },
    total=False,
)


class AnthropicOutputSchema(TypedDict, total=False):
    type: Re
…[4665 chars omitted]…
ls
161-            function = tool.get("function", {})
162-            if isinstance(function, dict):
163-                function_allowed_callers = function.get("allowed_callers", None)
164-                if function_allowed_callers and isinstance(function_allowed_callers, list):
165-                    if "code_execution_20250825" in function_allowed_callers:
166-                        return True

)  # support region-based pricing for bedrock

        ### TIMEOUT LOGIC ###
        timeout = timeout or kwargs.get("request_timeout", 600) or 600
        # set timeout for 10 minutes by default
        if isinstance(timeout, httpx.Timeout) and not supports_httpx_timeout(
            custom_llm_provider
        ):
            timeout = timeout.read or 600  # default 10 min timeout
        elif not isinstance(timeout, httpx.Timeout):
            timeout = float(timeout)  # type: ignore

        ### REGISTER CUSTOM MODEL PRICING -- IF GIVEN ###
        if input_cost_per_token is not None and output_cost_per_token is not None:
            litellm.register_model(
                {
                    f"{custom_llm_provider}/{model}": {
                        "input_cost_per_token": input_cost_per_token,
                        "output_cost_per_token": output_cost_per_token,

…[8629 chars omitted]…
rams=optional_params,
            model=model,
            drop_params=(
                drop_params
                if drop_params is not None and isinstance(drop_params, bool)
                else False
            ),
        )
    elif custom_llm_provider == "vertex_ai" and (
        model in litellm.vertex_chat_models
        or model in litellm.vertex_code_chat_models
3836:    extra_headers=None,

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:21:class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, VertexBase):
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:22:    def validate_anthropic_messages_environment(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:108:    def transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:112:        anthropic_messages_optional_request_params: Dict,
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:116:        anthropic_messages_request = super().transform_anthropic_messages_request(
litellm/llms/vertex_ai/vertex_ai_partner_mod
…[1366 chars omitted]…
erModelsAnthropicMessagesConfig()
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_anthropic_image_url_handling.py
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py

for k, v in optional_params.items()
            if k not in self.aws_authentication_params
        }
        filtered_params = self._normalize_bedrock_tool_search_tools(filtered_params)
        
        _anthropic_request = AnthropicConfig.transform_request(
            self,
            model=model,
            messages=messages,
            optional_params=filtered_params, 
            litellm_params=litellm_params,
            headers=headers,

        )

        _anthropic_request.pop("model", None)
        _anthropic_request.pop("stream", None)
        # Bedrock Invoke doesn't support output_format parameter
        _anthropic_request.pop("output_format", None)
        if "anthropic_version" not in _anthropic_request:
            _anthropic_request["anthropic_version"] = self.anthropic_version

        tools = optional_params.get("tools")
        tool_search_used = sel
…[8628 chars omitted]…
er-Sent Events expected by Anthropic clients.
        return self.bedrock_sse_wrapper(
            completion_stream=completion_stream,
            litellm_logging_obj=litellm_logging_obj,
            request_body=request_body,
        )

    async def bedrock_sse_wrapper(
        self,
        completion_stream: AsyncIterator[
            Union[bytes, GenericStreamingChunk, ModelResponseStream, dict]

custom-beta -> body: None output keys ['max_tokens', 'messages'] headers unaffected
beta-one,beta-two -> body: None output keys ['max_tokens', 'messages'] headers unaffected
optional {'max_tokens': 50, 'output_config': {'effort': 'high'}} -> {'output_config': {'effort': 'high'}, 'anthropic_beta': ['effort-2025-11-24']}
optional {'max_tokens': 50, 'output_format': {'type': 'json_schema', 'schema': {'type': 'object'}}} -> {}

{'extra_headers': {'anthropic-beta': 'one'}}
{'extra_headers': {'anthropic-beta': 'one,two'}}

params {'extra_headers': {'anthropic-beta': 'custom-beta'}}
data {'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'Hi'}]}], 'extra_headers': {'anthropic-beta': 'custom-beta'}, 'max_tokens': 8192}

179-        for tool in tools:
180-            # Check top-level input_examples
181-            input_examples = tool.get("input_examples", None)
182-            if input_examples and isinstance(input_examples, list) and len(input_examples) > 0:
183-                return True
184-            
185-            # Check function.input_examples for OpenAI format tools
186-            function = tool.get("function", {})
187-            if isinstance(function, dict):
188-                function_input_examples = function.get("input_examples", None)
189-                if function_input_examples and isinstance(function_input_examples, list) and len(function_input_examples) > 0:
190-                    return True

191-        
192-        return False
193-    
194:    def is_effort_used(self, optional_params: Optional[dict], model: Optional[str] = None) -> bool:
195-        """
196-        Ch
…[6745 chars omitted]…
    # Effort parameter uses a separate beta header
357-        if effort_used:
358-            from litellm.types.llms.anthropic import ANTHROPIC_EFFORT_BETA_HEADER
359-            betas.add(ANTHROPIC_EFFORT_BETA_HEADER)
360-        
361-        # Code execution tool uses a separate beta header
362-        if code_execution_tool_used:
363-            betas.add("code-execution-2025-08-25")
364-

1256:    non_default_params = get_non_default_completion_params(kwargs=kwargs)
1460:        processed_non_default_params = pre_process_non_default_params(
4654:    non_default_params = {
6286:    non_default_params = get_non_default_transcription_params(kwargs)
413:    extra_headers: Optional[dict] = None,
558:        "extra_headers": extra_headers,
1033:    extra_headers: Optional[dict] = None,
1081:        extra_headers (dict, optional): Additional headers to include in the request.
1164:                extra_headers=extra_headers,
1187:    headers = kwargs.get("headers", None) or extra_headers
1200:    if extra_headers is not None:
1201:        headers.update(extra_headers)

1627:            if extra_headers is not None:
1628:                optional_params["extra_headers"] = extra_headers
1740:            if extra_headers is not None:
1741:                optional_params["extra_hea
…[4202 chars omitted]…
           "functions": functions,
            "function_call": function_call,
            "temperature": temperature,
            "top_p": top_p,
            "n": n,
            "stream": stream,
            "stream_options": stream_options,
            "stop": stop,
            "max_tokens": max_tokens,
            "max_completion_tokens": max_completion_tokens,
            "modalities": modalities,

text_completion = kwargs.get("text_completion", False)
    atext_completion = kwargs.get("atext_completion", False)
    ### ASYNC CALLS ###
    acompletion = kwargs.get("acompletion", False)
    client = kwargs.get("client", None)
    ### Admin Controls ###
    no_log = kwargs.get("no-log", False)
    ### PROMPT MANAGEMENT ###
    prompt_id = cast(Optional[str], kwargs.get("prompt_id", None))
    prompt_variables = cast(Optional[dict], kwargs.get("prompt_variables", None))
    ### COPY MESSAGES ### - related issue https://github.com/BerriAI/litellm/discussions/4489
    messages = get_completion_messages(

        messages=messages,
        ensure_alternating_roles=ensure_alternating_roles or False,
        user_continue_message=user_continue_message,
        assistant_continue_message=assistant_continue_message,
    )
    ######## end of unpacking kwargs ###########
    non_default
…[8207 chars omitted]…
un_mock_completion(
litellm/utils.py-9140-    mock_response: Optional[Any],
litellm/utils.py-9141-    mock_tool_calls: Optional[Any],
litellm/utils.py-9142-    mock_timeout: Optional[Any],
litellm/utils.py-9143-) -> bool:
litellm/utils.py-9144-    if mock_response or mock_tool_calls or mock_timeout:
litellm/utils.py-9145-        return True
litellm/utils.py-9146-    return False
litellm/utils.py-9147-

from unittest.mock import patch

import pytest

from litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.experimental_pass_through.transformation import (
    VertexAIPartnerModelsAnthropicMessagesConfig,
)


def test_validate_environment_uses_vertex_ai_location():
    config = VertexAIPartnerModelsAnthropicMessagesConfig()
    headers = {}

    litellm_params = {
        "vertex_ai_project": "test-project",
        "vertex_ai_location": "europe-west1",
        "vertex_credentials": "{}",
    }
    optional_params = {}

    with patch.object(
        config, "_ensure_access_token", return_value=("token", "test-project")
    ), patch.object(
        config, "get_complete_vertex_url", return_value="https://mock-url"
    ) as mock_get_url:
        config.validate_anthropic_messages_environment(
            headers=headers,
            model="claude-3-sonnet",
            messages=[]
…[8630 chars omitted]…
ms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:362:    headers2 = {"anthropic-beta": PROMPT_CACHING_BETA_HEADER}
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:364:    assert "anthropic-beta" not in headers2, "Header should be removed if no supported values remain"

litellm/llms/bedrock/chat/converse_transformation.py:70:    get_anthropic_beta_from_headers,
litellm/llms/bedrock/chat/converse_transformation.py:1065:            user_betas = get_anthropic_beta_from_headers(headers)
litellm/llms/bedrock/chat/invoke_transformations/anthropic_claude3_transformation.py:9:from litellm.llms.bedrock.common_utils import get_anthropic_beta_from_headers
litellm/llms/bedrock/chat/invoke_transformations/anthropic_claude3_transformation.py:116:        beta_set = set(get_anthropic_beta_from_headers(headers))
litellm/llms/bedrock/common_utils.py:820:def get_anthropic_beta_from_headers(headers: dict) -> List[str]:
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:30:    get_anthropic_beta_from_headers,
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:465:        beta_set = set(get_anthro
…[8628 chars omitted]…
ansformations/anthropic_claude3_transformation.py:30:    get_anthropic_beta_from_headers,
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:465:        beta_set = set(get_anthropic_beta_from_headers(headers))
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:3:from litellm.anthropic_beta_headers_manager import (

if final_prompt_value:
                custom_prompt_dict[model]["final_prompt_value"] = final_prompt_value
            if bos_token:
                custom_prompt_dict[model]["bos_token"] = bos_token
            if eos_token:
                custom_prompt_dict[model]["eos_token"] = eos_token

        if kwargs.get("model_file_id_mapping"):
            messages = update_messages_with_model_file_ids(
                messages=messages,
                model_id=kwargs.get("model_info", {}).get("id", None),
                model_file_id_mapping=cast(

                    Dict[str, Dict[str, str]], kwargs.get("model_file_id_mapping")
                ),
            )

        provider_config: Optional[BaseConfig] = None
        if custom_llm_provider is not None and custom_llm_provider in [
            provider.value for provider in LlmProviders
        ]:
            provider_co
…[8630 chars omitted]…
okens,
1141-                modalities=modalities,
1142-                prediction=prediction,
1143-                audio=audio,
1144-                presence_penalty=presence_penalty,
1145-                frequency_penalty=frequency_penalty,
1146-                logit_bias=logit_bias,
1147-                user=user,
1148-                response_format=response_format,
1149-                seed=seed,

27-2877-        "response_format": None,
28-2878-        "temperature": None,  # openai defaults this to 0
29-2879-        "timestamp_granularities": None,
30-2880-    }
31-2881-
32:2882-    non_default_params = {
33-2883-        k: v
34-2884-        for k, v in passed_params.items()
35-2885-        if (k in default_params and v != default_params[k])
36-2886-    }
37-2887-    optional_params = {}
38-2888-

39-2889-    ## raise exception if non-default value passed for non-openai/azure embedding calls
40-2890-    def _check_valid_arg(supported_params):
41:2891-        if len(non_default_params.keys()) > 0:
42:2892-            keys = list(non_default_params.keys())
43-2893-            for k in keys:
44-2894-                if (
45-2895-                    drop_params is True or litellm.drop_params is True
46-2896-                ) and k not in supported_params:  # drop the unsupported no
…[8630 chars omitted]…
s,
3849-):
3850-    passed_params = locals().copy()
3851-    special_params = passed_params.pop("kwargs")
3852-    non_default_params = pre_process_non_default_params(
3853-        passed_params=passed_params,
3854-        special_params=special_params,
3855-        custom_llm_provider=custom_llm_provider,
3856-        additional_drop_params=additional_drop_params,
3857-        model=model,
3858-    )

tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_messages_config.py:37:    """Test that web search tool adds the required beta header for Vertex AI /v1/messages requests"""
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:41:    """Test that web search tool adds the required beta header for Vertex AI completion requests"""
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:56:    # Generate headers with is_vertex_request=True
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:60:        is_vertex_request=True,
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner
…[2620 chars omitted]…
ertex_request": True
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:152:    """Test that structured output beta headers are NOT added for Vertex AI requests"""
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:167:        'is_vertex_request': True

json_mode=json_mode,
        )

    def completion(
        self,
        model: str,
        messages: list,
        api_base: str,
        custom_llm_provider: str,
        custom_prompt_dict: dict,
        model_response: ModelResponse,
        print_verbose: Callable,

        encoding,
        api_key,
        logging_obj,
        optional_params: dict,
        timeout: Union[float, httpx.Timeout],
        litellm_params: dict,
        acompletion=None,
        logger_fn=None,
        headers={},
        client=None,
    ):
        from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
        from litellm.utils import ProviderConfigManager

        optional_params = copy.deepcopy(optional_params)
        stream = optional_params.pop("stream", None)
        json_mode: bool = optional_params.pop("json_mode", False)
        is_vertex_request: bool =
…[6813 chars omitted]…
 = streaming_response
        self.response_iterator = self.streaming_response
        self.content_blocks: List[ContentBlockDelta] = []
        self.tool_index = -1
        self.json_mode = json_mode
        # Generate response ID once per stream to match OpenAI-compatible behavior
litellm/integrations/lunary.py:122:                template_id = extra.pop("extra_headers", {}).get("Template-Id", None)

{
  "description": "Unsupported Anthropic beta headers for each provider. Headers listed here will be dropped. Headers not listed are passed through as-is.",
  "anthropic": [],
  "azure_ai": [],
  "bedrock_converse": [
    "prompt-caching-scope-2026-01-05",
    "bash_20250124",
    "bash_20241022",
    "text_editor_20250124",
    "text_editor_20241022",
    "compact-2026-01-12",
    "advanced-tool-use-2025-11-20",

    "web-fetch-2025-09-10",
    "code-execution-2025-08-25",
    "skills-2025-10-02",
    "files-api-2025-04-14"
  ],
  "bedrock": [
    "advanced-tool-use-2025-11-20",
    "prompt-caching-scope-2026-01-05",
    "structured-outputs-2025-11-13",
    "web-fetch-2025-09-10",
    "code-execution-2025-08-25",
    "skills-2025-10-02",
    "files-api-2025-04-14"
  ],
  "vertex_ai": [
    "prompt-caching-scope-2026-01-05"
  ]
}
    Azure Anthropic configuration that extends Anthropi
…[3901 chars omitted]…
fig(
litellm/llms/vertex_ai/batches/transformation.py:43:            outputConfig=output_config,
litellm/llms/vertex_ai/batches/transformation.py:152:        output_config = response.get("outputConfig")
litellm/llms/vertex_ai/batches/transformation.py:153:        if output_config is None:
litellm/llms/vertex_ai/batches/transformation.py:156:        gcs_destination = output_config.get("gcsDestination")

litellm/anthropic_interface/messages/__init__.py:22:    AnthropicMessagesResponse,
litellm/anthropic_interface/messages/__init__.py:42:) -> Union[AnthropicMessagesResponse, AsyncIterator]:
litellm/anthropic_interface/messages/__init__.py:102:    AnthropicMessagesResponse,
litellm/anthropic_interface/messages/__init__.py:104:    Coroutine[Any, Any, Union[AnthropicMessagesResponse, AsyncIterator[Any]]],
litellm/integrations/custom_logger.py:574:            response: Response from model (AnthropicMessagesResponse or AsyncIterator)
litellm/integrations/custom_logger.py:640:            (AnthropicMessagesResponse with final answer)
litellm/integrations/websearch_interception/transformation.py:35:            response: Model response (dict or AnthropicMessagesResponse)
litellm/litellm_core_utils/prompt_templates/factory.py:918:) -> AnthropicMessagesImageParam:
litellm/litellm_core_utils/promp
…[8630 chars omitted]…
odels/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:290:        # Verify that output_format was removed (fixes the "Extra inputs are not permitted" error)
tests/test_litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/test_vertex_ai_partner_models_anthropic_transformation.py:291:        assert "output_format" not in final_data, "output_format should be removed for VertexAI"

):
        try:
            import vertexai

            from litellm.llms.anthropic.chat import AnthropicChatCompletion
            from litellm.llms.codestral.completion.handler import (
                CodestralTextCompletion,
            )
            from litellm.llms.openai_like.chat.handler import OpenAILikeChatHandler
            from litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import (
                VertexLLM,
            )

        except Exception as e:
            raise VertexAIError(
                status_code=400,
                message=f"""vertexai import failed please run `pip install -U "google-cloud-aiplatform>=1.38"`. Got error: {e}""",
            )

        if not (
            hasattr(vertexai, "preview") or hasattr(vertexai.preview, "language_models")
        ):
            raise VertexAIError(
                status_code=400,
       
…[8629 chars omitted]…
ng_used,
            input_examples_used=input_examples_used,
            effort_used=effort_used,
            code_execution_tool_used=code_execution_tool_used,
            container_with_skills_used=container_with_skills_used,
        )

        headers = {**headers, **anthropic_headers}

        return headers

    @staticmethod
    def get_api_base(api_base: Optional[str] = None) -> Optional[str]:

## COMPLETION CALL
                response = azure_chat_completions.completion(
                    model=model,
                    messages=messages,
                    headers=headers,
                    api_key=api_key,
                    api_base=api_base,
                    api_version=api_version,
                    api_type=api_type,
                    dynamic_params=dynamic_params,
                    azure_ad_token=azure_ad_token,
                    azure_ad_token_provider=azure_ad_token_provider,

                    model_response=model_response,
                    print_verbose=print_verbose,
                    optional_params=optional_params,
                    litellm_params=litellm_params,
                    logger_fn=logger_fn,
                    logging_obj=logging,
                    acompletion=acompletion,
                    timeout=t
…[8629 chars omitted]…
ent
                aspeech=aspeech,
                litellm_params=litellm_params_dict,
            )
    elif custom_llm_provider == "elevenlabs":
        from litellm.llms.elevenlabs.text_to_speech.transformation import (
            ElevenLabsTextToSpeechConfig,
        )

        if text_to_speech_provider_config is None:
            text_to_speech_provider_config = ElevenLabsTextToSpeechConfig()

)

    def _check_valid_arg(supported_params: List[str]):
        """
        Check if the params passed to completion() are supported by the provider

        Args:
            supported_params: List[str] - supported params from the litellm config
        """
        verbose_logger.info(
            f"\nLiteLLM completion() model= {model}; provider = {custom_llm_provider}"
        )

        verbose_logger.debug(
            f"\nLiteLLM: Params passed to completion() {passed_params}"
        )
        verbose_logger.debug(
            f"\nLiteLLM: Non-Default params passed to completion() {non_default_params}"
        )
        unsupported_params = {}
        for k in non_default_params.keys():
            if k not in supported_params:
                if k == "user" or k == "stream_options" or k == "stream":
                    continue
                if k == "n" and n == 1: 
…[8629 chars omitted]…
llm.AmazonAnthropicConfig().map_openai_params(
                    non_default_params=non_default_params,
                    optional_params=optional_params,
                    model=model,
                    drop_params=(
                        drop_params
                        if drop_params is not None and isinstance(drop_params, bool)
                        else False
                    ),

"""
Interface for Anthropic's messages API

Use this to call LLMs in Anthropic /messages Request/Response format

This is an __init__.py file to allow the following interface

- litellm.messages.acreate
- litellm.messages.create

"""

from typing import Any, AsyncIterator, Coroutine, Dict, List, Optional, Union

from litellm.llms.anthropic.experimental_pass_through.messages.handler import (
    anthropic_messages as _async_anthropic_messages,
)
from litellm.llms.anthropic.experimental_pass_through.messages.handler import (
    anthropic_messages_handler as _sync_anthropic_messages,
)
from litellm.types.llms.anthropic_messages.anthropic_response import (
    AnthropicMessagesResponse,
)


async def acreate(
    max_tokens: int,
    messages: List[Dict],
    model: str,
    metadata: Optional[Dict] = None,
    stop_sequences: Optional[List[str]] = None,
    stream: Optional[bool] = Fals
…[5691 chars omitted]…
/invoke_transformations/anthropic_claude3_transformation.py:66:    def validate_anthropic_messages_environment(
litellm/llms/custom_httpx/llm_http_handler.py:1833:        ) = anthropic_messages_provider_config.validate_anthropic_messages_environment(
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py:22:    def validate_anthropic_messages_environment(

)

        if client is None or not isinstance(client, AsyncHTTPHandler):
            async_httpx_client = get_async_httpx_client(
                llm_provider=litellm.LlmProviders.ANTHROPIC
            )
        else:
            async_httpx_client = client

        # Prepare headers
        kwargs = kwargs or {}
        provider_specific_header = cast(

            Optional[litellm.types.utils.ProviderSpecificHeader],
            kwargs.get("provider_specific_header", None),
        )
        provider_specific_headers = ProviderSpecificHeaderUtils.get_provider_specific_headers(
            provider_specific_header=provider_specific_header,
            custom_llm_provider=custom_llm_provider,
        )
        forwarded_headers = kwargs.get("headers", None)
        # Also check for extra_headers in kwargs (from config or direct calls)
        extra_headers_from_kwargs = kwargs
…[8629 chars omitted]…
s a no-op and we just return the headers
        """
        return headers, None

    def get_async_streaming_response_iterator(
        self,
        model: str,
        httpx_response: httpx.Response,
        request_body: dict,
        litellm_logging_obj: LiteLLMLoggingObj,
    ) -> AsyncIterator:
        raise NotImplementedError("Subclasses must implement this method")

    def get_error_class(

408:    def transform_anthropic_messages_request(
409-        self,
410-        model: str,
411-        messages: List[Dict],
412-        anthropic_messages_optional_request_params: Dict,
413-        litellm_params: GenericLiteLLMParams,
414-        headers: dict,
415-    ) -> Dict:
416-        anthropic_messages_request = AnthropicMessagesConfig.transform_anthropic_messages_request(
417-            self=self,
418-            model=model,
419-            messages=messages,

420-            anthropic_messages_optional_request_params=anthropic_messages_optional_request_params,
421-            litellm_params=litellm_params,
422-            headers=headers,
423-        )
424-        #########################################################
425-        ############## BEDROCK Invoke SPECIFIC TRANSFORMATION ###
426-        #########################################################
427-
428-   
…[6937 chars omitted]…
ponse(
        **{
            "content": [{"text": mock_response, "type": "text"}],
            "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
            "model": "claude-sonnet-4-20250514",
            "role": "assistant",
            "stop_reason": "end_turn",
            "stop_sequence": None,
            "type": "message",
            "usage": {"input_tokens": 2095, "output_tokens": 503},
        }
    )

litellm/proxy/agent_endpoints/a2a_endpoints.py:236:                if key in all_litellm_params:
litellm/proxy/pass_through_endpoints/pass_through_endpoints.py:489:        for k in all_litellm_params:
litellm/types/utils.py:2840:all_litellm_params = (
526:    "extra_headers",
574:    "extra_headers": None,
3836:    extra_headers=None,
489:OPENAI_CHAT_COMPLETION_PARAMS = [

"functions",
    "function_call",
    "temperature",
    "temperature",
    "top_p",
    "n",
    "stream",
    "stream_options",
    "stop",
    "max_completion_tokens",
    "modalities",
    "prediction",

    "audio",
    "max_tokens",
    "presence_penalty",
    "frequency_penalty",
    "logit_bias",
    "user",
    "request_timeout",
    "api_base",
    "api_version",
    "api_key",
    "deployment_id",
    "organization",
    "base_url",
    "default_headers",
    "timeout",
    "response_format",
    "seed",
    "tools",
    "tool_choice",
    "max_retries",
    "parallel_tool_calls",
    "logprobs",
    "top_logprobs",
    "reasoning_effort",
    "extra_headers",
    "thinking",
    "web_search_options",
    "service_tier",
]

OPENAI_TRANSCRIPTION_PARAMS = [
    "language",
    "response_format",
    "timestamp_granularities",
]

OPENAI_EMBEDDING_PARAMS = ["dimensions", "en
…[4523 chars omitted]…
ams = locals()
2866-
2867-    passed_params.pop("OPENAI_TRANSCRIPTION_PARAMS")
2868-    custom_llm_provider = passed_params.pop("custom_llm_provider")
2869-    drop_params = passed_params.pop("drop_params")
2870-    special_params = passed_params.pop("kwargs")
2871-    for k, v in special_params.items():
2872-        passed_params[k] = v
2873-
2874-    default_params = {
2875-        "language": None,

drop_params is True or litellm.drop_params is True
                ) and k not in supported_params:  # drop the unsupported non-default values
                    non_default_params.pop(k, None)
                elif k not in supported_params:
                    raise UnsupportedParamsError(
                        status_code=500,
                        message=f"Setting user/encoding format is not supported by {custom_llm_provider}. To drop it from the call, set `litellm.drop_params = True`.",
                    )
            return non_default_params

    provider_config: Optional[BaseAudioTranscriptionConfig] = None
    if custom_llm_provider is not None:

        provider_config = ProviderConfigManager.get_provider_audio_transcription_config(
            model=model,
            provider=LlmProviders(custom_llm_provider),
        )

    if custom_llm_provider
…[7985 chars omitted]…
200-    files: dict  # file uploads
3201-    content: Any  # raw content
3202-
3203-
3204-class ProviderSpecificHeader(TypedDict):
3205-    custom_llm_provider: str
3206:    extra_headers: dict
3207-
3208-
3209-class SelectTokenizerResponse(TypedDict):
3210-    type: Literal["openai_tokenizer", "huggingface_tokenizer"]
3211-    tokenizer: Any
3212-
3213-
3214-class LiteLLMFineTuningJob(FineTuningJob):

3708:def pre_process_optional_params(
3709-    passed_params: dict, non_default_params: dict, custom_llm_provider: str
3710-) -> dict:
3711-    """For .completion(), preprocess optional params"""
3712-    optional_params: Dict = {}
3713-
3714-    common_auth_dict = litellm.common_cloud_provider_auth_params
3715-    if custom_llm_provider in common_auth_dict["providers"]:
3716-        """
3717-        Check if params = ["project", "region_name", "token"]
3718-        and correctly translate for = ["azure", "vertex_ai", "watsonx", "aws"]
3719-        """

3720-        if custom_llm_provider == "azure":
3721-            optional_params = litellm.AzureOpenAIConfig().map_special_auth_params(
3722-                non_default_params=passed_params, optional_params=optional_params
3723-            )
3724-        elif custom_llm_provider == "bedrock":
3725-            optional_params = (
3726-  
…[8629 chars omitted]…
   or "tools" in non_default_params
3747-    ):
3748-        if (
3749-            custom_llm_provider == "ollama"
3750-            and custom_llm_provider != "text-completion-openai"
3751-            and custom_llm_provider != "azure"
3752-            and custom_llm_provider != "vertex_ai"
3753-            and custom_llm_provider != "anyscale"
3754-            and custom_llm_provider != "together_ai"

for k, v in passed_params.items()
            if (
                k != "model"
                and k != "custom_llm_provider"
                and k != "api_version"
                and k != "drop_params"
                and k != "allowed_openai_params"
                and k != "additional_drop_params"
                and k not in additional_endpoint_specific_params
                and k in default_param_values
                and v != default_param_values[k]
                and _should_drop_param(

                    k=k, additional_drop_params=additional_drop_params
                )
                is False
            )
        }

        return non_default_params

    @staticmethod
    def embedding_pre_process_non_default_params(
        passed_params: dict,
        special_params: dict,
        custom_llm_provider: str,
        additional_drop_params: Optional[List[
…[6386 chars omitted]…
rue
914-            _input_schema["properties"] = {}
915-        else:
916-            _input_schema.update(cast(AnthropicInputSchema, json_schema))
917-
918-        _tool = AnthropicMessagesTool(
919-            name=RESPONSE_FORMAT_TOOL_NAME, input_schema=_input_schema
920-        )
921-        return _tool
922-
923-    def translate_system_message(
924-        self, messages: List[AllMessageValues]

............                                                             [100%]
12 passed, 2 warnings in 1.85s

assert result_non_vertex["anthropic-beta"] == "structured-outputs-2025-11-13", \
        f"Expected 'structured-outputs-2025-11-13', got: {result_non_vertex.get('anthropic-beta')}"


def test_vertex_ai_claude_sonnet_4_5_structured_output_fix():
    """
    Test fix for issue #18625: Claude Sonnet 4.5 on VertexAI should use tool-based 
    structured outputs instead of output_format parameter.
    
    This test verifies that:
    1. Claude Sonnet 4.5 uses tool-based structured outputs on VertexAI
    2. output_format parameter is removed from the final request

    3. The fix prevents "Extra inputs are not permitted" error
    """
    config = VertexAIAnthropicConfig()
    
    # Test data matching the issue report
    response_format = {
        "type": "json_schema",
        "json_schema": {
            "name": "questions",
            "strict": True,
            "schema": {
    
…[6493 chars omitted]…
sform_response_for_json_mode(
        self,
        json_mode: Optional[bool],
        tool_calls: List[ChatCompletionToolCallChunk],
    ) -> Optional[LitellmMessage]:
        _message: Optional[LitellmMessage] = None
        if json_mode is True and len(tool_calls) == 1:
            # check if tool name is the default tool name
            json_mode_content_str: Optional[str] = None
            if (

7cfe11e base
7cfe11e base

output_config {'output_config': {'effort': 'high'}}
output_format {'output_format': {'type': 'json_schema', 'schema': {'type': 'object'}}}

# Add compact header if any compact edits exist
        if has_compact:
            beta_set.add(ANTHROPIC_BETA_HEADER_VALUES.COMPACT_2026_01_12.value)
        
        # Add context management header if any other edits exist
        if has_other:
            beta_set.add(ANTHROPIC_BETA_HEADER_VALUES.CONTEXT_MANAGEMENT_2025_06_27.value)

    @staticmethod
    def _get_anthropic_beta_values(headers: Optional[dict]) -> set[str]:
        """Return the beta values from an Anthropic header mapping."""
        beta_values: set[str] = set()

        if not isinstance(headers, dict):
            return beta_values

        for header_name, header_value in headers.items():
            if not isinstance(header_name, str) or header_name.lower() != "anthropic-beta":
                continue
            if isinstance(header_value, str):
                values = header_value.split(",")
     
…[3729 chars omitted]…
_ai"
            )
        )
        if beta_set:
            data["anthropic_beta"] = sorted(beta_set)
        else:
            data.pop("anthropic_beta", None)

        self._remove_anthropic_beta_header(headers)
        return data

    def map_openai_params(
        self,
        non_default_params: dict,
        optional_params: dict,
        model: str,
        drop_params: bool,
    ) -> dict:

Validate the environment for the request
        """
        if "Authorization" not in headers:
            vertex_ai_project = VertexBase.get_vertex_ai_project(litellm_params)
            vertex_credentials = VertexBase.get_vertex_ai_credentials(litellm_params)
            vertex_ai_location = VertexBase.get_vertex_ai_location(litellm_params)

            access_token, project_id = self._ensure_access_token(
                credentials=vertex_credentials,
                project_id=vertex_ai_project,
                custom_llm_provider="vertex_ai",
            )

            headers["Authorization"] = f"Bearer {access_token}"

            api_base = self.get_complete_vertex_url(
                custom_api_base=api_base,
                vertex_location=vertex_ai_location,
                vertex_project=vertex_ai_project,
                project_id=project_id,
                p
…[6473 chars omitted]…
            {"anthropic-beta": anthropic_messages_optional_request_params.get("anthropic_beta")}
            )
        )
        beta_values = set(
            filter_and_transform_beta_headers(
                beta_headers=list(beta_values), provider="vertex_ai"
            )
        )
        if beta_values:
            anthropic_messages_request["anthropic_beta"] = sorted(beta_values)
        else:

else:
            anthropic_messages_request.pop("anthropic_beta", None)

        self._remove_anthropic_beta_header(headers)
        return anthropic_messages_request
from typing import Any, Dict, List, Optional, Tuple

from litellm.anthropic_beta_headers_manager import (
    update_headers_with_filtered_beta,
)
from litellm.llms.anthropic.common_utils import AnthropicModelInfo
from litellm.llms.anthropic.experimental_pass_through.messages.transformation import (

    AnthropicMessagesConfig,
)
from litellm.types.llms.anthropic import (
    ANTHROPIC_BETA_HEADER_VALUES,
    ANTHROPIC_HOSTED_TOOLS,
)
from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
from litellm.types.llms.vertex_ai import VertexPartnerProvider
from litellm.types.router import GenericLiteLLMParams

from ....vertex_llm_base import VertexBase


class VertexAIPartnerModelsAnthropicMe
…[3489 chars omitted]…
          else:
                continue

            beta_values.update(
                value.strip()
                for value in values
                if isinstance(value, str) and value.strip()
            )
        return beta_values

    @staticmethod
    def _remove_anthropic_beta_header(headers: dict) -> None:
        """Remove beta flags from HTTP headers after moving them into the body."""

custom-beta -> body: ['custom-beta'] headers: {} body keys: ['anthropic_beta', 'max_tokens', 'messages']
beta-one,beta-two -> body: ['beta-one', 'beta-two'] headers: {} body keys: ['anthropic_beta', 'max_tokens', 'messages']
output config body: {'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'Hi'}]}], 'max_tokens': 50, 'context_management': {'edits': [{'type': 'compact_20260112'}]}, 'anthropic_beta': ['compact-2026-01-12', 'effort-2025-11-24', 'user-beta']} headers: {}
Traceback (most recent call last):
  File "<stdin>", line 17, in <module>
  File "/repo/litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py", line 224, in transform_anthropic_messages_request
    filter_and_transform_beta_headers(
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
NameError: name 'filter_and_transform_beta_headers' is not defined

custom-beta -> body: ['custom-beta'] headers: {}
beta-one,beta-two -> body: ['beta-one', 'beta-two'] headers: {}
output config body: {'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'Hi'}]}], 'max_tokens': 50, 'context_management': {'edits': [{'type': 'compact_20260112'}]}, 'anthropic_beta': ['compact-2026-01-12', 'effort-2025-11-24', 'user-beta']} headers: {}
messages body: {'messages': [{'role': 'user', 'content': 'Hello'}], 'max_tokens': 50, 'context_management': {'edits': [{'type': 'compact_20260112'}]}, 'anthropic_version': 'vertex-2023-10-16', 'anthropic_beta': ['compact-2026-01-12', 'effort-2025-11-24', 'second-user-beta', 'user-beta']} headers: {}

............                                                             [100%]
12 passed, 2 warnings in 1.42s
/usr/local/bin/python: No module named ruff

model: str,
    # Optional OpenAI params: see https://platform.openai.com/docs/api-reference/chat/create
    messages: List = [],
    timeout: Optional[Union[float, str, httpx.Timeout]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    n: Optional[int] = None,
    stream: Optional[bool] = None,
    stream_options: Optional[dict] = None,
    stop=None,
    max_completion_tokens: Optional[int] = None,
    max_tokens: Optional[int] = None,

    modalities: Optional[List[ChatCompletionModality]] = None,
    prediction: Optional[ChatCompletionPredictionContentParam] = None,
    audio: Optional[ChatCompletionAudioParam] = None,
    presence_penalty: Optional[float] = None,
    frequency_penalty: Optional[float] = None,
    logit_bias: Optional[dict] = None,
    user: Optional[str] = None,
    # openai v1.0+ new params
    reasoning_effort: Optional[

…[7077 chars omitted]…
url",
    "default_headers",
    "timeout",
    "response_format",
    "seed",
    "tools",
    "tool_choice",
    "max_retries",
    "parallel_tool_calls",
    "logprobs",
    "top_logprobs",
    "reasoning_effort",
    "extra_headers",
    "thinking",
    "web_search_options",
    "service_tier",
]

OPENAI_TRANSCRIPTION_PARAMS = [
    "language",
    "response_format",
    "timestamp_granularities",

input custom-beta
beta body ['custom-beta', 'effort-2025-11-24']
tool [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'value': {'type': 'string'}}}}]
output fields {}
http beta None
input custom-one,custom-two
beta body ['custom-one', 'custom-two', 'effort-2025-11-24']
tool [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'value': {'type': 'string'}}}}]
output fields {}
http beta None

def transform_request(
        self,
        model: str,
        messages: List[AllMessageValues],
        optional_params: dict,
        litellm_params: dict,
        headers: dict,
    ) -> dict:
        # Vertex does not support these Anthropic request fields. Strip them before
        # the shared transformer runs, and make sure beta flags are not added to
        # HTTP headers (Vertex carries them in the request body instead).
        vertex_optional_params = {

            key: value
            for key, value in optional_params.items()
            if key not in {"output_config", "output_format"}
        }
        vertex_optional_params["is_vertex_request"] = True
        data = super().transform_request(
            model=model,
            messages=messages,
            optional_params=vertex_optional_params,
            litellm_params=litellm_params,
            headers=
…[1551 chars omitted]…
 import ANTHROPIC_BETA_HEADER_VALUES

            beta_set.add(ANTHROPIC_BETA_HEADER_VALUES.WEB_SEARCH_2025_03_05.value)
        if tool_search_used:
            beta_set.add("tool-search-tool-2025-10-19")  # Vertex requires this beta for tool search

        # Add context_management beta headers (compact and/or context-management)
        context_management = optional_params.get("context_management")

{'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'x'}]}], 'max_tokens': 5}
{'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'x'}]}], 'max_tokens': 5}

==================================== ERRORS ====================================
_ ERROR collecting tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py _
ImportError while importing test module '/repo/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/local/lib/python3.12/importlib/__init__.py:90: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py:6: in <module>
    from fastapi.testclient import TestClient
E   ModuleNotFoundError: No module named 'fastapi'
=========================== short test summary info ============================

ERROR tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
2 warnings, 1 error in 4.25s

[flake8]
ignore =
    # The following ignores can be removed when formatting using black
    W191,W291,W292,W293,W391,W504
    E101,E111,E114,E116,E117,E121,E122,E123,E124,E125,E126,E127,E128,E129,E131,
    E201,E202,E221,E222,E225,E226,E231,E241,E251,E252,E261,E265,E271,E272,E275,
    E301,E302,E303,E305,E306,
    # line break before binary operator
    W503,
    # inline comment should start with '# '
    E262,
    # too many leading '#' for block comment

    E266,
    # multiple imports on one line
    E401,
    # module level import not at top of file
    E402,
    # Line too long (82 > 79 characters)
    E501,
    # comparison to None should be 'if cond is None:'
    E711,
    # comparison to True should be 'if cond is True:' or 'if cond:'
    E712,
    # do not compare types, for exact checks use `is` / `is not`, for instance checks use `isinstance()`
    E721,
    # do not use 
…[8629 chars omitted]…
ers(
+                beta_headers=list(beta_set), provider="vertex_ai"
+            )
+        )
         if beta_set:
-            data["anthropic_beta"] = list(beta_set)
-        
+            data["anthropic_beta"] = sorted(beta_set)
+        else:
+            data.pop("anthropic_beta", None)
+
+        self._remove_anthropic_beta_header(headers)
         return data
 
     def map_openai_params(

validated headers web-search-2025-03-05
body beta ['web-search-2025-03-05'] sent headers None

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
37 132     The class `VertexAIAnthropicConfig` provides configuration for the VertexAI's Anthropic API interface. Below are the parameters:
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py

550-        "deployment_id": deployment_id,
551-        "base_url": base_url,
552-        "api_version": api_version,
553-        "api_key": api_key,
554-        "model_list": model_list,
555-        "reasoning_effort": reasoning_effort,
556-        "safety_identifier": safety_identifier,
557-        "service_tier": service_tier,
558:        "extra_headers": extra_headers,
559-        "acompletion": True,  # assuming this is a required parameter
560-        "thinking": thinking,
561-        "web_search_options": web_search_options,

562-        "shared_session": shared_session,
563-    }
564-    if custom_llm_provider is None:
565-        _, custom_llm_provider, _, _ = get_llm_provider(
566-            model=model,
--
1620-
1621-            azure_ad_token_provider = litellm_params.get(
1622-                "azure_ad_token_provider", None
1623-            )
1624-
1625-            header
…[1394 chars omitted]…
           if extra_headers is not None:
1526                 optional_params["extra_headers"] = extra_headers
1918             if extra_headers is not None:
1919                 headers.update(extra_headers)
2361                 extra_headers=headers,
2431                     extra_headers=headers,
2710                     extra_headers=headers,  # Use merged headers instead of original extra_headers

validated beta: web-search-2025-03-05,my-user-beta
body beta: ['my-user-beta', 'web-search-2025-03-05']
http beta: None

tests/test_litellm/llms/anthropic/chat/guardrail_translation/test_anthropic_guardrail_handler.py
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_handler.py
tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
tests/test_litellm/llms/anthropic/chat/__pycache__/test_anthropic_chat_transformation.cpython-312-pytest-9.2.0.pyc
tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_anthropic_experimental_pass_through_adapters_transformation.py
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_experimental_pass_through_messages_handler.py
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_messages_structured_outputs.py
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_content_after_stop_reason.py
tests/test_litellm/llms/anthropic/experimental_pass_t
…[974 chars omitted]…
_anthropic_headers(
tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py:27:def test_oauth_integration_in_validate_environment():

tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py:28:    """Test 2: OAuth integration in AnthropicConfig validate_environment"""
tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py:34:    updated_headers = config.validate_environment(

# Test without tool search
    tools = [
        {
            "type": "function",
            "function": {"name": "get_weather"}
        }
    ]
    assert config.is_tool_search_used(tools) is False


def test_tool_search_bm25_detection():
    """Test that tool search BM25 tools are properly detected"""

    from litellm.llms.anthropic.common_utils import AnthropicModelInfo
    
    config = AnthropicModelInfo()
    
    # Test with tool search BM25 tool
    tools = [
        {
            "type": "tool_search_tool_bm25_20251119",
            "name": "tool_search_tool_bm25"
        }
    ]
    assert config.is_tool_search_used(tools) is True


def test_tool_search_beta_header():
    """Test that tool search beta header is automatically added"""
    from litellm.llms.anthropic.common_utils import AnthropicModelInfo
    
    config = AnthropicModelInfo()
    
    headers = con
…[2973 chars omitted]…
 in headers["anthropic-beta"]


def test_input_examples_in_function_field():
    """Test that input_examples in function field is also preserved."""
    config = AnthropicConfig()
    
    # Test with function.input_examples
    tool = {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather information",
            "parameters": {

diff --git a/litellm/llms/anthropic/common_utils.py b/litellm/llms/anthropic/common_utils.py
index cb23d21..28770b1 100644
--- a/litellm/llms/anthropic/common_utils.py
+++ b/litellm/llms/anthropic/common_utils.py
@@ -376,12 +376,19 @@ class AnthropicModelInfo(BaseLLMModelInfo):
         if user_anthropic_beta_headers is not None:
             betas.update(user_anthropic_beta_headers)
 
-        # Don't send any beta headers to Vertex, except web search which is required
         if is_vertex_request is True:
-            # Vertex AI requires web search beta header for web search to work
+            # Preserve user beta values while adding the web-search beta when

+            # needed. Vertex's request transformer moves these values into the
+            # body and removes the header before the HTTP request is sent.
+            vertex_betas = set(user_anthropic_beta_headers or [])
 
…[8629 chars omitted]…
ers(
+                beta_headers=list(beta_set), provider="vertex_ai"
+            )
+        )
         if beta_set:
-            data["anthropic_beta"] = list(beta_set)
-        
+            data["anthropic_beta"] = sorted(beta_set)
+        else:
+            data.pop("anthropic_beta", None)
+
+        self._remove_anthropic_beta_header(headers)
         return data
 
     def map_openai_params(

"""
Tool Search Beta Header Configuration

Reference: https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool
"""

from typing import Dict

from litellm.types.utils import LlmProviders

# Tool search beta header values
TOOL_SEARCH_BETA_HEADER_ANTHROPIC = "advanced-tool-use-2025-11-20"

TOOL_SEARCH_BETA_HEADER_VERTEX = "tool-search-tool-2025-10-19"
TOOL_SEARCH_BETA_HEADER_BEDROCK = "tool-search-tool-2025-10-19"


# Mapping of custom_llm_provider -> tool search beta header
TOOL_SEARCH_BETA_HEADER_BY_PROVIDER: Dict[str, str] = {
    LlmProviders.ANTHROPIC.value: TOOL_SEARCH_BETA_HEADER_ANTHROPIC,
    LlmProviders.AZURE.value: TOOL_SEARCH_BETA_HEADER_ANTHROPIC,
    LlmProviders.AZURE_AI.value: TOOL_SEARCH_BETA_HEADER_ANTHROPIC,
    LlmProviders.VERTEX_AI.value: TOOL_SEARCH_BETA_HEADER_VERTEX,
    LlmProviders.VERTEX_AI_BETA.value: TOOL_SEARCH_BETA_HEADER_VERTEX,
    
…[1778 chars omitted]…
       input_examples_used = self.is_input_examples_used(tools)
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:461:            anthropic_model_info.is_programmatic_tool_calling_used(tools)
litellm/llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py:463:        input_examples_used = anthropic_model_info.is_input_examples_used(tools)

.........................                                                [100%]
25 passed, 2 warnings in 1.56s

/usr/local/bin/python: No module named pyflakes
parsed litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
parsed litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py
parsed litellm/llms/anthropic/common_utils.py

152:        auto_betas = self.get_anthropic_beta_list(
153-            model=model,
154-            optional_params=optional_params,
155-            computer_tool_used=self.is_computer_tool_used(tools),
156-            prompt_caching_set=self.is_cache_control_set(messages),
157-            file_id_used=self.is_file_id_used(messages),
158-            mcp_server_used=self.is_mcp_server_used(optional_params.get("mcp_servers")),
159-        )
160-
161-        beta_set = set(auto_betas)
162-        # Preserve user-provided beta values from both header sources. The extra
163-        # headers also appear in optional_params, while headers contains values

164-        # prepared by the Anthropic environment validator (e.g. web search).

Vertex Anthropic beta/optional-parameter reproducer passed
.........................                                                [100%]
25 passed, 2 warnings in 1.43s

optional {'max_tokens': 100, 'tool_choice': {'name': 'json_tool_call', 'type': 'tool'}, 'tools': [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'a': {'type': 'string'}}}}], 'json_mode': True}
body {'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'x'}]}], 'max_tokens': 100, 'tool_choice': {'name': 'json_tool_call', 'type': 'tool'}, 'tools': [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'a': {'type': 'string'}}}}], 'json_mode': True}

235-                return f"{api_base}/v1/projects/{vertex_project}/locations/{vertex_location}/publishers/anthropic/models/{model}:rawPredict"
236-
237:    def get_complete_vertex_url(
238-        self,
239-        custom_api_base: Optional[str],
240-        vertex_location: Optional[str],
241-        vertex_project: Optional[str],
242-        project_id: str,
243-        partner: VertexPartnerProvider,
244-        stream: Optional[bool],
245-        model: str,
246-    ) -> str:

247-        # Use get_vertex_region to handle global-only models
248-        resolved_location = self.get_vertex_region(vertex_location, model)
249-        api_base = self.get_api_base(
250-            api_base=custom_api_base, vertex_location=resolved_location
251-        )
252-        default_api_base = VertexBase.create_vertex_url(
253-            vertex_location=resolved_location,
254-            vertex
…[1767 chars omitted]…
params.
712-
713-        Args:
714-            litellm_params: Dictionary containing Vertex AI parameters
715-
716-        Returns:
717-            Vertex AI project ID or None
718-        """
719-        return (
720-            litellm_params.get("vertex_project")
721-            or litellm_params.get("vertex_ai_project")
litellm/llms/vertex_ai/vertex_llm_base.py:237:    def get_complete_vertex_url(

# What is this?
## Handler file for calling claude-3 on vertex ai
from typing import Any, List, Optional

import httpx

import litellm
from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
from litellm.types.llms.openai import AllMessageValues
from litellm.types.utils import ModelResponse

from ....anthropic.chat.transformation import AnthropicConfig

class VertexAIError(Exception):
    def __init__(self, status_code, message):
        self.status_code = status_code
        self.message = message
        self.request = httpx.Request(
            method="POST", url=" https://cloud.google.com/vertex-ai/"
        )
        self.response = httpx.Response(status_code=status_code, request=self.request)
        super().__init__(
            self.message
        )  # Call the base class constructor with the parameters it needs


class VertexAIAnthropicConfig(AnthropicConfig
…[8629 chars omitted]…
lter_and_transform_beta_headers(
                beta_headers=list(beta_values), provider="vertex_ai"
            )
        )
        if beta_values:
            anthropic_messages_request["anthropic_beta"] = sorted(beta_values)
        else:
            anthropic_messages_request.pop("anthropic_beta", None)

        self._remove_anthropic_beta_header(headers)
        return anthropic_messages_request

93:    def is_computer_tool_used(
104:    def is_web_search_tool_used(
218:    def is_code_execution_tool_used(self, tools: Optional[List]) -> bool:
274:    def get_anthropic_beta_list(

327-class AnthropicMessagesUserMessageParam(TypedDict, total=False):
328-    role: Required[Literal["user"]]
329-    content: Required[Union[str, Iterable[AnthropicMessagesUserMessageValues]]]
330-
331-
332-class AnthropicMetadata(TypedDict, total=False):
333-    user_id: str
334-
335-
336-class AnthropicSystemMessageContent(TypedDict, total=False):
337-    type: str
338-    text: str

339-    cache_control: Optional[Union[dict, ChatCompletionCachedContent]]
340-
341-
342-AllAnthropicMessageValues = Union[
343-    AnthropicMessagesUserMessageParam, AnthopicMessagesAssistantMessageParam
344-]
345-
346-
347:class AnthropicMessagesRequestOptionalParams(TypedDict, total=False):
348-    max_tokens: Optional[int]
349-    metadata: Optional[Union[AnthropicMetadata, Dict]]
350-    stop_sequences: Optional[List[str]]
351-    stream: Optional[bool]
352-    system: Optional[Union[str, List]]
353-
…[8629 chars omitted]…
lways uses tool-based structured outputs.
214-        VertexAI doesn't support the output_format parameter, so we force all models
215-        to use the tool-based approach for structured outputs.
216-        """
217-        # Temporarily override model name to force tool-based approach
218-        # This ensures Claude Sonnet 4.5 uses tools instead of output_format
219-        original_model = model

152:        auto_betas = self.get_anthropic_beta_list(
153-            model=model,
154-            optional_params=vertex_optional_params,
155-            computer_tool_used=self.is_computer_tool_used(tools),
156-            prompt_caching_set=self.is_cache_control_set(messages),
157-            file_id_used=self.is_file_id_used(messages),
158-            mcp_server_used=self.is_mcp_server_used(optional_params.get("mcp_servers")),
159-        )
160-

AnthropicConfig {'tool_choice': {'name': 'json_tool_call', 'type': 'tool'}, 'tools': [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'a': {'type': 'string'}}}}], 'json_mode': True}
body fields dict_keys(['model', 'messages', 'tool_choice', 'tools', 'json_mode', 'max_tokens'])
VertexAIAnthropicConfig {'tool_choice': {'name': 'json_tool_call', 'type': 'tool'}, 'tools': [{'name': 'json_tool_call', 'input_schema': {'type': 'object', 'properties': {'a': {'type': 'string'}}}}], 'json_mode': True}
body fields dict_keys(['messages', 'tool_choice', 'tools', 'json_mode', 'max_tokens'])

from typing import Any, Dict, List, Optional, Tuple

from litellm.anthropic_beta_headers_manager import (
    filter_and_transform_beta_headers,
    update_headers_with_filtered_beta,
)
from litellm.llms.anthropic.common_utils import AnthropicModelInfo
from litellm.llms.anthropic.experimental_pass_through.messages.transformation import (
    AnthropicMessagesConfig,
)
from litellm.types.llms.anthropic import (
    ANTHROPIC_BETA_HEADER_VALUES,

    ANTHROPIC_HOSTED_TOOLS,
)
from litellm.types.llms.anthropic_tool_search import get_tool_search_beta_header
from litellm.types.llms.vertex_ai import VertexPartnerProvider
from litellm.types.router import GenericLiteLLMParams

from ....vertex_llm_base import VertexBase


class VertexAIPartnerModelsAnthropicMessagesConfig(AnthropicMessagesConfig, VertexBase):
    def validate_anthropic_messages_environment(
        self,
        headers: dict,

…[3099 chars omitted]…
r header_name, header_value in headers.items():
            if not isinstance(header_name, str) or header_name.lower() != "anthropic-beta":
                continue
            if isinstance(header_value, str):
                values = header_value.split(",")
            elif isinstance(header_value, (list, tuple, set)):
                values = header_value
            else:
                continue

litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/transformation.py
37 132     The class `VertexAIAnthropicConfig` provides configuration for the VertexAI's Anthropic API interface. Below are the parameters:
litellm/llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py
litellm/llms/anthropic/common_utils.py
189 126                 if function_input_examples and isinstance(function_input_examples, list) and len(function_input_examples) > 0:
411 213                 message="Missing Anthropic API Key - A call is being made to anthropic but no key is set either in the environment variables or via params. Please set `ANTHROPIC_API_KEY` in your environment vars",
483 147                 "ANTHROPIC_API_BASE or ANTHROPIC_API_KEY is not set. Please set the environment variable, to query Anthropic's `/models` endpoint."

if not isinstance(headers, dict):
            return beta_values

        for header_name, header_value in headers.items():
            if (
                not isinstance(header_name, str)
                or header_name.lower() != "anthropic-beta"
            ):
                continue
            if isinstance(header_value, str):
                values = header_value.split(",")
            elif isinstance(header_value, (list, tuple, set)):

                values = header_value
            else:
                continue

            beta_values.update(
                value.strip()
                for value in values
                if isinstance(value, str) and value.strip()
            )
        return beta_values

    @staticmethod
    def _remove_anthropic_beta_header(headers: dict) -> None:
        """Remove beta flags from HTTP headers after moving them into the body."
…[8629 chars omitted]…
 dict,
        model: str,
        drop_params: bool,
    ) -> dict:
        """
        Override parent method to ensure VertexAI always uses tool-based structured outputs.
        VertexAI doesn't support the output_format parameter, so we force all models
        to use the tool-based approach for structured outputs.
        """
        # Temporarily override model name to force tool-based approach