feat(bedrock): serve the OpenAI models on bedrock-runtime's native Responses API (internal copy of #38489)

litellm/__init__.py

@@ -1871,6 +1871,9 @@ def set_global_gitlab_config(config: Dict[str, Any]) -> None:
     from .llms.openrouter.responses.transformation import (
         OpenRouterResponsesAPIConfig as OpenRouterResponsesAPIConfig,
     )
+    from .llms.bedrock.responses.transformation import (
+        BedrockOpenAIResponsesConfig as BedrockOpenAIResponsesConfig,
+    )
     from .llms.bedrock_mantle.responses.transformation import (
         BedrockMantleResponsesAPIConfig as BedrockMantleResponsesAPIConfig,
     )

litellm/_lazy_imports_registry.py

@@ -245,6 +245,7 @@
     "PerplexityResponsesConfig",
     "DatabricksResponsesAPIConfig",
     "OpenRouterResponsesAPIConfig",
+    "BedrockOpenAIResponsesConfig",
     "BedrockMantleResponsesAPIConfig",
     "GoogleAIStudioInteractionsConfig",
     "VertexAIInteractionsConfig",
@@ -921,6 +922,10 @@
         "OpenAITextCompletionConfig",
     ),
     "GroqChatConfig": (".llms.groq.chat.transformation", "GroqChatConfig"),
