feat(bedrock): add support for bedrock-mantle endpoint (Claude Mythos Preview) (#26196)

* add anthropic.claude-mythos-preview to model_prices_and_context_window.json * add mantle route to bedrock common_utils: route detection, chat config, messages config dispatch * add AmazonMantleConfig for bedrock/mantle /chat/completions endpoint * add AmazonMantleMessagesConfig for bedrock/mantle /messages endpoint * register AmazonMantleMessagesConfig in __init__.py and lazy imports registry * add unit tests for bedrock mantle route and config dispatch * add e2e tests for bedrock mantle: URL, body, SigV4 header, region routing
2026-08-21 04:24:51 +00:00 · 2026-04-21 15:41:58 -07:00
parent 8a4a775b1b
commit a302613eb5
9 changed files with 462 additions and 0 deletions
@@ -1502,6 +1502,9 @@ if TYPE_CHECKING:
    from .llms.bedrock.messages.invoke_transformations.anthropic_claude3_transformation import (
        AmazonAnthropicClaudeMessagesConfig as AmazonAnthropicClaudeMessagesConfig,
    )
+    from .llms.bedrock.messages.mantle_transformation import (
+        AmazonMantleMessagesConfig as AmazonMantleMessagesConfig,
+    )
    from .llms.together_ai.chat import TogetherAIConfig as TogetherAIConfig
    from .llms.nlp_cloud.chat.handler import NLPCloudConfig as NLPCloudConfig
    from .llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import (
@@ -171,6 +171,7 @@ LLM_CONFIG_NAMES = (
    "CohereChatConfig",
    "AnthropicMessagesConfig",
    "AmazonAnthropicClaudeMessagesConfig",
+    "AmazonMantleMessagesConfig",
    "TogetherAIConfig",
    "NLPCloudConfig",
    "VertexGeminiConfig",
@@ -715,6 +716,10 @@ _LLM_CONFIGS_IMPORT_MAP = {
        ".llms.bedrock.messages.invoke_transformations.anthropic_claude3_transformation",
        "AmazonAnthropicClaudeMessagesConfig",
    ),
+    "AmazonMantleMessagesConfig": (
+        ".llms.bedrock.messages.mantle_transformation",
+        "AmazonMantleMessagesConfig",
+    ),
    "TogetherAIConfig": (".llms.together_ai.chat", "TogetherAIConfig"),
    "NLPCloudConfig": (".llms.nlp_cloud.chat.handler", "NLPCloudConfig"),
    "VertexGeminiConfig": (
@@ -0,0 +1,91 @@
+"""
+Transformation for Bedrock Mantle (Claude Mythos Preview)
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-mythos-preview.html
+
+The bedrock-mantle endpoint uses the Anthropic Messages API format but is served
+at a different endpoint (bedrock-mantle.{region}.api.aws) with AWS SigV4 auth.
+"""
+
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from litellm.llms.bedrock.chat.invoke_transformations.anthropic_claude3_transformation import (
+    AmazonAnthropicClaudeConfig,
+)
+from litellm.types.llms.openai import AllMessageValues
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
+
+    LiteLLMLoggingObj = _LiteLLMLoggingObj
+else:
+    LiteLLMLoggingObj = Any
+
+MANTLE_ENDPOINT_TEMPLATE = "https://bedrock-mantle.{region}.api.aws/v1/messages"
+
+
+class AmazonMantleConfig(AmazonAnthropicClaudeConfig):
+    """
+    Config for the bedrock-mantle endpoint (Claude Mythos Preview).
+
+    Uses the Anthropic Messages API format with AWS SigV4 auth, but at a
+    different endpoint from bedrock-runtime. Model ID goes in the request body.
+
+    Usage: model="bedrock/mantle/anthropic.claude-mythos-preview"
+    """
+
+    def get_complete_url(
+        self,
+        api_base: Optional[str],
+        api_key: Optional[str],
+        model: str,
+        optional_params: dict,
+        litellm_params: dict,
+        stream: Optional[bool] = None,
+    ) -> str:
+        region = self._get_aws_region_name(optional_params=optional_params, model=model)
+        return MANTLE_ENDPOINT_TEMPLATE.format(region=region)
+
+    def transform_request(
+        self,
+        model: str,
+        messages: List[AllMessageValues],
+        optional_params: dict,
+        litellm_params: dict,
+        headers: dict,
+    ) -> dict:
+        # Strip the "mantle/" routing prefix to get the real model ID
+        model_id = model.replace("mantle/", "", 1)
+
+        request = self._build_bedrock_anthropic_request_base(
+            model=model_id,
+            messages=messages,
+            optional_params=optional_params,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+        # The parent strips "model" from the body (Invoke API puts it in URL).
+        # The mantle endpoint (Messages API) requires "model" in the body.
+        request["model"] = model_id
+        return request
+
+    async def async_transform_request(
+        self,
+        model: str,
+        messages: List[AllMessageValues],
+        optional_params: dict,
+        litellm_params: dict,
+        headers: dict,
+    ) -> dict:
+        model_id = model.replace("mantle/", "", 1)
+
+        request = self._build_bedrock_anthropic_request_base(
+            model=model_id,
+            messages=messages,
+            optional_params=optional_params,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+        await self._async_convert_document_url_sources_to_base64(request)
+        request["model"] = model_id
+        return request
@@ -696,6 +696,7 @@ class BedrockModelInfo(BaseLLMModelInfo):
        "agentcore",
        "async_invoke",
        "openai",
+        "mantle",
    ]:
        """
        Get the bedrock route for the given model.
@@ -710,6 +711,7 @@ class BedrockModelInfo(BaseLLMModelInfo):
                "agentcore",
                "async_invoke",
                "openai",
+                "mantle",
            ],
        ] = {
            "invoke/": "invoke",
@@ -719,6 +721,7 @@ class BedrockModelInfo(BaseLLMModelInfo):
            "agentcore/": "agentcore",
            "async_invoke/": "async_invoke",
            "openai/": "openai",
+            "mantle/": "mantle",
        }

        # Check explicit routes first
@@ -770,6 +773,13 @@ class BedrockModelInfo(BaseLLMModelInfo):
        """
        return "agentcore/" in model

+    @staticmethod
+    def _explicit_mantle_route(model: str) -> bool:
+        """
+        Check if the model is an explicit mantle route (bedrock-mantle endpoint).
+        """
+        return "mantle/" in model
+
    @staticmethod
    def _explicit_converse_like_route(model: str) -> bool:
        """
@@ -809,6 +819,16 @@ class BedrockModelInfo(BaseLLMModelInfo):
        if BedrockModelInfo._explicit_converse_route(model):
            return None

+        #########################################################
+        # Mantle route uses the bedrock-mantle endpoint (not bedrock-runtime)
+        #########################################################
+        if BedrockModelInfo._explicit_mantle_route(model):
+            from litellm.llms.bedrock.messages.mantle_transformation import (
+                AmazonMantleMessagesConfig,
+            )
+
+            return AmazonMantleMessagesConfig()
+
        #########################################################
        # This goes through litellm.AmazonAnthropicClaude3MessagesConfig()
        # Since bedrock Invoke supports Native Anthropic Messages API
@@ -855,6 +875,12 @@ def get_bedrock_chat_config(model: str):
        )

        return AmazonAgentCoreConfig()
+    elif bedrock_route == "mantle":
+        from litellm.llms.bedrock.chat.mantle.transformation import (
+            AmazonMantleConfig,
+        )
+
+        return AmazonMantleConfig()

    # Handle provider-specific configs
    if bedrock_invoke_provider == "amazon":
@@ -0,0 +1,69 @@
+"""
+Transformation for Bedrock Mantle (Claude Mythos Preview) - /messages endpoint
+
+Inherits all Messages API request/response transformations from
+AmazonAnthropicClaudeMessagesConfig. Overrides only the URL and model-prefix
+stripping that are specific to the bedrock-mantle endpoint.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from litellm.llms.bedrock.messages.invoke_transformations.anthropic_claude3_transformation import (
+    AmazonAnthropicClaudeMessagesConfig,
+)
+from litellm.types.router import GenericLiteLLMParams
+
+if TYPE_CHECKING:
+    from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj
+
+    LiteLLMLoggingObj = _LiteLLMLoggingObj
+else:
+    LiteLLMLoggingObj = Any
+
+MANTLE_ENDPOINT_TEMPLATE = "https://bedrock-mantle.{region}.api.aws/v1/messages"
+
+
+class AmazonMantleMessagesConfig(AmazonAnthropicClaudeMessagesConfig):
+    """
+    Config for the bedrock-mantle /messages endpoint (Claude Mythos Preview).
+
+    The mantle endpoint uses the Anthropic Messages API format and requires the
+    model ID in the request body (unlike Bedrock Invoke which puts it in the URL).
+    """
+
+    def get_complete_url(
+        self,
+        api_base: Optional[str],
+        api_key: Optional[str],
+        model: str,
+        optional_params: dict,
+        litellm_params: dict,
+        stream: Optional[bool] = None,
+    ) -> str:
+        region = self._get_aws_region_name(optional_params=optional_params, model=model)
+        return MANTLE_ENDPOINT_TEMPLATE.format(region=region)
+
+    def transform_anthropic_messages_request(
+        self,
+        model: str,
+        messages: List[Dict],
+        anthropic_messages_optional_request_params: Dict,
+        litellm_params: GenericLiteLLMParams,
+        headers: dict,
+    ) -> Dict:
+        # Strip "mantle/" routing prefix to get the real model ID
+        model_id = model.replace("mantle/", "", 1)
+
+        request = super().transform_anthropic_messages_request(
+            model=model_id,
+            messages=messages,
+            anthropic_messages_optional_request_params=anthropic_messages_optional_request_params,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+
+        # Parent (AmazonAnthropicClaudeMessagesConfig) removes "model" from the
+        # body (Bedrock Invoke puts model in the URL). The mantle endpoint
+        # (Messages API) requires "model" in the request body.
+        request["model"] = model_id
+        return request
@@ -1148,6 +1148,20 @@
        "tool_use_system_prompt_tokens": 346,
        "supports_native_structured_output": true
    },
+    "anthropic.claude-mythos-preview": {
+        "input_cost_per_token": 0,
+        "output_cost_per_token": 0,
+        "litellm_provider": "bedrock",
+        "max_input_tokens": 1000000,
+        "max_output_tokens": 128000,
+        "max_tokens": 128000,
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_vision": true,
+        "supports_prompt_caching": false,
+        "supports_reasoning": true,
+        "supports_tool_choice": true
+    },
    "global.anthropic.claude-opus-4-7": {
        "cache_creation_input_token_cost": 6.25e-06,
        "cache_read_input_token_cost": 5e-07,
@@ -0,0 +1,149 @@
+"""
+E2E tests for Bedrock Mantle (Claude Mythos Preview) integration.
+
+Tests use a fake/mocked HTTP layer to verify the full request pipeline:
+- correct endpoint URL
+- model ID in the request body
+- AWS SigV4 Authorization header present
+- response parsing
+"""
+
+import json
+import os
+import sys
+from unittest.mock import MagicMock, patch
+
+import httpx
+import pytest
+
+sys.path.insert(0, os.path.abspath("../.."))
+
+import litellm
+from litellm.llms.custom_httpx.http_handler import HTTPHandler
+
+MODEL = "bedrock/mantle/anthropic.claude-mythos-preview"
+REGION = "us-east-1"
+EXPECTED_URL = f"https://bedrock-mantle.{REGION}.api.aws/v1/messages"
+
+FAKE_ANTHROPIC_RESPONSE = {
+    "id": "msg_fake123",
+    "type": "message",
+    "role": "assistant",
+    "model": "anthropic.claude-mythos-preview",
+    "content": [{"type": "text", "text": "Hello from Mythos!"}],
+    "stop_reason": "end_turn",
+    "stop_sequence": None,
+    "usage": {"input_tokens": 10, "output_tokens": 5},
+}
+
+
+def _make_fake_response(body: dict) -> MagicMock:
+    mock_resp = MagicMock(spec=httpx.Response)
+    mock_resp.status_code = 200
+    mock_resp.headers = httpx.Headers({"content-type": "application/json"})
+    mock_resp.text = json.dumps(body)
+    mock_resp.json.return_value = body
+    mock_resp.is_error = False
+    mock_resp.raise_for_status = MagicMock()
+    return mock_resp
+
+
+def test_mantle_request_url_and_body():
+    """Verify the correct URL is called and model appears in the request body."""
+    client = HTTPHandler()
+
+    with patch.object(
+        client, "post", return_value=_make_fake_response(FAKE_ANTHROPIC_RESPONSE)
+    ) as mock_post:
+        try:
+            litellm.completion(
+                model=MODEL,
+                messages=[{"role": "user", "content": "Hello"}],
+                max_tokens=50,
+                aws_region_name=REGION,
+                aws_access_key_id="AKIAIOSFODNN7EXAMPLE",
+                aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+                client=client,
+            )
+        except Exception:
+            pass  # response parsing may fail on mock; we only care about the outgoing call
+
+        mock_post.assert_called_once()
+        call_kwargs = mock_post.call_args.kwargs
+
+        # Correct endpoint
+        assert (
+            call_kwargs["url"] == EXPECTED_URL
+        ), f"Expected {EXPECTED_URL}, got {call_kwargs['url']}"
+
+        # Request body has model ID (without "mantle/" prefix)
+        raw_data = call_kwargs.get("data") or call_kwargs.get("json")
+        body = json.loads(raw_data) if isinstance(raw_data, (str, bytes)) else raw_data
+        assert (
+            body["model"] == "anthropic.claude-mythos-preview"
+        ), f"body['model'] = {body.get('model')}"
+        assert "messages" in body
+        assert body["max_tokens"] == 50
+
+        # AWS SigV4 Authorization header must be present
+        headers = call_kwargs.get("headers", {})
+        assert "Authorization" in headers, f"No Authorization header in {headers}"
+        assert headers["Authorization"].startswith(
+            "AWS4-HMAC-SHA256"
+        ), f"Expected SigV4 auth, got: {headers['Authorization'][:50]}"
+
+
+def test_mantle_request_does_not_include_mantle_prefix_in_body():
+    """Ensure 'mantle/' never leaks into the request body."""
+    client = HTTPHandler()
+
+    with patch.object(
+        client, "post", return_value=_make_fake_response(FAKE_ANTHROPIC_RESPONSE)
+    ) as mock_post:
+        try:
+            litellm.completion(
+                model=MODEL,
+                messages=[{"role": "user", "content": "Hi"}],
+                max_tokens=10,
+                aws_region_name=REGION,
+                aws_access_key_id="AKIAIOSFODNN7EXAMPLE",
+                aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+                client=client,
+            )
+        except Exception:
+            pass
+
+        call_kwargs = mock_post.call_args.kwargs
+        raw_data = call_kwargs.get("data") or call_kwargs.get("json")
+        body = json.loads(raw_data) if isinstance(raw_data, (str, bytes)) else raw_data
+
+        body_str = json.dumps(body)
+        assert "mantle/" not in body_str, f"'mantle/' leaked into body: {body_str}"
+
+
+def test_mantle_region_reflected_in_url():
+    """The region from aws_region_name must appear in the endpoint URL."""
+    client = HTTPHandler()
+
+    for region in ["us-east-1", "us-west-2", "eu-west-1"]:
+        with patch.object(
+            client, "post", return_value=_make_fake_response(FAKE_ANTHROPIC_RESPONSE)
+        ) as mock_post:
+            try:
+                litellm.completion(
+                    model=MODEL,
+                    messages=[{"role": "user", "content": "Hi"}],
+                    max_tokens=10,
+                    aws_region_name=region,
+                    aws_access_key_id="AKIAIOSFODNN7EXAMPLE",
+                    aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+                    client=client,
+                )
+            except Exception:
+                pass
+
+            call_kwargs = mock_post.call_args.kwargs
+            expected = f"https://bedrock-mantle.{region}.api.aws/v1/messages"
+            assert (
+                call_kwargs["url"] == expected
+            ), f"region={region}: expected URL {expected}, got {call_kwargs['url']}"
@@ -0,0 +1,105 @@
+"""
+Unit tests for the Bedrock Mantle (Claude Mythos Preview) integration.
+
+Tests cover route detection, URL construction, and config dispatch for both
+the /chat/completions and /messages endpoints.
+"""
+
+from litellm.llms.bedrock.common_utils import BedrockModelInfo, get_bedrock_chat_config
+from litellm.llms.bedrock.chat.mantle.transformation import AmazonMantleConfig
+from litellm.llms.bedrock.messages.mantle_transformation import (
+    AmazonMantleMessagesConfig,
+)
+
+
+def test_get_bedrock_route_mantle():
+    assert (
+        BedrockModelInfo.get_bedrock_route("mantle/anthropic.claude-mythos-preview")
+        == "mantle"
+    )
+
+
+def test_get_bedrock_route_mantle_does_not_match_other_routes():
+    assert (
+        BedrockModelInfo.get_bedrock_route("anthropic.claude-3-sonnet-20240229-v1:0")
+        != "mantle"
+    )
+    assert (
+        BedrockModelInfo.get_bedrock_route("converse/anthropic.claude-3-sonnet")
+        != "mantle"
+    )
+
+
+def test_explicit_mantle_route_flag():
+    assert (
+        BedrockModelInfo._explicit_mantle_route(
+            "mantle/anthropic.claude-mythos-preview"
+        )
+        is True
+    )
+    assert BedrockModelInfo._explicit_mantle_route("anthropic.claude-3-sonnet") is False
+    assert (
+        BedrockModelInfo._explicit_mantle_route("converse/anthropic.claude-3-sonnet")
+        is False
+    )
+
+
+def test_mantle_url_construction():
+    config = AmazonMantleConfig()
+    url = config.get_complete_url(
+        api_base=None,
+        api_key=None,
+        model="mantle/anthropic.claude-mythos-preview",
+        optional_params={"aws_region_name": "us-east-1"},
+        litellm_params={},
+    )
+    assert url == "https://bedrock-mantle.us-east-1.api.aws/v1/messages"
+
+
+def test_mantle_url_construction_different_region():
+    config = AmazonMantleConfig()
+    url = config.get_complete_url(
+        api_base=None,
+        api_key=None,
+        model="mantle/anthropic.claude-mythos-preview",
+        optional_params={"aws_region_name": "us-west-2"},
+        litellm_params={},
+    )
+    assert url == "https://bedrock-mantle.us-west-2.api.aws/v1/messages"
+
+
+def test_get_bedrock_chat_config_returns_mantle_config():
+    config = get_bedrock_chat_config("mantle/anthropic.claude-mythos-preview")
+    assert isinstance(config, AmazonMantleConfig)
+
+
+def test_get_bedrock_provider_config_for_messages_api_mantle():
+    config = BedrockModelInfo.get_bedrock_provider_config_for_messages_api(
+        "mantle/anthropic.claude-mythos-preview"
+    )
+    assert isinstance(config, AmazonMantleMessagesConfig)
+
+
+def test_mantle_messages_url_construction():
+    config = AmazonMantleMessagesConfig()
+    url = config.get_complete_url(
+        api_base=None,
+        api_key=None,
+        model="mantle/anthropic.claude-mythos-preview",
+        optional_params={"aws_region_name": "us-east-1"},
+        litellm_params={},
+    )
+    assert url == "https://bedrock-mantle.us-east-1.api.aws/v1/messages"
+
+
+def test_mantle_transform_request_strips_prefix_and_adds_model():
+    config = AmazonMantleConfig()
+    request = config.transform_request(
+        model="mantle/anthropic.claude-mythos-preview",
+        messages=[{"role": "user", "content": "Hello"}],
+        optional_params={"max_tokens": 100},
+        litellm_params={},
+        headers={},
+    )
+    assert request["model"] == "anthropic.claude-mythos-preview"
+    assert "mantle/" not in request["model"]