+    "BedrockOpenAIResponsesConfig": (
+        ".llms.bedrock.responses.transformation",
+        "BedrockOpenAIResponsesConfig",
+    ),
     "BedrockMantleChatConfig": (
         ".llms.bedrock_mantle.chat.transformation",
         "BedrockMantleChatConfig",

litellm/llms/base_llm/responses/codex_compat.py

@@ -0,0 +1,154 @@
+"""Codex CLI wire-format quirks shared by the Responses API providers that need them.
+
+Codex sends history item types that api.openai.com accepts but other Responses
+backends reject with ``400 Invalid 'input': value did not match any expected
+variant``. Both Amazon Bedrock endpoints reject them:
+
+- ``bedrock-mantle.{region}.api.aws`` (verified against ``openai.gpt-5.6-sol``)
+- ``bedrock-runtime.{region}.amazonaws.com/openai/v1`` (same, verified separately)
+
+They are *history* items, so they only appear from the second turn of a session
+onward -- a first-turn request succeeds and hides the problem entirely.
+
+Codex also sends a ``web_search`` tool on every turn. api.openai.com runs that tool
+itself; a backend with no server-side tools rejects the whole request over it, so
+the same providers drop the tool types their backend does not accept.
+
+Both helpers are pure transforms that report what they rewrote or dropped; callers
+do their own logging, so each provider keeps its own wording.
+"""
+
+import json
+from collections.abc import Mapping, Sequence
+from typing import Final
+
+from typing_extensions import ReadOnly, TypedDict
+
+from litellm.types.llms.openai import ResponseInputParam
+
+AGENT_MESSAGE_INPUT_ITEM_TYPE: Final = "agent_message"
+CONTEXT_COMPACTION_INPUT_ITEM_TYPE: Final = "context_compaction"
+LOCAL_SHELL_CALL_INPUT_ITEM_TYPE: Final = "local_shell_call"
+
+
+class _RewrittenOutputTextBlock(TypedDict):
+    type: ReadOnly[str]
+    text: ReadOnly[str]
+
+
+class _RewrittenAssistantMessageItem(TypedDict):
+    type: ReadOnly[str]
+    role: ReadOnly[str]
+    content: ReadOnly[tuple[_RewrittenOutputTextBlock, ...]]
+
+
+class _RewrittenCompactionItem(TypedDict):
+    type: ReadOnly[str]
+    encrypted_content: ReadOnly[str]
+
+
+class _RewrittenFunctionCallItem(TypedDict):
+    type: ReadOnly[str]
+    call_id: ReadOnly[str]
+    name: ReadOnly[str]
+    arguments: ReadOnly[str]
+
+
+def _agent_message_text(item: "Mapping[str, object]") -> str:
+    content: Final = item.get("content")
+    if not isinstance(content, list):
+        return ""
+    return "".join(
+        str(block.get("text") or block.get("encrypted_content") or "") for block in content if isinstance(block, dict)
+    )
+
+
+def _normalize_agent_message_item(item: "Mapping[str, object]") -> "_RewrittenAssistantMessageItem | None":
+    text: Final = _agent_message_text(item)
+    if not text:
+        return None
+    rewritten: Final[_RewrittenAssistantMessageItem] = {
+        "type": "message",
+        "role": "assistant",
+        "content": ({"type": "output_text", "text": text},),
+    }
+    return rewritten
+
+
+def _normalize_context_compaction_item(item: "Mapping[str, object]") -> "_RewrittenCompactionItem | None":
+    encrypted_content: Final = item.get("encrypted_content")
+    if not isinstance(encrypted_content, str) or not encrypted_content:
+        return None
+    rewritten: Final[_RewrittenCompactionItem] = {"type": "compaction", "encrypted_content": encrypted_content}
+    return rewritten
+
+
+def _normalize_local_shell_call_item(item: "Mapping[str, object]") -> "_RewrittenFunctionCallItem | None":
+    call_id: Final = item.get("call_id")
+    if not isinstance(call_id, str) or not call_id:
+        return None
+    action: Final = item.get("action")
+    rewritten: Final[_RewrittenFunctionCallItem] = {
+        "type": "function_call",
+        "call_id": call_id,
+        "name": "local_shell",
+        "arguments": json.dumps(action) if isinstance(action, dict) else "{}",
+    }
+    return rewritten
+
+
+def _normalize_input_item(item: object) -> "tuple[object, str | None]":
+    """Returns (normalized item, or None to drop it; original type when rewritten)."""
+    if not isinstance(item, dict):
+        return item, None
+    item_type: Final = item.get("type")
+    if item_type == AGENT_MESSAGE_INPUT_ITEM_TYPE:
+        return _normalize_agent_message_item(item), item_type
+    if item_type == CONTEXT_COMPACTION_INPUT_ITEM_TYPE:
+        return _normalize_context_compaction_item(item), item_type
+    if item_type == LOCAL_SHELL_CALL_INPUT_ITEM_TYPE:
+        return _normalize_local_shell_call_item(item), item_type
+    return item, None
+
+
+def normalize_codex_input_items(
+    input: "str | ResponseInputParam",
+) -> "tuple[str | ResponseInputParam, tuple[str, ...]]":
+    """Rewrite the Codex history item types a Responses backend rejects.
+
+    ``agent_message`` (Codex multi-agent traffic; its ``encrypted_content`` slot
+    carries the plaintext payload when the model never issued encrypted args)
+    becomes an assistant message, ``context_compaction`` becomes the ``compaction``
+    spelling these backends accept, and ``local_shell_call`` becomes the
+    ``function_call`` its recorded ``function_call_output`` already pairs with.
+
+    Returns the normalized input and the sorted set of types that were rewritten,
+    so the caller can log in its own words. Non-list input is returned untouched.
+    """
+    if not isinstance(input, list):
+        return input, ()
+    normalized: Final = tuple(_normalize_input_item(item) for item in input)
+    rewritten_types: Final = tuple(sorted(frozenset(item_type for _, item_type in normalized if item_type is not None)))
+    kept: Final = [i for i, _ in normalized if i is not None]  # mutable-ok: downstream narrows on isinstance(list)
+    # Codex passthrough items sit outside the OpenAI input union.
+    return kept, rewritten_types  # pyright: ignore[reportReturnType]  # see above
+
+
+def drop_unsupported_tools(
+    tools: "Sequence[object]", supported_types: "frozenset[str]"
+) -> "tuple[tuple[object, ...], tuple[str, ...]]":
+    """Keep the tools whose ``type`` the backend accepts; non-dict tools pass through.
+
+    Returns the kept tools and the sorted set of dropped types.
+    """
+    kept: Final = tuple(tool for tool in tools if not isinstance(tool, dict) or tool.get("type") in supported_types)
+    dropped_types: Final = tuple(
+        sorted(
+            frozenset(
+                str(tool.get("type"))
+                for tool in tools
+                if isinstance(tool, dict) and tool.get("type") not in supported_types
+            )
+        )
+    )
+    return kept, dropped_types

litellm/llms/base_llm/responses/transformation.py

@@ -130,6 +130,22 @@ def transform_responses_api_request(
     ) -> dict:
         pass
 
+    async def async_transform_responses_api_request(
+        self,
+        model: str,
+        input: str | ResponseInputParam,
+        response_api_optional_request_params: dict,
+        litellm_params: GenericLiteLLMParams,
+        headers: dict,
+    ) -> dict:
+        return self.transform_responses_api_request(
+            model=model,
+            input=input,
+            response_api_optional_request_params=response_api_optional_request_params,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+
     @abstractmethod
     def transform_response_api_response(
         self,

litellm/llms/bedrock/common_utils.py

@@ -818,6 +818,28 @@ def _mantle_api_base_from_env() -> str | None:
     return next((base[: -len(suffix)] for suffix in _MANTLE_OPENAI_BASE_SUFFIXES if base.endswith(suffix)), base)
 
 
+def bedrock_supports_openai_responses(model: str | None, model_cost: Mapping[str, object]) -> bool:
+    """Whether a Bedrock model is served by bedrock-runtime's OpenAI Responses surface.
+
+    Purely data-driven from the model's price-map capability signal -- ``/v1/responses``
+    in ``supported_endpoints`` -- and overridable via ``register_model`` and proxy
+    ``model_info``, so onboarding a model is a JSON change, never a code change.
+    There is deliberately no model-name match: AWS exposes this surface per model,
+    not per family, and the two Bedrock endpoints do not agree with each other
+    (bedrock-runtime accepts Codex's ``additional_tools`` items where
+    bedrock-mantle rejects them), so a name-shaped gate would be wrong.
+    A model absent from ``model_cost`` has no signal and returns False, leaving the
+    chat-completions bridge in place exactly as before.
+    """
+    if not model:
+        return False
+    candidates: Final = (model_cost.get(key) for key in (model, f"bedrock/{model}"))
+    return any(
+        isinstance(entry, Mapping) and "/v1/responses" in (entry.get("supported_endpoints") or ())
+        for entry in candidates
+    )
+
+
 def build_mantle_messages_url(
     api_base: str | None,
     aws_bedrock_runtime_endpoint: str | None,