diff --git a/docs/my-website/sidebars.js b/docs/my-website/sidebars.js
index 1362745a91f..79a0279bad5 100644
--- a/docs/my-website/sidebars.js
+++ b/docs/my-website/sidebars.js
@@ -631,6 +631,7 @@ const sidebars = {
             "mcp_openapi",
             "mcp_oauth",
             "mcp_aws_sigv4",
+            "mcp_zero_trust",
             "mcp_public_internet",
             "mcp_semantic_filter",
             "mcp_control",
diff --git a/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.57-py3-none-any.whl b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.57-py3-none-any.whl
new file mode 100644
index 00000000000..eeed18e312a
Binary files /dev/null and b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.57-py3-none-any.whl differ
diff --git a/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.57.tar.gz b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.57.tar.gz
new file mode 100644
index 00000000000..293c44e593d
Binary files /dev/null and b/litellm-proxy-extras/dist/litellm_proxy_extras-0.4.57.tar.gz differ
diff --git a/litellm-proxy-extras/pyproject.toml b/litellm-proxy-extras/pyproject.toml
index b65dbe45233..006aad9480b 100644
--- a/litellm-proxy-extras/pyproject.toml
+++ b/litellm-proxy-extras/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm-proxy-extras"
-version = "0.4.56"
+version = "0.4.57"
 description = "Additional files for the LiteLLM Proxy. Reduces the size of the main litellm package."
 authors = ["BerriAI"]
 readme = "README.md"
@@ -22,7 +22,7 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.commitizen]
-version = "0.4.56"
+version = "0.4.57"
 version_files = [
     "pyproject.toml:version",
     "../requirements.txt:litellm-proxy-extras==",
diff --git a/litellm/litellm_core_utils/prompt_templates/factory.py b/litellm/litellm_core_utils/prompt_templates/factory.py
index 47272b38ad6..2b838ad1f80 100644
--- a/litellm/litellm_core_utils/prompt_templates/factory.py
+++ b/litellm/litellm_core_utils/prompt_templates/factory.py
@@ -2439,13 +2439,25 @@ def anthropic_messages_pt(  # noqa: PLR0915
 
                             user_content.append(_content_element)
                         elif m.get("type", "") == "document":
-                            user_content.append(cast(AnthropicMessagesDocumentParam, m))
+                            _document_content_element = cast(
+                                AnthropicMessagesDocumentParam,
+                                add_cache_control_to_content(
+                                    anthropic_content_element=cast(AnthropicMessagesDocumentParam, m),
+                                    original_content_element=dict(m),
+                                ),
+                            )
+                            user_content.append(_document_content_element)
                         elif m.get("type", "") == "file":
-                            user_content.append(
+                            _file_content_element = (
                                 anthropic_process_openai_file_message(
                                     cast(ChatCompletionFileObject, m)
                                 )
                             )
+                            _file_content_element = add_cache_control_to_content(
+                                anthropic_content_element=cast(AnthropicMessagesDocumentParam, _file_content_element),
+                                original_content_element=dict(m),
+                            )
+                            user_content.append(cast(AnthropicMessagesDocumentParam,_file_content_element))
                 elif isinstance(user_message_types_block["content"], str):
                     _anthropic_content_text_element: AnthropicMessagesTextParam = {
                         "type": "text",
diff --git a/litellm/llms/anthropic/chat/handler.py b/litellm/llms/anthropic/chat/handler.py
index 5eebebc2e23..7dce72f1e82 100644
--- a/litellm/llms/anthropic/chat/handler.py
+++ b/litellm/llms/anthropic/chat/handler.py
@@ -48,6 +48,10 @@ from litellm.types.llms.openai import (
     ChatCompletionToolCallChunk,
     ChatCompletionToolCallFunctionChunk,
 )
+from litellm.types.responses.main import (
+    OutputCodeInterpreterCall,
+    build_code_interpreter_log_outputs,
+)
 from litellm.types.utils import (
     Delta,
     GenericStreamingChunk,
@@ -538,6 +542,12 @@ class ModelResponseIterator:
         # Accumulate compaction blocks for multi-turn reconstruction
         self.compaction_blocks: List[Dict[str, Any]] = []
 
+        # Track server tool use inputs and results for code_interpreter_results
+        self._server_tool_inputs: Dict[str, Any] = {}
+        self.tool_results: List[Dict[str, Any]] = []
+        self._current_server_tool_id: Optional[str] = None
+        self._container_id: Optional[str] = None
+
     def check_empty_tool_call_args(self) -> bool:
         """
         Check if the tool call block so far has been an empty string
@@ -568,9 +578,7 @@ class ModelResponseIterator:
             speed=self.speed,
         )
 
-    def _content_block_delta_helper(
-        self, chunk: dict
-    ) -> Tuple[
+    def _content_block_delta_helper(self, chunk: dict) -> Tuple[
         str,
         Optional[ChatCompletionToolCallChunk],
         List[Union[ChatCompletionThinkingBlock, ChatCompletionRedactedThinkingBlock]],
@@ -682,6 +690,39 @@ class ModelResponseIterator:
 
         return content_block_start
 
+    def _build_code_interpreter_results(self) -> list:
+        """Convert accumulated tool_results to OutputCodeInterpreterCall objects.
+
+        Called during streaming to produce provider-neutral code_interpreter_results
+        alongside the raw tool_results, so the Responses API layer doesn't need
+        Anthropic-specific knowledge.
+
+        Returns the full cumulative list each time (not incremental), matching
+        how web_search_results works.  stream_chunk_builder uses "last value
+        wins" for list-valued provider_specific_fields keys, so the last
+        emission must contain every result.
+        """
+        results = []
+        for tr in self.tool_results:
+            if tr.get("type") != "bash_code_execution_tool_result":
+                continue
+            call_id = tr.get("tool_use_id", "")
+            content = tr.get("content", {})
+            log_outputs = build_code_interpreter_log_outputs(content)
+            tool_input = self._server_tool_inputs.get(call_id, {})
+            code = tool_input.get("command", "") if isinstance(tool_input, dict) else ""
+            results.append(
+                OutputCodeInterpreterCall(
+                    type="code_interpreter_call",
+                    id=call_id,
+                    code=code,
+                    container_id=self._container_id,
+                    status="completed",
+                    outputs=log_outputs,
+                )
+            )
+        return results
+
     def chunk_parser(self, chunk: dict) -> ModelResponseStream:  # noqa: PLR0915
         try:
             type_chunk = chunk.get("type", "") or ""
@@ -748,6 +789,23 @@ class ModelResponseIterator:
                         ),
                         index=self.tool_index,
                     )
+                    # Track server tool use inputs for code_interpreter_results.
+                    # The initial input in content_block_start is typically {}
+                    # for streaming; the full input arrives via input_json_delta
+                    # and is assembled at content_block_stop.
+                    if (
+                        content_block_start["content_block"]["type"]
+                        == "server_tool_use"
+                    ):
+                        self._current_server_tool_id = content_block_start[
+                            "content_block"
+                        ]["id"]
+                        tool_input = content_block_start["content_block"].get(
+                            "input", {}
+                        )
+                        self._server_tool_inputs[self._current_server_tool_id] = (
+                            tool_input
+                        )
                     # Include caller information if present (for programmatic tool calling)
                     if "caller" in content_block_start["content_block"]:
                         caller_data = content_block_start["content_block"]["caller"]
@@ -768,9 +826,9 @@ class ModelResponseIterator:
                     # Handle compaction blocks
                     # The full content comes in content_block_start
                     self.compaction_blocks.append(content_block_start["content_block"])
-                    provider_specific_fields[
-                        "compaction_blocks"
-                    ] = self.compaction_blocks
+                    provider_specific_fields["compaction_blocks"] = (
+                        self.compaction_blocks
+                    )
                     provider_specific_fields["compaction_start"] = {
                         "type": "compaction",
                         "content": content_block_start["content_block"].get(
@@ -792,9 +850,9 @@ class ModelResponseIterator:
                         self.web_search_results.append(
                             content_block_start["content_block"]
                         )
-                        provider_specific_fields[
-                            "web_search_results"
-                        ] = self.web_search_results
+                        provider_specific_fields["web_search_results"] = (
+                            self.web_search_results
+                        )
                     elif content_type == "web_fetch_tool_result":
                         # Capture web_fetch_tool_result for multi-turn reconstruction
                         # The full content comes in content_block_start, not in deltas
@@ -802,16 +860,18 @@ class ModelResponseIterator:
                         self.web_search_results.append(
                             content_block_start["content_block"]
                         )
-                        provider_specific_fields[
-                            "web_search_results"
-                        ] = self.web_search_results
+                        provider_specific_fields["web_search_results"] = (
+                            self.web_search_results
+                        )
                     elif content_type != "tool_search_tool_result":
                         # Handle other tool results (code execution, etc.)
                         # Skip tool_search_tool_result as it's internal metadata
-                        if not hasattr(self, "tool_results"):
-                            self.tool_results = []
                         self.tool_results.append(content_block_start["content_block"])
                         provider_specific_fields["tool_results"] = self.tool_results
+                        # Convert to provider-neutral code_interpreter_results
+                        provider_specific_fields["code_interpreter_results"] = (
+                            self._build_code_interpreter_results()
+                        )
 
             elif type_chunk == "content_block_stop":
                 ContentBlockStop(**chunk)  # type: ignore
@@ -828,6 +888,24 @@ class ModelResponseIterator:
                             ),
                             index=self.tool_index,
                         )
+                    # Update server_tool_inputs with fully assembled input
+                    # from input_json_delta chunks (content_block_start has {})
+                    if (
+                        self.current_content_block_type == "server_tool_use"
+                        and self._current_server_tool_id
+                    ):
+                        args = ""
+                        for block in self.content_blocks:
+                            if block["delta"]["type"] == "input_json_delta":
+                                args += block["delta"].get("partial_json", "")
+                        if args:
+                            try:
+                                self._server_tool_inputs[
+                                    self._current_server_tool_id
+                                ] = json.loads(args)
+                            except (json.JSONDecodeError, TypeError):
+                                pass
+                        self._current_server_tool_id = None
                 # Reset response_format tool tracking when block stops
                 self.is_response_format_tool = False
                 # Reset current content block type
@@ -840,6 +918,17 @@ class ModelResponseIterator:
                 finish_reason, usage, container = self._handle_message_delta(chunk)
                 if container:
                     provider_specific_fields["container"] = container
+                    # Store container_id and re-emit code_interpreter_results
+                    # so stream_chunk_builder's last-value-wins picks up the
+                    # version with container_id populated.
+                    container_id = (
+                        container.get("id") if isinstance(container, dict) else None
+                    )
+                    if container_id and self.tool_results:
+                        self._container_id = container_id
+                        provider_specific_fields["code_interpreter_results"] = (
+                            self._build_code_interpreter_results()
+                        )
             elif type_chunk == "message_start":
                 """
                 Anthropic
diff --git a/litellm/llms/anthropic/chat/transformation.py b/litellm/llms/anthropic/chat/transformation.py
index 47cdd8287e0..bbc73fcfd40 100644
--- a/litellm/llms/anthropic/chat/transformation.py
+++ b/litellm/llms/anthropic/chat/transformation.py
@@ -59,6 +59,10 @@ from litellm.types.utils import (
     PromptTokensDetailsWrapper,
     ServerToolUse,
 )
+from litellm.types.responses.main import (
+    OutputCodeInterpreterCall,
+    build_code_interpreter_log_outputs,
+)
 from litellm.utils import (
     ModelResponse,
     Usage,
@@ -960,11 +964,11 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                 if mcp_servers:
                     optional_params["mcp_servers"] = mcp_servers
             elif param == "tool_choice" or param == "parallel_tool_calls":
-                _tool_choice: Optional[
-                    AnthropicMessagesToolChoice
-                ] = self._map_tool_choice(
-                    tool_choice=non_default_params.get("tool_choice"),
-                    parallel_tool_use=non_default_params.get("parallel_tool_calls"),
+                _tool_choice: Optional[AnthropicMessagesToolChoice] = (
+                    self._map_tool_choice(
+                        tool_choice=non_default_params.get("tool_choice"),
+                        parallel_tool_use=non_default_params.get("parallel_tool_calls"),
+                    )
                 )
 
                 if _tool_choice is not None:
@@ -1062,9 +1066,9 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                         self.map_openai_context_management_to_anthropic(value)
                     )
                     if anthropic_context_management is not None:
-                        optional_params[
-                            "context_management"
-                        ] = anthropic_context_management
+                        optional_params["context_management"] = (
+                            anthropic_context_management
+                        )
             elif param == "speed" and isinstance(value, str):
                 # Pass through Anthropic-specific speed parameter for fast mode
                 optional_params["speed"] = value
@@ -1138,9 +1142,9 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                         text=system_message_block["content"],
                     )
                     if "cache_control" in system_message_block:
-                        anthropic_system_message_content[
-                            "cache_control"
-                        ] = system_message_block["cache_control"]
+                        anthropic_system_message_content["cache_control"] = (
+                            system_message_block["cache_control"]
+                        )
                     anthropic_system_message_list.append(
                         anthropic_system_message_content
                     )
@@ -1164,9 +1168,9 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                             )
                         )
                         if "cache_control" in _content:
-                            anthropic_system_message_content[
-                                "cache_control"
-                            ] = _content["cache_control"]
+                            anthropic_system_message_content["cache_control"] = (
+                                _content["cache_control"]
+                            )
 
                         anthropic_system_message_list.append(
                             anthropic_system_message_content
@@ -1463,9 +1467,7 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                 )
         return _message
 
-    def extract_response_content(
-        self, completion_response: dict
-    ) -> Tuple[
+    def extract_response_content(self, completion_response: dict) -> Tuple[
         str,
         Optional[List[Any]],
         Optional[
@@ -1749,6 +1751,40 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
                 provider_specific_fields["web_search_results"] = web_search_results
             if tool_results is not None:
                 provider_specific_fields["tool_results"] = tool_results
+                # Convert to provider-neutral OutputCodeInterpreterCall objects
+                # so the Responses API layer can use them without Anthropic-specific knowledge.
+                container_id = (
+                    completion_response.get("container", {}).get("id")
+                    if isinstance(completion_response.get("container"), dict)
+                    else None
+                )
+                code_by_id: Dict[str, str] = {}
+                for tc in tool_calls:
+                    try:
+                        args = json.loads(tc.get("function", {}).get("arguments", "{}"))
+                        code_by_id[tc.get("id", "")] = args.get("command", "")
+                    except Exception:
+                        pass
+                code_interpreter_results = []
+                for tr in tool_results:
+                    if tr.get("type") != "bash_code_execution_tool_result":
+                        continue
+                    call_id = tr.get("tool_use_id", "")
+                    content = tr.get("content", {})
+                    log_outputs = build_code_interpreter_log_outputs(content)
+                    code_interpreter_results.append(
+                        OutputCodeInterpreterCall(
+                            type="code_interpreter_call",
+                            id=call_id,
+                            code=code_by_id.get(call_id, ""),
+                            container_id=container_id,
+                            status="completed",
+                            outputs=log_outputs,
+                        )
+                    )
+                provider_specific_fields["code_interpreter_results"] = (
+                    code_interpreter_results
+                )
             if container is not None:
                 provider_specific_fields["container"] = container
             if compaction_blocks is not None:
@@ -1794,6 +1830,7 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
         model_response.created = int(time.time())
         model_response.model = completion_response["model"]
 
+        _hidden_params["provider_specific_fields"] = provider_specific_fields
         model_response._hidden_params = _hidden_params
         return model_response
 
diff --git a/litellm/proxy/response_polling/background_streaming.py b/litellm/proxy/response_polling/background_streaming.py
index 5ec0aac8e29..b4d51814e5a 100644
--- a/litellm/proxy/response_polling/background_streaming.py
+++ b/litellm/proxy/response_polling/background_streaming.py
@@ -258,8 +258,8 @@ async def background_streaming_task(  # noqa: PLR0915
                                 ),
                             )
 
-                            # Extract error for failed responses
-                            if event_type == "response.failed":
+                            # Extract error for failed and incomplete responses
+                            if event_type == "response.failed" or event_type == "response.incomplete":
                                 terminal_error = response_data.get("error")
 
                             # Core response fields
@@ -337,7 +337,7 @@ async def background_streaming_task(  # noqa: PLR0915
         )
 
         verbose_proxy_logger.info(
-            f"Finished background streaming for {polling_id}, status={final_status}, output_items={len(output_items)}"
+            f"Finished background streaming for {polling_id}, status={final_status}, error={terminal_error}, incomplete_details={incomplete_details_data}, output_items={len(output_items)}"
         )
 
     except Exception as e:
diff --git a/litellm/proxy/route_llm_request.py b/litellm/proxy/route_llm_request.py
index e5fc9fe76a4..f1590b16c24 100644
--- a/litellm/proxy/route_llm_request.py
+++ b/litellm/proxy/route_llm_request.py
@@ -1,3 +1,4 @@
+import asyncio
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 from fastapi import HTTPException, status
@@ -123,30 +124,99 @@ def get_team_id_from_data(data: dict) -> Optional[str]:
     return None
 
 
-def add_shared_session_to_data(data: dict) -> None:
+_shared_session_lock: Optional[asyncio.Lock] = None
+
+
+def _get_shared_session_lock() -> asyncio.Lock:
+    """Lazily create the shared session lock (must be called within a running event loop).
+
+    WARNING: Do not reset _shared_session_lock to None while any coroutine may be
+    executing the session-recovery path; doing so breaks the double-checked locking
+    guarantee and can cause duplicate session creation.
+    """
+    global _shared_session_lock
+    if _shared_session_lock is None:
+        _shared_session_lock = asyncio.Lock()
+    return _shared_session_lock
+
+
+async def add_shared_session_to_data(data: dict) -> None:
     """
     Add shared aiohttp session for connection reuse (prevents cold starts).
+    If the session was closed (e.g. due to network interruption or idle timeout),
+    automatically recreates it so connection pooling is restored.
+    Uses an asyncio.Lock to prevent race conditions where multiple concurrent
+    requests could each create a new session, leaking intermediate ones.
     Silently continues without session reuse if import fails or session is unavailable.
 
     Args:
         data: Dictionary to add the shared session to
     """
     try:
+        import litellm.proxy.proxy_server as proxy_server
         from litellm._logging import verbose_proxy_logger
-        from litellm.proxy.proxy_server import shared_aiohttp_session
 
-        if shared_aiohttp_session is not None and not shared_aiohttp_session.closed:
-            data["shared_session"] = shared_aiohttp_session
+        session = proxy_server.shared_aiohttp_session
+
+        if session is not None and not session.closed:
+            data["shared_session"] = session
             verbose_proxy_logger.info(
-                f"SESSION REUSE: Attached shared aiohttp session to request (ID: {id(shared_aiohttp_session)})"
+                f"SESSION REUSE: Attached shared aiohttp session to request (ID: {id(session)})"
             )
+        elif session is not None and session.closed:
+            # Session was created at startup but has since closed — recreate it
+            # Use lock to prevent concurrent recreation (avoids session/connector leak)
+            lock = _get_shared_session_lock()
+            async with lock:
+                # Double-check under lock — another coroutine may have already recreated it
+                session = proxy_server.shared_aiohttp_session
+                if session is not None and not session.closed:
+                    data["shared_session"] = session
+                    return
+
+                # session could be None here (if another coroutine set it to None)
+                # or closed — either way we need to recreate
+                if session is not None:
+                    verbose_proxy_logger.warning(
+                        f"SESSION REUSE: Shared aiohttp session is closed (ID: {id(session)}), recreating..."
+                    )
+                else:
+                    verbose_proxy_logger.warning(
+                        "SESSION REUSE: Shared aiohttp session is None after re-check, recreating..."
+                    )
+                try:
+                    new_session = (
+                        await proxy_server._initialize_shared_aiohttp_session()
+                    )
+                except Exception:
+                    verbose_proxy_logger.exception(
+                        "SESSION REUSE: Exception during shared session recreation"
+                    )
+                    new_session = None
+                if new_session is not None:
+                    proxy_server.shared_aiohttp_session = new_session
+                    data["shared_session"] = new_session
+                else:
+                    verbose_proxy_logger.info(
+                        "SESSION REUSE: Failed to recreate shared session, continuing without session reuse"
+                    )
         else:
             verbose_proxy_logger.info(
                 "SESSION REUSE: No shared session available for this request"
             )
     except Exception:
-        # Silently continue without session reuse if import fails or session unavailable
-        pass
+        # Continue without session reuse — this outer handler covers import failures
+        # and other unexpected errors to avoid breaking the request path.
+        # Inner recovery logic has its own specific exception handling.
+        try:
+            from litellm._logging import verbose_proxy_logger
+
+            verbose_proxy_logger.debug(
+                "SESSION REUSE: Unexpected error in session setup, continuing without reuse",
+                exc_info=True,
+            )
+        except Exception:
+            pass
 
 
 async def route_request(  # noqa: PLR0915 - Complex routing function, refactoring tracked separately
@@ -248,7 +318,7 @@ async def route_request(  # noqa: PLR0915 - Complex routing function, refactorin
     """
     Common helper to route the request
     """
-    add_shared_session_to_data(data)
+    await add_shared_session_to_data(data)
 
     team_id = get_team_id_from_data(data)
     router_model_names = llm_router.model_names if llm_router is not None else []
diff --git a/litellm/responses/litellm_completion_transformation/streaming_iterator.py b/litellm/responses/litellm_completion_transformation/streaming_iterator.py
index ce037850b86..0672b03bcd7 100644
--- a/litellm/responses/litellm_completion_transformation/streaming_iterator.py
+++ b/litellm/responses/litellm_completion_transformation/streaming_iterator.py
@@ -107,6 +107,7 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         self._reasoning_done_emitted = False
         self._reasoning_item_id: Optional[str] = None
         self._accumulated_reasoning_content_parts: List[str] = []
+        self._accumulated_provider_specific_fields: Dict[str, Any] = {}
 
     def _get_or_assign_tool_output_index(self, call_id: str) -> int:
         existing = self._tool_output_index_by_call_id.get(call_id)
@@ -479,16 +480,36 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
         event.__dict__["sequence_number"] = self._sequence_number
         return event
 
-    def create_litellm_model_response(
-        self,
-    ) -> Optional[ModelResponse]:
-        return cast(
+    def _merge_provider_specific_fields(self, src: dict) -> None:
+        """Merge provider_specific_fields using last-value-wins for lists.
+
+        List-valued keys (web_search_results, tool_results,
+        code_interpreter_results, etc.) are emitted cumulatively — each
+        emission contains the full list so far.  Using "last value wins"
+        matches stream_chunk_builder's semantics and avoids quadratic
+        growth from repeated extend calls.
+        """
+        for key, val in src.items():
+            self._accumulated_provider_specific_fields[key] = val
+
+    def create_litellm_model_response(self) -> Optional[ModelResponse]:
+        response = cast(
             Optional[ModelResponse],
             stream_chunk_builder(
                 chunks=self.collected_chat_completion_chunks,
                 logging_obj=self.litellm_logging_obj,
             ),
         )
+        if response is not None and self._accumulated_provider_specific_fields:
+            if (
+                not hasattr(response, "_hidden_params")
+                or response._hidden_params is None
+            ):
+                response._hidden_params = {}
+            response._hidden_params.setdefault("provider_specific_fields", {}).update(
+                self._accumulated_provider_specific_fields
+            )
+        return response
 
     @staticmethod
     def _snapshot_chunk_for_stream_chunk_builder(
@@ -853,6 +874,17 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
                     if chunk is not None:
                         chunk = cast(ModelResponseStream, chunk)
                         self._ensure_output_item_for_chunk(chunk)
+                        # Accumulate provider_specific_fields from chunk and delta
+                        for src in (
+                            getattr(chunk, "provider_specific_fields", None),
+                            getattr(
+                                chunk.choices[0].delta if chunk.choices else None,
+                                "provider_specific_fields",
+                                None,
+                            ),
+                        ):
+                            if src and isinstance(src, dict):
+                                self._merge_provider_specific_fields(src)
                         # Proceed to transformation
                         self.collected_chat_completion_chunks.append(
                             self._snapshot_chunk_for_stream_chunk_builder(chunk)
@@ -964,6 +996,17 @@ class LiteLLMCompletionStreamingIterator(ResponsesAPIStreamingIterator):
                 try:
                     chunk = self.litellm_custom_stream_wrapper.__next__()
                     self._ensure_output_item_for_chunk(chunk)
+                    # Accumulate provider_specific_fields from chunk and delta
+                    for src in (
+                        getattr(chunk, "provider_specific_fields", None),
+                        getattr(
+                            chunk.choices[0].delta if chunk.choices else None,
+                            "provider_specific_fields",
+                            None,
+                        ),
+                    ):
+                        if src and isinstance(src, dict):
+                            self._merge_provider_specific_fields(src)
                     # Emit any just-queued output_item event
                     if self._pending_response_events:
                         return self._pending_response_events.pop(0)
diff --git a/litellm/responses/litellm_completion_transformation/transformation.py b/litellm/responses/litellm_completion_transformation/transformation.py
index 71fa88fb751..cf18511bfa3 100644
--- a/litellm/responses/litellm_completion_transformation/transformation.py
+++ b/litellm/responses/litellm_completion_transformation/transformation.py
@@ -42,6 +42,7 @@ from litellm.types.llms.openai import (
 from litellm.types.responses.main import (
     GenericResponseOutputItem,
     GenericResponseOutputItemContentAnnotation,
+    OutputCodeInterpreterCall,
     OutputFunctionToolCall,
     OutputImageGenerationCall,
     OutputText,
@@ -1696,6 +1697,7 @@ class LiteLLMCompletionResponsesConfig:
     ) -> List[
         Union[
             GenericResponseOutputItem,
+            OutputCodeInterpreterCall,
             OutputFunctionToolCall,
             OutputImageGenerationCall,
             ResponseFunctionToolCall,
@@ -1704,6 +1706,7 @@ class LiteLLMCompletionResponsesConfig:
         responses_output: List[
             Union[
                 GenericResponseOutputItem,
+                OutputCodeInterpreterCall,
                 OutputFunctionToolCall,
                 OutputImageGenerationCall,
                 ResponseFunctionToolCall,
@@ -1725,8 +1728,63 @@ class LiteLLMCompletionResponsesConfig:
                 chat_completion_response=chat_completion_response
             )
         )
+
+        # Convert server-side tool results (e.g. Anthropic code execution)
+        # into code_interpreter_call output items, replacing the corresponding
+        # function_call items so the output matches OpenAI's native shape.
+        tool_result_items = (
+            LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(
+                chat_completion_response
+            )
+        )
+        if tool_result_items:
+            result_by_id = {item.id: item for item in tool_result_items}
+            replaced_ids = set(result_by_id.keys())
+            responses_output = [
+                (
+                    result_by_id[getattr(item, "call_id", None)]
+                    if (
+                        getattr(item, "type", None) == "function_call"
+                        and getattr(item, "call_id", None) in replaced_ids
+                    )
+                    else item
+                )
+                for item in responses_output
+            ]
+
         return responses_output
 
+    @staticmethod
+    def _extract_tool_result_output_items(
+        chat_completion_response: ModelResponse,
+    ) -> list:
+        """Extract pre-built code_interpreter_call output items from provider_specific_fields.
+
+        Provider transformers (e.g. Anthropic) convert their native tool results
+        into OutputCodeInterpreterCall objects and store them in
+        provider_specific_fields["code_interpreter_results"]. This method
+        simply retrieves them — no provider-specific parsing here.
+        """
+        output_items: list = []
+        for choice in chat_completion_response.choices or []:
+            message = getattr(choice, "message", None)
+            if not message:
+                continue
+            psf = getattr(message, "provider_specific_fields", None)
+            if not psf or not isinstance(psf, dict):
+                continue
+            results = psf.get("code_interpreter_results")
+            if results and isinstance(results, list):
+                for item in results:
+                    # In the streaming path, items are plain dicts after
+                    # model_dump() in stream_chunk_builder.  Reconstruct
+                    # Pydantic objects so responses_output has a uniform type.
+                    if isinstance(item, dict):
+                        output_items.append(OutputCodeInterpreterCall(**item))
+                    else:
+                        output_items.append(item)
+        return output_items
+
     @staticmethod
     def _extract_reasoning_output_items(
         chat_completion_response: ModelResponse,
@@ -2055,9 +2113,9 @@ class LiteLLMCompletionResponsesConfig:
                 hasattr(completion_details, "reasoning_tokens")
                 and completion_details.reasoning_tokens is not None
             ):
-                output_details_dict[
-                    "reasoning_tokens"
-                ] = completion_details.reasoning_tokens
+                output_details_dict["reasoning_tokens"] = (
+                    completion_details.reasoning_tokens
+                )
             else:
                 output_details_dict["reasoning_tokens"] = 0
 
diff --git a/litellm/types/llms/openai.py b/litellm/types/llms/openai.py
index a2df3f2e0d6..a265198e6b8 100644
--- a/litellm/types/llms/openai.py
+++ b/litellm/types/llms/openai.py
@@ -84,6 +84,7 @@ from typing_extensions import Annotated, Dict, Required, TypedDict, override
 from litellm.types.llms.base import BaseLiteLLMOpenAIResponseObject
 from litellm.types.responses.main import (
     GenericResponseOutputItem,
+    OutputCodeInterpreterCall,
     OutputFunctionToolCall,
     OutputImageGenerationCall,
 )
@@ -969,12 +970,12 @@ class OpenAIChatCompletionChunk(ChatCompletionChunk):
 
 class Hyperparameters(BaseModel):
     batch_size: Optional[Union[str, int]] = None  # "Number of examples in each batch."
-    learning_rate_multiplier: Optional[
-        Union[str, float]
-    ] = None  # Scaling factor for the learning rate
-    n_epochs: Optional[
-        Union[str, int]
-    ] = None  # "The number of epochs to train the model for"
+    learning_rate_multiplier: Optional[Union[str, float]] = (
+        None  # Scaling factor for the learning rate
+    )
+    n_epochs: Optional[Union[str, int]] = (
+        None  # "The number of epochs to train the model for"
+    )
 
     model_config = {"extra": "allow"}
 
@@ -1003,18 +1004,18 @@ class FineTuningJobCreate(BaseModel):
 
     model: str  # "The name of the model to fine-tune."
     training_file: str  # "The ID of an uploaded file that contains training data."
-    hyperparameters: Optional[
-        Hyperparameters
-    ] = None  # "The hyperparameters used for the fine-tuning job."
-    suffix: Optional[
-        str
-    ] = None  # "A string of up to 18 characters that will be added to your fine-tuned model name."
-    validation_file: Optional[
-        str
-    ] = None  # "The ID of an uploaded file that contains validation data."
-    integrations: Optional[
-        List[str]
-    ] = None  # "A list of integrations to enable for your fine-tuning job."
+    hyperparameters: Optional[Hyperparameters] = (
+        None  # "The hyperparameters used for the fine-tuning job."
+    )
+    suffix: Optional[str] = (
+        None  # "A string of up to 18 characters that will be added to your fine-tuned model name."
+    )
+    validation_file: Optional[str] = (
+        None  # "The ID of an uploaded file that contains validation data."
+    )
+    integrations: Optional[List[str]] = (
+        None  # "A list of integrations to enable for your fine-tuning job."
+    )
     seed: Optional[int] = None  # "The seed controls the reproducibility of the job."
 
 
@@ -1242,6 +1243,7 @@ class ResponsesAPIResponse(BaseLiteLLMOpenAIResponseObject):
         List[
             Union[
                 GenericResponseOutputItem,
+                OutputCodeInterpreterCall,
                 OutputFunctionToolCall,
                 OutputImageGenerationCall,
                 ResponseFunctionToolCall,
@@ -1308,13 +1310,16 @@ class ResponsesAPIResponse(BaseLiteLLMOpenAIResponseObject):
         if not isinstance(serialized, list):
             return serialized
         return [
-            {
-                k: v
-                for k, v in item.items()
-                if v is not None or k not in ("status", "content", "encrypted_content")
-            }
-            if isinstance(item, dict) and item.get("type") == "reasoning"
-            else item
+            (
+                {
+                    k: v
+                    for k, v in item.items()
+                    if v is not None
+                    or k not in ("status", "content", "encrypted_content")
+                }
+                if isinstance(item, dict) and item.get("type") == "reasoning"
+                else item
+            )
             for item in serialized
         ]
 
diff --git a/litellm/types/responses/main.py b/litellm/types/responses/main.py
index 7a666d5e65f..ebd2ad5b5a8 100644
--- a/litellm/types/responses/main.py
+++ b/litellm/types/responses/main.py
@@ -49,6 +49,42 @@ class OutputImageGenerationCall(BaseLiteLLMOpenAIResponseObject):
     result: Optional[str]  # Base64 encoded image data (without data:image prefix)
 
 
+class OutputCodeInterpreterCallLog(BaseLiteLLMOpenAIResponseObject):
+    """Log output from a code interpreter call"""
+
+    type: Literal["logs"]
+    logs: str
+
+
+class OutputCodeInterpreterCall(BaseLiteLLMOpenAIResponseObject):
+    """A code interpreter / code execution call output"""
+
+    type: Literal["code_interpreter_call"]
+    id: str
+    code: Optional[str]
+    container_id: Optional[str]
+    status: Literal["in_progress", "completed", "incomplete", "failed"]
+    outputs: Optional[List[OutputCodeInterpreterCallLog]]
+
+
+def build_code_interpreter_log_outputs(
+    content: Any,
+) -> Optional[List[OutputCodeInterpreterCallLog]]:
+    """Convert Anthropic bash_code_execution stdout/stderr to log outputs.
+
+    Shared by streaming (handler.py) and non-streaming (transformation.py) paths.
+    """
+    if not isinstance(content, dict):
+        return None
+    parts = []
+    if content.get("stdout"):
+        parts.append(content["stdout"])
+    if content.get("stderr"):
+        parts.append(f"STDERR: {content['stderr']}")
+    logs = "".join(parts)
+    return [OutputCodeInterpreterCallLog(type="logs", logs=logs)] if logs else None
+
+
 class GenericResponseOutputItem(BaseLiteLLMOpenAIResponseObject):
     """
     Generic response API output item
diff --git a/pyproject.toml b/pyproject.toml
index 37223a3e251..0e2fb40d935 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -61,7 +61,7 @@ boto3 = { version = "^1.40.76", optional = true }
 redisvl = {version = "^0.4.1", optional = true, markers = "python_version >= '3.9' and python_version < '3.14'"}
 mcp = {version = ">=1.25.0,<2.0.0", optional = true, python = ">=3.10"}
 a2a-sdk = {version = "^0.3.22", optional = true, python = ">=3.10"}
-litellm-proxy-extras = {version = "^0.4.56", optional = true}
+litellm-proxy-extras = {version = "^0.4.57", optional = true}
 rich = {version = "^13.7.1", optional = true}
 litellm-enterprise = {version = "^0.1.33", optional = true}
 diskcache = {version = "^5.6.1", optional = true}
diff --git a/requirements.txt b/requirements.txt
index 2bdafda612a..827986487fc 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -57,7 +57,7 @@ grpcio>=1.75.0; python_version >= "3.14"
 sentry_sdk==2.21.0 # for sentry error handling
 detect-secrets==1.5.0 # Enterprise - secret detection / masking in LLM requests
 tzdata==2025.1 # IANA time zone database
-litellm-proxy-extras==0.4.56 # for proxy extras - e.g. prisma migrations
+litellm-proxy-extras==0.4.57 # for proxy extras - e.g. prisma migrations
 llm-sandbox==0.3.31 # for skill execution in sandbox
 ### LITELLM PACKAGE DEPENDENCIES
 python-dotenv==1.0.1 # for env
diff --git a/tests/proxy_unit_tests/test_response_polling_handler.py b/tests/proxy_unit_tests/test_response_polling_handler.py
index 6235dde8475..c5f3d7c6f45 100644
--- a/tests/proxy_unit_tests/test_response_polling_handler.py
+++ b/tests/proxy_unit_tests/test_response_polling_handler.py
@@ -1414,6 +1414,11 @@ class TestBackgroundStreamingTerminalEvents:
             background_streaming_task,
         )
 
+        error_payload = {
+            "type": "incomplete_response",
+            "message": "The model stopped before producing a complete response",
+            "code": "max_output_tokens",
+        }
         events = [
             {"type": "response.in_progress"},
             {
@@ -1421,6 +1426,7 @@ class TestBackgroundStreamingTerminalEvents:
                 "response": {
                     "id": "resp_123",
                     "status": "incomplete",
+                    "error": error_payload,
                     "incomplete_details": {"reason": "max_output_tokens"},
                     "usage": {"input_tokens": 10, "output_tokens": 4096},
                     "model": "gpt-4o",
@@ -1442,6 +1448,7 @@ class TestBackgroundStreamingTerminalEvents:
 
         final_call = handler.update_state.call_args_list[-1]
         assert final_call.kwargs["status"] == "incomplete"
+        assert final_call.kwargs["error"] == error_payload
         assert final_call.kwargs["incomplete_details"] == {"reason": "max_output_tokens"}
         assert final_call.kwargs["usage"] == {"input_tokens": 10, "output_tokens": 4096}
 
diff --git a/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py b/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py
index 8d68539564c..988941d1d91 100644
--- a/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py
+++ b/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py
@@ -1,4 +1,4 @@
-import json
+import base64
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -8,6 +8,7 @@ from litellm.litellm_core_utils.prompt_templates.factory import (
     BAD_MESSAGE_ERROR_STR,
     BedrockConverseMessagesProcessor,
     BedrockImageProcessor,
+    anthropic_messages_pt,
     _convert_to_bedrock_tool_call_invoke,
     ollama_pt,
     sanitize_messages_for_tool_calling,
@@ -1594,6 +1595,92 @@ def test_bedrock_tools_unpack_defs_no_oom_with_nested_refs():
     assert "$defs" not in tool_schema, "$defs should be removed after expansion"
 
 
+def test_anthropic_messages_pt_file_block_preserves_cache_control():
+    """
+    Test that cache_control on file-type content blocks is preserved
+    when translating to Anthropic message format.
+    Regression test for https://github.com/BerriAI/litellm/issues/23873
+    """
+
+    pdf_b64 = base64.b64encode(b"%PDF-1.4 fake pdf content").decode()
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "file",
+                    "file": {
+                        "filename": "document.pdf",
+                        "file_data": f"data:application/pdf;base64,{pdf_b64}",
+                    },
+                    "cache_control": {"type": "ephemeral"},
+                },
+                {
+                    "type": "text",
+                    "text": "Summarize this document.",
+                    "cache_control": {"type": "ephemeral"},
+                },
+            ],
+        }
+    ]
+
+    result = anthropic_messages_pt(
+        messages=messages,
+        model="claude-sonnet-4-20250514",
+        llm_provider="anthropic",
+    )
+
+    assert len(result) == 1
+    content_blocks = result[0]["content"]
+    assert len(content_blocks) == 2
+
+    file_block = content_blocks[0]
+    assert file_block["type"] == "document"
+    assert "cache_control" in file_block, (
+        "cache_control should be preserved on file/document content blocks"
+    )
+    assert file_block["cache_control"]["type"] == "ephemeral"
+
+    text_block = content_blocks[1]
+    assert text_block["type"] == "text"
+    assert "cache_control" in text_block
+    assert text_block["cache_control"]["type"] == "ephemeral"
+
+
+def test_anthropic_messages_pt_file_block_without_cache_control():
+    """
+    Test that file blocks without cache_control still work correctly.
+    """
+    import base64
+
+    pdf_b64 = base64.b64encode(b"%PDF-1.4 fake").decode()
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "file",
+                    "file": {
+                        "filename": "doc.pdf",
+                        "file_data": f"data:application/pdf;base64,{pdf_b64}",
+                    },
+                },
+            ],
+        }
+    ]
+
+    result = anthropic_messages_pt(
+        messages=messages,
+        model="claude-sonnet-4-20250514",
+        llm_provider="anthropic",
+    )
+
+    assert len(result) == 1
+    file_block = result[0]["content"][0]
+    assert file_block["type"] == "document"
+    assert "cache_control" not in file_block
+
+
 # ── _convert_to_bedrock_tool_call_invoke tests ──
 
 
diff --git a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_handler.py b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_handler.py
index d9f513d8d1d..20427e8cc94 100644
--- a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_handler.py
+++ b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_handler.py
@@ -6,6 +6,7 @@ from litellm.types.llms.openai import (
     ChatCompletionToolCallChunk,
     ChatCompletionToolCallFunctionChunk,
 )
+from litellm.types.responses.main import OutputCodeInterpreterCall
 
 
 def test_redacted_thinking_content_block_delta():
@@ -479,14 +480,22 @@ def test_partial_json_chunk_accumulation():
     # First partial chunk should return None (still accumulating)
     result1 = iterator._parse_sse_data(f"data:{partial_chunk_1}")
     assert result1 is None, "First partial chunk should return None while accumulating"
-    assert iterator.chunk_type == "accumulated_json", "Should switch to accumulated_json mode"
-    assert iterator.accumulated_json == partial_chunk_1, "Should have accumulated first part"
+    assert (
+        iterator.chunk_type == "accumulated_json"
+    ), "Should switch to accumulated_json mode"
+    assert (
+        iterator.accumulated_json == partial_chunk_1
+    ), "Should have accumulated first part"
 
     # Second partial chunk should complete the JSON and return a parsed result
     result2 = iterator._parse_sse_data(f"data:{partial_chunk_2}")
     assert result2 is not None, "Second chunk should return parsed result"
-    assert iterator.accumulated_json == "", "Buffer should be cleared after successful parse"
-    assert result2.choices[0].delta.content == "Hello", f"Expected 'Hello', got '{result2.choices[0].delta.content}'"
+    assert (
+        iterator.accumulated_json == ""
+    ), "Buffer should be cleared after successful parse"
+    assert (
+        result2.choices[0].delta.content == "Hello"
+    ), f"Expected 'Hello', got '{result2.choices[0].delta.content}'"
 
 
 def test_complete_json_chunk_no_accumulation():
@@ -503,7 +512,9 @@ def test_complete_json_chunk_no_accumulation():
     assert result is not None, "Complete chunk should return parsed result immediately"
     assert iterator.chunk_type == "valid_json", "Should remain in valid_json mode"
     assert iterator.accumulated_json == "", "Buffer should remain empty"
-    assert result.choices[0].delta.content == "Hello", f"Expected 'Hello', got '{result.choices[0].delta.content}'"
+    assert (
+        result.choices[0].delta.content == "Hello"
+    ), f"Expected 'Hello', got '{result.choices[0].delta.content}'"
 
 
 def test_multiple_partial_chunks_accumulation():
@@ -620,7 +631,9 @@ def test_web_search_tool_result_no_extra_tool_calls():
     # Should have exactly 2 tool calls:
     # 1. From content_block_start (server_tool_use) with id and name
     # 2. From content_block_delta with the actual query
-    assert len(tool_calls_emitted) == 2, f"Expected 2 tool calls, got {len(tool_calls_emitted)}"
+    assert (
+        len(tool_calls_emitted) == 2
+    ), f"Expected 2 tool calls, got {len(tool_calls_emitted)}"
 
     # First tool call should have the id and name
     assert tool_calls_emitted[0]["id"] == "srvtoolu_01ABC123"
@@ -722,7 +735,10 @@ def test_web_search_tool_result_captured_in_provider_specific_fields():
         {
             "type": "content_block_delta",
             "index": 0,
-            "delta": {"type": "input_json_delta", "partial_json": '{"query": "otter facts"}'},
+            "delta": {
+                "type": "input_json_delta",
+                "partial_json": '{"query": "otter facts"}',
+            },
         },
         # 4. content_block_stop for server_tool_use
         {"type": "content_block_stop", "index": 0},
@@ -822,7 +838,10 @@ def test_web_fetch_tool_result_captured_in_provider_specific_fields():
         {
             "type": "content_block_delta",
             "index": 0,
-            "delta": {"type": "input_json_delta", "partial_json": '{"url": "https://example.com"}'},
+            "delta": {
+                "type": "input_json_delta",
+                "partial_json": '{"url": "https://example.com"}',
+            },
         },
         # 4. content_block_stop for server_tool_use
         {"type": "content_block_stop", "index": 0},
@@ -946,7 +965,7 @@ def test_web_fetch_tool_result_no_extra_tool_calls():
 def test_container_in_provider_specific_fields_streaming():
     """
     Test that container is captured in provider_specific_fields for streaming responses.
-    
+
     When container with skills is used, the container field should be present in
     the provider_specific_fields of the message_delta chunk.
     """
@@ -1025,7 +1044,9 @@ def test_container_in_provider_specific_fields_streaming():
             ]
 
     # Verify container was captured
-    assert container_field is not None, "container should be captured in provider_specific_fields"
+    assert (
+        container_field is not None
+    ), "container should be captured in provider_specific_fields"
     assert (
         container_field["id"] == "container_011CW9hA9zpZ8xD3bjjShy4p"
     ), "container id should match"
@@ -1033,18 +1054,14 @@ def test_container_in_provider_specific_fields_streaming():
         container_field["expires_at"] == "2025-12-16T04:57:16.913181Z"
     ), "expires_at should match"
     assert len(container_field["skills"]) == 1, "Should have 1 skill"
-    assert (
-        container_field["skills"][0]["skill_id"] == "pptx"
-    ), "skill_id should be pptx"
-    assert (
-        container_field["skills"][0]["version"] == "20251013"
-    ), "version should match"
+    assert container_field["skills"][0]["skill_id"] == "pptx", "skill_id should be pptx"
+    assert container_field["skills"][0]["version"] == "20251013", "version should match"
 
 
 def test_container_in_provider_specific_fields_non_streaming():
     """
     Test that container is captured in provider_specific_fields for non-streaming responses.
-    
+
     When container with skills is used in non-streaming, the container field should be
     present in the provider_specific_fields of the response.
     """
@@ -1106,7 +1123,7 @@ def test_container_in_provider_specific_fields_non_streaming():
 def test_container_absent_when_not_provided():
     """
     Test that container is not added to provider_specific_fields when not provided.
-    
+
     This ensures we don't add empty or None container fields.
     """
     iterator = ModelResponseIterator(
@@ -1133,3 +1150,434 @@ def test_container_absent_when_not_provided():
         assert (
             "container" not in model_response.choices[0].delta.provider_specific_fields
         ), "container should not be present when not provided in delta"
+
+
+def test_streaming_code_execution_produces_code_interpreter_results():
+    """
+    Test that bash_code_execution_tool_result content blocks in streaming
+    produce code_interpreter_results in provider_specific_fields, so the
+    Responses API layer can use them without Anthropic-specific knowledge.
+    """
+
+    chunks = [
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01XYZ",
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "usage": {"input_tokens": 100, "output_tokens": 1},
+            },
+        },
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "text",
+                "text": "",
+            },
+        },
+        {
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {"type": "text_delta", "text": "Running code..."},
+        },
+        {"type": "content_block_stop", "index": 0},
+        {
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01ABC",
+                "name": "bash_code_execution",
+                "input": {"command": "echo hello"},
+            },
+        },
+        {"type": "content_block_stop", "index": 1},
+        {
+            "type": "content_block_start",
+            "index": 2,
+            "content_block": {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01ABC",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "hello\n",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        },
+        {"type": "content_block_stop", "index": 2},
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn"},
+            "usage": {"output_tokens": 50},
+        },
+    ]
+
+    iterator = ModelResponseIterator(None, sync_stream=True)
+
+    found_code_interpreter_results = False
+    for chunk in chunks:
+        parsed = iterator.chunk_parser(chunk)
+        psf = None
+        if parsed.choices and parsed.choices[0].delta:
+            psf = getattr(parsed.choices[0].delta, "provider_specific_fields", None)
+        if psf and "code_interpreter_results" in psf:
+            found_code_interpreter_results = True
+            results = psf["code_interpreter_results"]
+            assert len(results) == 1
+            assert isinstance(results[0], OutputCodeInterpreterCall)
+            assert results[0].type == "code_interpreter_call"
+            assert results[0].id == "srvtoolu_01ABC"
+            assert results[0].code == "echo hello"
+            assert results[0].outputs is not None
+            assert len(results[0].outputs) == 1
+            assert results[0].outputs[0].logs == "hello\n"
+
+    assert found_code_interpreter_results, (
+        "code_interpreter_results should appear in provider_specific_fields "
+        "when bash_code_execution_tool_result is streamed"
+    )
+
+
+def test_streaming_multiple_code_executions_no_duplicates():
+    """
+    Test that multiple code executions in a single streaming response emit
+    cumulative code_interpreter_results on each chunk (matching stream_chunk_builder's
+    "last value wins" contract).  The final emission must contain ALL results.
+    """
+    chunks = [
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01XYZ",
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "usage": {"input_tokens": 100, "output_tokens": 1},
+            },
+        },
+        # First code execution
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01AAA",
+                "name": "bash_code_execution",
+                "input": {"command": "echo first"},
+            },
+        },
+        {"type": "content_block_stop", "index": 0},
+        {
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01AAA",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "first\n",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        },
+        {"type": "content_block_stop", "index": 1},
+        # Second code execution
+        {
+            "type": "content_block_start",
+            "index": 2,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01BBB",
+                "name": "bash_code_execution",
+                "input": {"command": "echo second"},
+            },
+        },
+        {"type": "content_block_stop", "index": 2},
+        {
+            "type": "content_block_start",
+            "index": 3,
+            "content_block": {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01BBB",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "second\n",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        },
+        {"type": "content_block_stop", "index": 3},
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn"},
+            "usage": {"output_tokens": 50},
+        },
+    ]
+
+    iterator = ModelResponseIterator(None, sync_stream=True)
+
+    # Collect each emission of code_interpreter_results
+    emissions = []
+    for chunk in chunks:
+        parsed = iterator.chunk_parser(chunk)
+        psf = None
+        if parsed.choices and parsed.choices[0].delta:
+            psf = getattr(parsed.choices[0].delta, "provider_specific_fields", None)
+        if psf and "code_interpreter_results" in psf:
+            emissions.append(psf["code_interpreter_results"])
+
+    # Should have 2 emissions (one per tool_result block)
+    assert len(emissions) == 2, f"Expected 2 emissions, got {len(emissions)}"
+
+    # First emission: cumulative list with 1 result
+    assert len(emissions[0]) == 1
+    assert emissions[0][0].id == "srvtoolu_01AAA"
+    assert emissions[0][0].code == "echo first"
+    assert emissions[0][0].outputs[0].logs == "first\n"
+
+    # Second (final) emission: cumulative list with BOTH results
+    # This is what stream_chunk_builder will pick as "last value wins"
+    assert len(emissions[1]) == 2, (
+        f"Expected final emission to have 2 results, got {len(emissions[1])}. "
+        f"IDs: {[r.id for r in emissions[1]]}"
+    )
+    assert emissions[1][0].id == "srvtoolu_01AAA"
+    assert emissions[1][0].code == "echo first"
+    assert emissions[1][0].outputs[0].logs == "first\n"
+    assert emissions[1][1].id == "srvtoolu_01BBB"
+    assert emissions[1][1].code == "echo second"
+    assert emissions[1][1].outputs[0].logs == "second\n"
+
+
+def test_streaming_code_execution_input_assembled_from_deltas():
+    """
+    In real Anthropic streaming, content_block_start for server_tool_use has
+    input: {}.  The actual input arrives via input_json_delta deltas and must
+    be assembled at content_block_stop so the code field is populated.
+
+    This test uses realistic chunk shapes (empty input in start, partial JSON
+    in deltas) to exercise the input assembly path.
+    """
+    chunks = [
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01XYZ",
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "usage": {"input_tokens": 100, "output_tokens": 1},
+            },
+        },
+        # server_tool_use with empty input (real streaming behaviour)
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01AAA",
+                "name": "code_execution",
+                "input": {},
+            },
+        },
+        # Input arrives via deltas, split across two chunks
+        {
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {
+                "type": "input_json_delta",
+                "partial_json": '{"comma',
+            },
+        },
+        {
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {
+                "type": "input_json_delta",
+                "partial_json": 'nd": "echo hello"}',
+            },
+        },
+        {"type": "content_block_stop", "index": 0},
+        # Tool result
+        {
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01AAA",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "hello\n",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        },
+        {"type": "content_block_stop", "index": 1},
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn"},
+            "usage": {"output_tokens": 50},
+        },
+    ]
+
+    iterator = ModelResponseIterator(None, sync_stream=True)
+
+    code_results = None
+    for chunk in chunks:
+        parsed = iterator.chunk_parser(chunk)
+        psf = None
+        if parsed.choices and parsed.choices[0].delta:
+            psf = getattr(parsed.choices[0].delta, "provider_specific_fields", None)
+        if psf and "code_interpreter_results" in psf:
+            code_results = psf["code_interpreter_results"]
+
+    # The code field must contain the assembled input, not be empty
+    assert code_results is not None, "No code_interpreter_results emitted"
+    assert len(code_results) == 1
+    assert code_results[0].id == "srvtoolu_01AAA"
+    assert code_results[0].code == "echo hello"
+    assert code_results[0].outputs[0].logs == "hello\n"
+
+
+def test_empty_output_produces_null_outputs():
+    """
+    When both stdout and stderr are empty, outputs should be None
+    (matching OpenAI's native behavior) rather than [{logs: ""}].
+    """
+    chunks = [
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01XYZ",
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "usage": {"input_tokens": 100, "output_tokens": 1},
+            },
+        },
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01AAA",
+                "name": "bash_code_execution",
+                "input": {"command": "true"},
+            },
+        },
+        {"type": "content_block_stop", "index": 0},
+        {
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01AAA",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        },
+        {"type": "content_block_stop", "index": 1},
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn"},
+            "usage": {"output_tokens": 50},
+        },
+    ]
+
+    iterator = ModelResponseIterator(None, sync_stream=True)
+
+    code_results = None
+    for chunk in chunks:
+        parsed = iterator.chunk_parser(chunk)
+        psf = None
+        if parsed.choices and parsed.choices[0].delta:
+            psf = getattr(parsed.choices[0].delta, "provider_specific_fields", None)
+        if psf and "code_interpreter_results" in psf:
+            code_results = psf["code_interpreter_results"]
+
+    assert code_results is not None, "No code_interpreter_results emitted"
+    assert len(code_results) == 1
+    assert code_results[0].id == "srvtoolu_01AAA"
+    assert (
+        code_results[0].outputs is None
+    ), f"Expected outputs=None for empty execution, got {code_results[0].outputs}"
+
+
+def test_non_bash_tool_result_skipped():
+    """
+    Tool result types other than bash_code_execution_tool_result (e.g.
+    text_editor_code_execution_tool_result) should be skipped and NOT
+    produce code_interpreter_call items.
+    """
+    chunks = [
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01XYZ",
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "usage": {"input_tokens": 100, "output_tokens": 1},
+            },
+        },
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01AAA",
+                "name": "text_editor",
+                "input": {"command": "view", "path": "/tmp/test.py"},
+            },
+        },
+        {"type": "content_block_stop", "index": 0},
+        # text_editor result — should NOT become a code_interpreter_call
+        {
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "type": "text_editor_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01AAA",
+                "content": [
+                    {"type": "text", "text": "file contents here"},
+                ],
+            },
+        },
+        {"type": "content_block_stop", "index": 1},
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn"},
+            "usage": {"output_tokens": 50},
+        },
+    ]
+
+    iterator = ModelResponseIterator(None, sync_stream=True)
+
+    code_results = None
+    for chunk in chunks:
+        parsed = iterator.chunk_parser(chunk)
+        psf = None
+        if parsed.choices and parsed.choices[0].delta:
+            psf = getattr(parsed.choices[0].delta, "provider_specific_fields", None)
+        if psf and "code_interpreter_results" in psf:
+            code_results = psf["code_interpreter_results"]
+
+    # code_interpreter_results should be emitted but empty (no bash results)
+    assert (
+        code_results is not None
+    ), "Expected code_interpreter_results key to be emitted"
+    assert (
+        len(code_results) == 0
+    ), f"Expected 0 code_interpreter_results for text_editor result, got {len(code_results)}"
diff --git a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
index a95b9413b9d..a3469964862 100644
--- a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
+++ b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py
@@ -183,7 +183,9 @@ def test_extract_response_content_with_citations():
         },
     }
 
-    _, citations, _, _, _, _, _, _ = config.extract_response_content(completion_response)
+    _, citations, _, _, _, _, _, _ = config.extract_response_content(
+        completion_response
+    )
     assert citations == [
         [
             {
@@ -305,7 +307,7 @@ def test_web_search_tool_result_extraction():
                 "type": "server_tool_use",
                 "id": "srvtoolu_01ABC123",
                 "name": "web_search",
-                "input": {"query": "average weight african elephant kg"}
+                "input": {"query": "average weight african elephant kg"},
             },
             {
                 "type": "web_search_tool_result",
@@ -317,32 +319,39 @@ def test_web_search_tool_result_extraction():
                         "title": "African Elephant Facts",
                         "encrypted_content": "encrypted_data_here",
                         "page_age": "2024-01-15",
-                        "snippet": "Adult African elephants weigh between 4,000-6,000 kg..."
+                        "snippet": "Adult African elephants weigh between 4,000-6,000 kg...",
                     }
-                ]
+                ],
             },
             {
                 "type": "text",
-                "text": "Based on my search, African elephants weigh around 5,000 kg."
+                "text": "Based on my search, African elephants weigh around 5,000 kg.",
             },
             {
                 "type": "tool_use",
                 "id": "toolu_01XYZ789",
                 "name": "add_numbers",
-                "input": {"a": 5000, "b": 100}
-            }
+                "input": {"a": 5000, "b": 100},
+            },
         ],
         "stop_reason": "tool_use",
         "usage": {
             "input_tokens": 100,
             "output_tokens": 50,
-            "server_tool_use": {"web_search_requests": 1}
-        }
+            "server_tool_use": {"web_search_requests": 1},
+        },
     }
 
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     # Verify text extraction
     assert "Based on my search" in text
@@ -388,7 +397,7 @@ def test_web_search_tool_result_in_provider_specific_fields():
                 "type": "server_tool_use",
                 "id": "srvtoolu_provider_test",
                 "name": "web_search",
-                "input": {"query": "test query"}
+                "input": {"query": "test query"},
             },
             {
                 "type": "web_search_tool_result",
@@ -398,21 +407,18 @@ def test_web_search_tool_result_in_provider_specific_fields():
                         "type": "web_search_result",
                         "url": "https://example.com/test",
                         "title": "Test Result",
-                        "snippet": "Test snippet content"
+                        "snippet": "Test snippet content",
                     }
-                ]
+                ],
             },
-            {
-                "type": "text",
-                "text": "Here is the result."
-            }
+            {"type": "text", "text": "Here is the result."},
         ],
         "stop_reason": "end_turn",
         "usage": {
             "input_tokens": 50,
             "output_tokens": 25,
-            "server_tool_use": {"web_search_requests": 1}
-        }
+            "server_tool_use": {"web_search_requests": 1},
+        },
     }
 
     raw_response = httpx.Response(status_code=200, headers={})
@@ -432,7 +438,10 @@ def test_web_search_tool_result_in_provider_specific_fields():
     assert "web_search_results" in provider_fields
     assert len(provider_fields["web_search_results"]) == 1
     assert provider_fields["web_search_results"][0]["type"] == "web_search_tool_result"
-    assert provider_fields["web_search_results"][0]["tool_use_id"] == "srvtoolu_provider_test"
+    assert (
+        provider_fields["web_search_results"][0]["tool_use_id"]
+        == "srvtoolu_provider_test"
+    )
 
 
 def test_multiple_web_search_tool_results():
@@ -447,34 +456,52 @@ def test_multiple_web_search_tool_results():
                 "type": "server_tool_use",
                 "id": "srvtoolu_search1",
                 "name": "web_search",
-                "input": {"query": "african elephant weight"}
+                "input": {"query": "african elephant weight"},
             },
             {
                 "type": "web_search_tool_result",
                 "tool_use_id": "srvtoolu_search1",
-                "content": [{"type": "web_search_result", "url": "https://example1.com", "title": "Result 1", "snippet": "First result"}]
+                "content": [
+                    {
+                        "type": "web_search_result",
+                        "url": "https://example1.com",
+                        "title": "Result 1",
+                        "snippet": "First result",
+                    }
+                ],
             },
             {
                 "type": "server_tool_use",
                 "id": "srvtoolu_search2",
                 "name": "web_search",
-                "input": {"query": "asian elephant weight"}
+                "input": {"query": "asian elephant weight"},
             },
             {
                 "type": "web_search_tool_result",
                 "tool_use_id": "srvtoolu_search2",
-                "content": [{"type": "web_search_result", "url": "https://example2.com", "title": "Result 2", "snippet": "Second result"}]
+                "content": [
+                    {
+                        "type": "web_search_result",
+                        "url": "https://example2.com",
+                        "title": "Result 2",
+                        "snippet": "Second result",
+                    }
+                ],
             },
-            {
-                "type": "text",
-                "text": "Found information about both elephants."
-            }
+            {"type": "text", "text": "Found information about both elephants."},
         ]
     }
 
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     # Verify both web_search_tool_results are extracted
     assert web_search_results is not None
@@ -751,7 +778,7 @@ def test_anthropic_beta_header_merging_with_output_format():
     optional_params = {
         "output_format": {
             "type": "json_schema",
-            "schema": {"type": "object", "properties": {}}
+            "schema": {"type": "object", "properties": {}},
         }
     }
 
@@ -761,10 +788,12 @@ def test_anthropic_beta_header_merging_with_output_format():
 
     # Both beta headers should be present
     beta_value = result_headers["anthropic-beta"]
-    assert "context-1m-2025-08-07" in beta_value, \
-        f"User's context-1m beta header missing from: {beta_value}"
-    assert "structured-outputs-2025-11-13" in beta_value, \
-        f"Structured output beta header missing from: {beta_value}"
+    assert (
+        "context-1m-2025-08-07" in beta_value
+    ), f"User's context-1m beta header missing from: {beta_value}"
+    assert (
+        "structured-outputs-2025-11-13" in beta_value
+    ), f"Structured output beta header missing from: {beta_value}"
 
 
 def test_anthropic_beta_header_merging_with_multiple_features():
@@ -780,10 +809,10 @@ def test_anthropic_beta_header_merging_with_multiple_features():
     optional_params = {
         "output_format": {
             "type": "json_schema",
-            "schema": {"type": "object", "properties": {}}
+            "schema": {"type": "object", "properties": {}},
         },
         "context_management": _sample_context_management_payload(),
-        "tools": [{"type": "web_fetch_20250910", "name": "web_fetch"}]
+        "tools": [{"type": "web_fetch_20250910", "name": "web_fetch"}],
     }
 
     result_headers = config.update_headers_with_optional_anthropic_beta(
@@ -950,20 +979,12 @@ def test_tool_search_regex_detection():
 
     # Test with tool search regex tool
     tools = [
-        {
-            "type": "tool_search_tool_regex_20251119",
-            "name": "tool_search_tool_regex"
-        }
+        {"type": "tool_search_tool_regex_20251119", "name": "tool_search_tool_regex"}
     ]
     assert config.is_tool_search_used(tools) is True
 
     # Test without tool search
-    tools = [
-        {
-            "type": "function",
-            "function": {"name": "get_weather"}
-        }
-    ]
+    tools = [{"type": "function", "function": {"name": "get_weather"}}]
     assert config.is_tool_search_used(tools) is False
 
 
@@ -975,10 +996,7 @@ def test_tool_search_bm25_detection():
 
     # Test with tool search BM25 tool
     tools = [
-        {
-            "type": "tool_search_tool_bm25_20251119",
-            "name": "tool_search_tool_bm25"
-        }
+        {"type": "tool_search_tool_bm25_20251119", "name": "tool_search_tool_bm25"}
     ]
     assert config.is_tool_search_used(tools) is True
 
@@ -1002,10 +1020,7 @@ def test_tool_search_regex_mapping():
     """Test that tool search regex tools are properly mapped"""
     config = AnthropicConfig()
 
-    tool = {
-        "type": "tool_search_tool_regex_20251119",
-        "name": "tool_search_tool_regex"
-    }
+    tool = {"type": "tool_search_tool_regex_20251119", "name": "tool_search_tool_regex"}
 
     mapped_tool, mcp_server = config._map_tool_helper(tool)
 
@@ -1019,10 +1034,7 @@ def test_tool_search_bm25_mapping():
     """Test that tool search BM25 tools are properly mapped"""
     config = AnthropicConfig()
 
-    tool = {
-        "type": "tool_search_tool_bm25_20251119",
-        "name": "tool_search_tool_bm25"
-    }
+    tool = {"type": "tool_search_tool_bm25_20251119", "name": "tool_search_tool_bm25"}
 
     mapped_tool, mcp_server = config._map_tool_helper(tool)
 
@@ -1037,20 +1049,17 @@ def test_deferred_tools_separation():
     config = AnthropicConfig()
 
     tools = [
-        {
-            "type": "tool_search_tool_regex_20251119",
-            "name": "tool_search_tool_regex"
-        },
+        {"type": "tool_search_tool_regex_20251119", "name": "tool_search_tool_regex"},
         {
             "type": "function",
             "function": {"name": "get_weather"},
-            "defer_loading": True
+            "defer_loading": True,
         },
         {
             "type": "function",
             "function": {"name": "search_files"},
-            "defer_loading": False
-        }
+            "defer_loading": False,
+        },
     ]
 
     non_deferred, deferred = config._separate_deferred_tools(tools)
@@ -1069,14 +1078,21 @@ def test_server_tool_use_in_response():
                 "type": "server_tool_use",
                 "id": "srvtoolu_01ABC123",
                 "name": "tool_search_tool_regex",
-                "input": {"query": "weather"}
+                "input": {"query": "weather"},
             }
         ]
     }
 
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     assert len(tool_calls) == 1
     assert tool_calls[0]["id"] == "srvtoolu_01ABC123"
@@ -1091,9 +1107,7 @@ def test_tool_search_usage_tracking():
     usage_object = {
         "input_tokens": 100,
         "output_tokens": 50,
-        "server_tool_use": {
-            "tool_search_requests": 2
-        }
+        "server_tool_use": {"tool_search_requests": 2},
     }
 
     usage = config.calculate_usage(usage_object=usage_object, reasoning_content=None)
@@ -1109,16 +1123,13 @@ def test_tool_reference_expansion():
     deferred_tools = [
         {
             "type": "function",
-            "function": {
-                "name": "get_weather",
-                "description": "Get weather"
-            }
+            "function": {"name": "get_weather", "description": "Get weather"},
         }
     ]
 
     content = [
         {"type": "text", "text": "I'll search for tools"},
-        {"type": "tool_reference", "tool_name": "get_weather"}
+        {"type": "tool_reference", "tool_name": "get_weather"},
     ]
 
     expanded = config._expand_tool_references(content, deferred_tools)
@@ -1140,13 +1151,11 @@ def test_defer_loading_preserved_in_transformation():
             "description": "Get weather information",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "location": {"type": "string"}
-                },
-                "required": ["location"]
-            }
+                "properties": {"location": {"type": "string"}},
+                "required": ["location"],
+            },
         },
-        "defer_loading": True
+        "defer_loading": True,
     }
 
     mapped_tool, mcp_server = config._map_tool_helper(tool)
@@ -1166,45 +1175,51 @@ def test_tool_search_complete_response_parsing():
         "content": [
             {
                 "type": "text",
-                "text": "I'll search for weather-related tools that can help you."
+                "text": "I'll search for weather-related tools that can help you.",
             },
             {
                 "type": "server_tool_use",
                 "id": "srvtoolu_015i6aVA2niwzv4RG4DtnxDJ",
                 "name": "tool_search_tool_regex",
                 "input": {"pattern": "weather", "limit": 5},
-                "caller": {"type": "direct"}
+                "caller": {"type": "direct"},
             },
             {
                 "type": "tool_search_tool_result",
                 "tool_use_id": "srvtoolu_015i6aVA2niwzv4RG4DtnxDJ",
                 "content": {
                     "type": "tool_search_tool_search_result",
-                    "tool_references": [{"type": "tool_reference", "tool_name": "get_weather"}]
-                }
-            },
-            {
-                "type": "text",
-                "text": "Great! I found a weather tool."
+                    "tool_references": [
+                        {"type": "tool_reference", "tool_name": "get_weather"}
+                    ],
+                },
             },
+            {"type": "text", "text": "Great! I found a weather tool."},
             {
                 "type": "tool_use",
                 "id": "toolu_01CrCNx4ntSaeeV9iArT4JfQ",
                 "name": "get_weather",
-                "input": {"location": "San Francisco"}
-            }
+                "input": {"location": "San Francisco"},
+            },
         ],
         "usage": {
             "input_tokens": 1639,
             "output_tokens": 170,
-            "server_tool_use": {"web_search_requests": 0}
-        }
+            "server_tool_use": {"web_search_requests": 0},
+        },
     }
 
     # Extract content
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     # Verify text extraction (should concatenate both text blocks)
     assert "I'll search for weather-related tools" in text
@@ -1222,12 +1237,14 @@ def test_tool_search_complete_response_parsing():
     usage = config.calculate_usage(
         usage_object=completion_response["usage"],
         reasoning_content=None,
-        completion_response=completion_response
+        completion_response=completion_response,
     )
 
     assert usage.server_tool_use is not None
     assert usage.server_tool_use.web_search_requests == 0
-    assert usage.server_tool_use.tool_search_requests == 1  # Counted from server_tool_use blocks
+    assert (
+        usage.server_tool_use.tool_search_requests == 1
+    )  # Counted from server_tool_use blocks
 
 
 def test_allowed_callers_field_preservation():
@@ -1242,13 +1259,11 @@ def test_allowed_callers_field_preservation():
             "description": "Execute a SQL query",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "sql": {"type": "string"}
-                },
-                "required": ["sql"]
-            }
+                "properties": {"sql": {"type": "string"}},
+                "required": ["sql"],
+            },
         },
-        "allowed_callers": ["code_execution_20250825"]
+        "allowed_callers": ["code_execution_20250825"],
     }
 
     transformed_tool, _ = config._map_tool_helper(tool_with_allowed_callers)
@@ -1265,19 +1280,16 @@ def test_programmatic_tool_calling_beta_header():
 
     # Test detection with allowed_callers
     tools = [
-        {
-            "type": "code_execution_20250825",
-            "name": "code_execution"
-        },
+        {"type": "code_execution_20250825", "name": "code_execution"},
         {
             "type": "function",
             "function": {
                 "name": "query_database",
                 "description": "Execute a SQL query",
-                "parameters": {"type": "object", "properties": {}}
+                "parameters": {"type": "object", "properties": {}},
             },
-            "allowed_callers": ["code_execution_20250825"]
-        }
+            "allowed_callers": ["code_execution_20250825"],
+        },
     ]
 
     is_programmatic = model_info.is_programmatic_tool_calling_used(tools)
@@ -1285,8 +1297,7 @@ def test_programmatic_tool_calling_beta_header():
 
     # Test header generation
     headers = model_info.get_anthropic_headers(
-        api_key="test-key",
-        programmatic_tool_calling_used=True
+        api_key="test-key", programmatic_tool_calling_used=True
     )
 
     assert "anthropic-beta" in headers
@@ -1303,10 +1314,7 @@ def test_caller_field_in_response():
         "type": "message",
         "role": "assistant",
         "content": [
-            {
-                "type": "text",
-                "text": "I'll query the database."
-            },
+            {"type": "text", "text": "I'll query the database."},
             {
                 "type": "tool_use",
                 "id": "toolu_123",
@@ -1314,15 +1322,24 @@ def test_caller_field_in_response():
                 "input": {"sql": "SELECT * FROM users"},
                 "caller": {
                     "type": "code_execution_20250825",
-                    "tool_id": "srvtoolu_abc"
-                }
-            }
+                    "tool_id": "srvtoolu_abc",
+                },
+            },
         ],
         "stop_reason": "tool_use",
-        "usage": {"input_tokens": 100, "output_tokens": 50}
+        "usage": {"input_tokens": 100, "output_tokens": 50},
     }
 
-    text, citations, thinking, reasoning, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(completion_response)
+    (
+        text,
+        citations,
+        thinking,
+        reasoning,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     assert len(tool_calls) == 1
     assert tool_calls[0]["id"] == "toolu_123"
@@ -1337,10 +1354,7 @@ def test_code_execution_20250825_tool_type():
     """Test that code_execution_20250825 tool type is handled correctly."""
     config = AnthropicConfig()
 
-    tool = {
-        "type": "code_execution_20250825",
-        "name": "code_execution"
-    }
+    tool = {"type": "code_execution_20250825", "name": "code_execution"}
 
     transformed_tool, _ = config._map_tool_helper(tool)
     assert transformed_tool is not None
@@ -1360,13 +1374,11 @@ def test_allowed_callers_in_function_field():
             "description": "Execute a SQL query",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "sql": {"type": "string"}
-                },
-                "required": ["sql"]
+                "properties": {"sql": {"type": "string"}},
+                "required": ["sql"],
             },
-            "allowed_callers": ["code_execution_20250825"]
-        }
+            "allowed_callers": ["code_execution_20250825"],
+        },
     }
 
     transformed_tool, _ = config._map_tool_helper(tool)
@@ -1389,15 +1401,15 @@ def test_input_examples_field_preservation():
                 "type": "object",
                 "properties": {
                     "location": {"type": "string"},
-                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
+                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                 },
-                "required": ["location"]
-            }
+                "required": ["location"],
+            },
         },
         "input_examples": [
             {"location": "San Francisco, CA", "unit": "fahrenheit"},
-            {"location": "Tokyo, Japan", "unit": "celsius"}
-        ]
+            {"location": "Tokyo, Japan", "unit": "celsius"},
+        ],
     }
 
     transformed_tool, _ = config._map_tool_helper(tool_with_examples)
@@ -1420,11 +1432,9 @@ def test_input_examples_beta_header():
             "function": {
                 "name": "get_weather",
                 "description": "Get weather information",
-                "parameters": {"type": "object", "properties": {}}
+                "parameters": {"type": "object", "properties": {}},
             },
-            "input_examples": [
-                {"location": "San Francisco, CA"}
-            ]
+            "input_examples": [{"location": "San Francisco, CA"}],
         }
     ]
 
@@ -1433,8 +1443,7 @@ def test_input_examples_beta_header():
 
     # Test header generation
     headers = model_info.get_anthropic_headers(
-        api_key="test-key",
-        input_examples_used=True
+        api_key="test-key", input_examples_used=True
     )
 
     assert "anthropic-beta" in headers
@@ -1453,16 +1462,14 @@ def test_input_examples_in_function_field():
             "description": "Get weather information",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "location": {"type": "string"}
-                },
-                "required": ["location"]
+                "properties": {"location": {"type": "string"}},
+                "required": ["location"],
             },
             "input_examples": [
                 {"location": "Paris, France"},
-                {"location": "London, UK"}
-            ]
-        }
+                {"location": "London, UK"},
+            ],
+        },
     }
 
     transformed_tool, _ = config._map_tool_helper(tool)
@@ -1483,17 +1490,13 @@ def test_input_examples_with_other_features():
             "description": "Execute a SQL query",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "sql": {"type": "string"}
-                },
-                "required": ["sql"]
-            }
+                "properties": {"sql": {"type": "string"}},
+                "required": ["sql"],
+            },
         },
-        "input_examples": [
-            {"sql": "SELECT * FROM users WHERE id = 1"}
-        ],
+        "input_examples": [{"sql": "SELECT * FROM users WHERE id = 1"}],
         "defer_loading": True,
-        "allowed_callers": ["code_execution_20250825"]
+        "allowed_callers": ["code_execution_20250825"],
     }
 
     transformed_tool, _ = config._map_tool_helper(tool)
@@ -1517,19 +1520,20 @@ def test_input_examples_empty_list_not_added():
             "description": "Get weather information",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "location": {"type": "string"}
-                },
-                "required": ["location"]
-            }
+                "properties": {"location": {"type": "string"}},
+                "required": ["location"],
+            },
         },
-        "input_examples": []
+        "input_examples": [],
     }
 
     transformed_tool, _ = config._map_tool_helper(tool)
     assert transformed_tool is not None
     # Empty list should not be added
-    assert "input_examples" not in transformed_tool or len(transformed_tool.get("input_examples", [])) == 0
+    assert (
+        "input_examples" not in transformed_tool
+        or len(transformed_tool.get("input_examples", [])) == 0
+    )
 
 
 # ============ Effort Parameter Tests ============
@@ -1540,18 +1544,14 @@ def test_effort_output_config_preservation():
     config = AnthropicConfig()
 
     messages = [{"role": "user", "content": "Analyze this code"}]
-    optional_params = {
-        "output_config": {
-            "effort": "medium"
-        }
-    }
+    optional_params = {"output_config": {"effort": "medium"}}
 
     result = config.transform_request(
         model="claude-opus-4-5-20251101",
         messages=messages,
         optional_params=optional_params,
         litellm_params={},
-        headers={}
+        headers={},
     )
 
     assert "output_config" in result
@@ -1565,18 +1565,13 @@ def test_effort_beta_header_injection():
     model_info = AnthropicModelInfo()
 
     # Test with effort parameter
-    optional_params = {
-        "output_config": {
-            "effort": "low"
-        }
-    }
+    optional_params = {"output_config": {"effort": "low"}}
 
     effort_used = model_info.is_effort_used(optional_params=optional_params)
     assert effort_used is True
 
     headers = model_info.get_anthropic_headers(
-        api_key="test-key",
-        effort_used=effort_used
+        api_key="test-key", effort_used=effort_used
     )
 
     assert "anthropic-beta" in headers
@@ -1597,7 +1592,7 @@ def test_effort_validation():
             messages=messages,
             optional_params=optional_params,
             litellm_params={},
-            headers={}
+            headers={},
         )
         assert result["output_config"]["effort"] == effort
 
@@ -1609,7 +1604,7 @@ def test_effort_validation():
             messages=messages,
             optional_params=optional_params,
             litellm_params={},
-            headers={}
+            headers={},
         )
 
 
@@ -1618,18 +1613,14 @@ def test_effort_with_claude_opus_45():
     config = AnthropicConfig()
 
     messages = [{"role": "user", "content": "Complex analysis task"}]
-    optional_params = {
-        "output_config": {
-            "effort": "high"
-        }
-    }
+    optional_params = {"output_config": {"effort": "high"}}
 
     result = config.transform_request(
         model="claude-opus-4-5-20251101",
         messages=messages,
         optional_params=optional_params,
         litellm_params={},
-        headers={}
+        headers={},
     )
 
     assert "output_config" in result
@@ -1650,7 +1641,7 @@ def test_effort_validation_with_opus_46():
             messages=messages,
             optional_params=optional_params,
             litellm_params={},
-            headers={}
+            headers={},
         )
         assert result["output_config"]["effort"] == effort
 
@@ -1661,14 +1652,16 @@ def test_max_effort_rejected_for_opus_45():
 
     messages = [{"role": "user", "content": "Test"}]
 
-    with pytest.raises(ValueError, match="effort='max' is only supported by Claude Opus 4.6"):
+    with pytest.raises(
+        ValueError, match="effort='max' is only supported by Claude Opus 4.6"
+    ):
         optional_params = {"output_config": {"effort": "max"}}
         config.transform_request(
             model="claude-opus-4-5-20251101",
             messages=messages,
             optional_params=optional_params,
             litellm_params={},
-            headers={}
+            headers={},
         )
 
 
@@ -1685,23 +1678,16 @@ def test_effort_with_other_features():
                 "description": "Get data",
                 "parameters": {
                     "type": "object",
-                    "properties": {
-                        "query": {"type": "string"}
-                    },
-                    "required": ["query"]
-                }
-            }
+                    "properties": {"query": {"type": "string"}},
+                    "required": ["query"],
+                },
+            },
         }
     ]
     optional_params = {
-        "output_config": {
-            "effort": "low"
-        },
+        "output_config": {"effort": "low"},
         "tools": tools,
-        "thinking": {
-            "type": "enabled",
-            "budget_tokens": 1000
-        }
+        "thinking": {"type": "enabled", "budget_tokens": 1000},
     }
 
     result = config.transform_request(
@@ -1709,7 +1695,7 @@ def test_effort_with_other_features():
         messages=messages,
         optional_params=optional_params,
         litellm_params={},
-        headers={}
+        headers={},
     )
 
     # Verify all features are present
@@ -1752,11 +1738,14 @@ def test_translate_system_message_skips_empty_list_content():
 
     # Test list content with empty text block
     messages = [
-        {"role": "system", "content": [
-            {"type": "text", "text": ""},
-            {"type": "text", "text": "Valid content"},
-            {"type": "text", "text": ""},
-        ]},
+        {
+            "role": "system",
+            "content": [
+                {"type": "text", "text": ""},
+                {"type": "text", "text": "Valid content"},
+                {"type": "text", "text": ""},
+            ],
+        },
         {"role": "user", "content": "Hello"},
     ]
 
@@ -1794,9 +1783,16 @@ def test_translate_system_message_preserves_cache_control():
 
     # Test list content with cache_control
     messages = [
-        {"role": "system", "content": [
-            {"type": "text", "text": "Cached content", "cache_control": {"type": "ephemeral"}},
-        ]},
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Cached content",
+                    "cache_control": {"type": "ephemeral"},
+                },
+            ],
+        },
         {"role": "user", "content": "Hello"},
     ]
 
@@ -1938,7 +1934,7 @@ def test_transform_request_uses_dynamic_max_tokens():
         messages=messages,
         optional_params={},  # No max_tokens provided
         litellm_params={},
-        headers={}
+        headers={},
     )
 
     assert result["max_tokens"] == 64000
@@ -1959,7 +1955,7 @@ def test_transform_request_respects_user_max_tokens():
         messages=messages,
         optional_params={"max_tokens": 1000},
         litellm_params={},
-        headers={}
+        headers={},
     )
 
     assert result["max_tokens"] == 1000
@@ -2006,11 +2002,12 @@ def test_calculate_usage_completion_tokens_details_with_reasoning():
         "output_tokens": 500,
     }
     # Simulating reasoning content that would count as ~50 tokens
-    reasoning_content = "Let me think about this step by step. " * 10  # Roughly 50 tokens
+    reasoning_content = (
+        "Let me think about this step by step. " * 10
+    )  # Roughly 50 tokens
 
     usage = config.calculate_usage(
-        usage_object=usage_object,
-        reasoning_content=reasoning_content
+        usage_object=usage_object, reasoning_content=reasoning_content
     )
 
     # completion_tokens_details should be populated with both reasoning and text tokens
@@ -2051,7 +2048,7 @@ def test_reasoning_effort_maps_to_adaptive_thinking_for_claude_4_6_models():
                 non_default_params=non_default_params,
                 optional_params=optional_params,
                 model=model,
-                drop_params=False
+                drop_params=False,
             )
 
             # Should map to adaptive thinking type
@@ -2062,7 +2059,9 @@ def test_reasoning_effort_maps_to_adaptive_thinking_for_claude_4_6_models():
             # reasoning_effort should not be in the result (it's transformed to thinking)
             assert "reasoning_effort" not in result
             # Should set output_config with the mapped effort value
-            assert "output_config" in result, f"output_config missing for {model} with effort={effort}"
+            assert (
+                "output_config" in result
+            ), f"output_config missing for {model} with effort={effort}"
             assert result["output_config"]["effort"] == effort_map[effort]
 
 
@@ -2123,10 +2122,10 @@ def test_reasoning_effort_maps_to_budget_thinking_for_non_opus_4_6():
 
     # Test with Claude Sonnet 4.5 (non-Opus 4.6 model)
     test_cases = [
-        ("low", 1024),      # DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET
-        ("medium", 2048),   # DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET
-        ("high", 4096),     # DEFAULT_REASONING_EFFORT_HIGH_THINKING_BUDGET
-        ("minimal", 128),   # DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET
+        ("low", 1024),  # DEFAULT_REASONING_EFFORT_LOW_THINKING_BUDGET
+        ("medium", 2048),  # DEFAULT_REASONING_EFFORT_MEDIUM_THINKING_BUDGET
+        ("high", 4096),  # DEFAULT_REASONING_EFFORT_HIGH_THINKING_BUDGET
+        ("minimal", 128),  # DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET
     ]
 
     for effort, expected_budget in test_cases:
@@ -2137,7 +2136,7 @@ def test_reasoning_effort_maps_to_budget_thinking_for_non_opus_4_6():
             non_default_params=non_default_params,
             optional_params=optional_params,
             model="claude-sonnet-4-5-20250929",
-            drop_params=False
+            drop_params=False,
         )
 
         # Should map to enabled thinking type with budget_tokens
@@ -2166,9 +2165,9 @@ def test_reasoning_effort_sets_output_config_for_46_models():
                 drop_params=False,
             )
 
-            assert "output_config" in result, (
-                f"output_config missing for {model} with effort={effort}"
-            )
+            assert (
+                "output_config" in result
+            ), f"output_config missing for {model} with effort={effort}"
             assert result["output_config"]["effort"] == effort
 
 
@@ -2207,9 +2206,9 @@ def test_reasoning_effort_does_not_set_output_config_for_older_models():
             drop_params=False,
         )
 
-        assert "output_config" not in result, (
-            f"output_config should not be set for {model}"
-        )
+        assert (
+            "output_config" not in result
+        ), f"output_config should not be set for {model}"
 
 
 def test_max_effort_rejected_for_sonnet_46():
@@ -2217,7 +2216,9 @@ def test_max_effort_rejected_for_sonnet_46():
     config = AnthropicConfig()
     messages = [{"role": "user", "content": "Test"}]
 
-    with pytest.raises(ValueError, match="effort='max' is only supported by Claude Opus 4.6"):
+    with pytest.raises(
+        ValueError, match="effort='max' is only supported by Claude Opus 4.6"
+    ):
         config.transform_request(
             model="claude-sonnet-4-6-20260219",
             messages=messages,
@@ -2260,9 +2261,7 @@ def test_effort_beta_header_not_injected_for_46_models():
             optional_params={"output_config": {"effort": "high"}},
             model=model,
         )
-        assert result is False, (
-            f"is_effort_used should return False for {model}"
-        )
+        assert result is False, f"is_effort_used should return False for {model}"
 
 
 def test_effort_beta_header_still_injected_for_older_models():
@@ -2302,17 +2301,12 @@ def test_code_execution_tool_results_extraction():
         "role": "assistant",
         "model": "claude-sonnet-4-5-20250929",
         "content": [
-            {
-                "type": "text",
-                "text": "I'll calculate that for you."
-            },
+            {"type": "text", "text": "I'll calculate that for you."},
             {
                 "type": "server_tool_use",
                 "id": "srvtoolu_01ABC",
                 "name": "bash_code_execution",
-                "input": {
-                    "command": "python3 << 'EOF'\nprint(2 + 2)\nEOF\n"
-                }
+                "input": {"command": "python3 << 'EOF'\nprint(2 + 2)\nEOF\n"},
             },
             {
                 "type": "bash_code_execution_tool_result",
@@ -2321,8 +2315,8 @@ def test_code_execution_tool_results_extraction():
                     "type": "bash_code_execution_result",
                     "stdout": "4\n",
                     "stderr": "",
-                    "return_code": 0
-                }
+                    "return_code": 0,
+                },
             },
             {
                 "type": "server_tool_use",
@@ -2331,28 +2325,22 @@ def test_code_execution_tool_results_extraction():
                 "input": {
                     "command": "create",
                     "path": "test.txt",
-                    "file_text": "Hello"
-                }
+                    "file_text": "Hello",
+                },
             },
             {
                 "type": "text_editor_code_execution_tool_result",
                 "tool_use_id": "srvtoolu_01DEF",
                 "content": {
                     "type": "text_editor_code_execution_result",
-                    "is_file_update": False
-                }
+                    "is_file_update": False,
+                },
             },
-            {
-                "type": "text",
-                "text": "Done!"
-            }
+            {"type": "text", "text": "Done!"},
         ],
         "stop_reason": "stop",
         "stop_sequence": None,
-        "usage": {
-            "input_tokens": 100,
-            "output_tokens": 50
-        }
+        "usage": {"input_tokens": 100, "output_tokens": 50},
     }
 
     # Create mock HTTP response
@@ -2377,11 +2365,17 @@ def test_code_execution_tool_results_extraction():
 
     # Verify first tool call
     assert transformed_response.choices[0].message.tool_calls[0].id == "srvtoolu_01ABC"
-    assert transformed_response.choices[0].message.tool_calls[0].function.name == "bash_code_execution"
+    assert (
+        transformed_response.choices[0].message.tool_calls[0].function.name
+        == "bash_code_execution"
+    )
 
     # Verify second tool call
     assert transformed_response.choices[0].message.tool_calls[1].id == "srvtoolu_01DEF"
-    assert transformed_response.choices[0].message.tool_calls[1].function.name == "text_editor_code_execution"
+    assert (
+        transformed_response.choices[0].message.tool_calls[1].function.name
+        == "text_editor_code_execution"
+    )
 
     # Verify tool results are in provider_specific_fields
     provider_fields = transformed_response.choices[0].message.provider_specific_fields
@@ -2404,10 +2398,83 @@ def test_code_execution_tool_results_extraction():
     assert editor_result["content"]["is_file_update"] is False
 
     # Verify text content is properly concatenated
-    assert "I'll calculate that for you." in transformed_response.choices[0].message.content
+    assert (
+        "I'll calculate that for you."
+        in transformed_response.choices[0].message.content
+    )
     assert "Done!" in transformed_response.choices[0].message.content
 
 
+def test_code_execution_tool_results_in_hidden_params():
+    """
+    Test that tool_results reaches _hidden_params so the Responses API adapter
+    can surface them via provider_specific_fields.
+
+    The Responses API adapter reads _hidden_params.get("provider_specific_fields")
+    to set provider_specific_fields on the response. Without this, server-side
+    code execution results (stdout/stderr) are lost when using responses.create().
+    """
+    import httpx
+
+    from litellm.types.utils import ModelResponse
+
+    config = AnthropicConfig()
+
+    mock_anthropic_response = {
+        "id": "msg_01XYZ",
+        "type": "message",
+        "role": "assistant",
+        "model": "claude-sonnet-4-5-20250929",
+        "content": [
+            {"type": "text", "text": "Here's the result."},
+            {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01ABC",
+                "name": "bash_code_execution",
+                "input": {"command": "echo hello"},
+            },
+            {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01ABC",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "hello\n",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        ],
+        "stop_reason": "stop",
+        "stop_sequence": None,
+        "usage": {"input_tokens": 100, "output_tokens": 50},
+    }
+
+    mock_raw_response = MagicMock(spec=httpx.Response)
+    mock_raw_response.json.return_value = mock_anthropic_response
+    mock_raw_response.status_code = 200
+    mock_raw_response.headers = {}
+
+    model_response = ModelResponse()
+
+    transformed_response = config.transform_parsed_response(
+        completion_response=mock_anthropic_response,
+        raw_response=mock_raw_response,
+        model_response=model_response,
+        json_mode=False,
+        prefix_prompt=None,
+    )
+
+    # Verify tool_results is in _hidden_params for the Responses API adapter
+    hidden = transformed_response._hidden_params
+    assert "provider_specific_fields" in hidden
+    assert "tool_results" in hidden["provider_specific_fields"]
+    assert len(hidden["provider_specific_fields"]["tool_results"]) == 1
+    assert (
+        hidden["provider_specific_fields"]["tool_results"][0]["content"]["stdout"]
+        == "hello\n"
+    )
+
+
 def test_tool_search_tool_result_not_in_tool_results():
     """
     Test that tool_search_tool_result is NOT included in tool_results
@@ -2425,21 +2492,12 @@ def test_tool_search_tool_result_not_in_tool_results():
         "role": "assistant",
         "model": "claude-sonnet-4-5-20250929",
         "content": [
-            {
-                "type": "text",
-                "text": "Found tools."
-            },
-            {
-                "type": "tool_search_tool_result",
-                "tool_references": ["tool1", "tool2"]
-            }
+            {"type": "text", "text": "Found tools."},
+            {"type": "tool_search_tool_result", "tool_references": ["tool1", "tool2"]},
         ],
         "stop_reason": "stop",
         "stop_sequence": None,
-        "usage": {
-            "input_tokens": 100,
-            "output_tokens": 50
-        }
+        "usage": {"input_tokens": 100, "output_tokens": 50},
     }
 
     mock_raw_response = MagicMock(spec=httpx.Response)
@@ -2479,22 +2537,16 @@ def test_web_search_tool_result_backwards_compatibility():
         "role": "assistant",
         "model": "claude-sonnet-4-5-20250929",
         "content": [
-            {
-                "type": "text",
-                "text": "Here are the results."
-            },
+            {"type": "text", "text": "Here are the results."},
             {
                 "type": "web_search_tool_result",
                 "search_query": "test query",
-                "results": [{"title": "Result 1", "url": "https://example.com"}]
-            }
+                "results": [{"title": "Result 1", "url": "https://example.com"}],
+            },
         ],
         "stop_reason": "stop",
         "stop_sequence": None,
-        "usage": {
-            "input_tokens": 100,
-            "output_tokens": 50
-        }
+        "usage": {"input_tokens": 100, "output_tokens": 50},
     }
 
     mock_raw_response = MagicMock(spec=httpx.Response)
@@ -2540,24 +2592,28 @@ def test_compaction_block_extraction():
         "content": [
             {
                 "type": "compaction",
-                "content": "Summary of the conversation: The user requested help building a web scraper..."
+                "content": "Summary of the conversation: The user requested help building a web scraper...",
             },
             {
                 "type": "text",
-                "text": "I don't have access to real-time data, so I can't provide the current weather in San Francisco."
-            }
+                "text": "I don't have access to real-time data, so I can't provide the current weather in San Francisco.",
+            },
         ],
         "stop_reason": "max_tokens",
         "stop_sequence": None,
-        "usage": {
-            "input_tokens": 86,
-            "output_tokens": 100
-        }
+        "usage": {"input_tokens": 86, "output_tokens": 100},
     }
 
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     # Verify compaction blocks are extracted
     assert compaction_blocks is not None
@@ -2587,18 +2643,12 @@ def test_compaction_block_in_provider_specific_fields():
         "content": [
             {
                 "type": "compaction",
-                "content": "Summary of the conversation: The user requested help building a web scraper..."
+                "content": "Summary of the conversation: The user requested help building a web scraper...",
             },
-            {
-                "type": "text",
-                "text": "Here is the response."
-            }
+            {"type": "text", "text": "Here is the response."},
         ],
         "stop_reason": "end_turn",
-        "usage": {
-            "input_tokens": 50,
-            "output_tokens": 25
-        }
+        "usage": {"input_tokens": 50, "output_tokens": 25},
     }
 
     raw_response = httpx.Response(status_code=200, headers={})
@@ -2618,7 +2668,10 @@ def test_compaction_block_in_provider_specific_fields():
     assert "compaction_blocks" in provider_fields
     assert len(provider_fields["compaction_blocks"]) == 1
     assert provider_fields["compaction_blocks"][0]["type"] == "compaction"
-    assert "Summary of the conversation" in provider_fields["compaction_blocks"][0]["content"]
+    assert (
+        "Summary of the conversation"
+        in provider_fields["compaction_blocks"][0]["content"]
+    )
 
 
 def test_multiple_compaction_blocks():
@@ -2629,24 +2682,22 @@ def test_multiple_compaction_blocks():
 
     completion_response = {
         "content": [
-            {
-                "type": "compaction",
-                "content": "First summary..."
-            },
-            {
-                "type": "text",
-                "text": "Some text."
-            },
-            {
-                "type": "compaction",
-                "content": "Second summary..."
-            }
+            {"type": "compaction", "content": "First summary..."},
+            {"type": "text", "text": "Some text."},
+            {"type": "compaction", "content": "Second summary..."},
         ]
     }
 
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     # Verify both compaction blocks are extracted
     assert compaction_blocks is not None
@@ -2665,37 +2716,26 @@ def test_compaction_block_request_transformation():
     )
 
     messages = [
-        {
-            "role": "user",
-            "content": "What is the weather in San Francisco?"
-        },
+        {"role": "user", "content": "What is the weather in San Francisco?"},
         {
             "role": "assistant",
             "content": [
-                {
-                    "type": "text",
-                    "text": "I don't have access to real-time data."
-                }
+                {"type": "text", "text": "I don't have access to real-time data."}
             ],
             "provider_specific_fields": {
                 "compaction_blocks": [
                     {
                         "type": "compaction",
-                        "content": "Summary of the conversation: The user requested help building a web scraper..."
+                        "content": "Summary of the conversation: The user requested help building a web scraper...",
                     }
                 ]
-            }
+            },
         },
-        {
-            "role": "user",
-            "content": "What about New York?"
-        }
+        {"role": "user", "content": "What about New York?"},
     ]
 
     result = anthropic_messages_pt(
-        messages=messages,
-        model="claude-opus-4-6",
-        llm_provider="anthropic"
+        messages=messages, model="claude-opus-4-6", llm_provider="anthropic"
     )
 
     # Find the assistant message
@@ -2727,14 +2767,8 @@ def test_compaction_with_context_management():
 
     messages = [{"role": "user", "content": "Hello"}]
     optional_params = {
-        "context_management": {
-            "edits": [
-                {
-                    "type": "compact_20260112"
-                }
-            ]
-        },
-        "max_tokens": 100
+        "context_management": {"edits": [{"type": "compact_20260112"}]},
+        "max_tokens": 100,
     }
 
     result = config.transform_request(
@@ -2742,7 +2776,7 @@ def test_compaction_with_context_management():
         messages=messages,
         optional_params=optional_params,
         litellm_params={},
-        headers={}
+        headers={},
     )
 
     # Verify context_management is included
@@ -2758,30 +2792,28 @@ def test_compaction_block_with_other_content_types():
 
     completion_response = {
         "content": [
-            {
-                "type": "compaction",
-                "content": "Summary of previous conversation..."
-            },
-            {
-                "type": "thinking",
-                "thinking": "Let me think about this..."
-            },
-            {
-                "type": "text",
-                "text": "Based on my analysis..."
-            },
+            {"type": "compaction", "content": "Summary of previous conversation..."},
+            {"type": "thinking", "thinking": "Let me think about this..."},
+            {"type": "text", "text": "Based on my analysis..."},
             {
                 "type": "tool_use",
                 "id": "toolu_123",
                 "name": "get_weather",
-                "input": {"location": "San Francisco"}
-            }
+                "input": {"location": "San Francisco"},
+            },
         ]
     }
 
-    text, citations, thinking_blocks, reasoning_content, tool_calls, web_search_results, tool_results, compaction_blocks = config.extract_response_content(
-        completion_response
-    )
+    (
+        text,
+        citations,
+        thinking_blocks,
+        reasoning_content,
+        tool_calls,
+        web_search_results,
+        tool_results,
+        compaction_blocks,
+    ) = config.extract_response_content(completion_response)
 
     # Verify all content types are extracted
     assert compaction_blocks is not None
@@ -2798,11 +2830,11 @@ def test_map_openai_context_management_to_anthropic():
     Test mapping OpenAI Responses API context_management format to Anthropic format.
     """
     config = AnthropicConfig()
-    
+
     # Test OpenAI list format with compaction
     openai_format = [{"type": "compaction", "compact_threshold": 200000}]
     result = config.map_openai_context_management_to_anthropic(openai_format)
-    
+
     assert result is not None
     assert "edits" in result
     assert len(result["edits"]) == 1
@@ -2811,26 +2843,32 @@ def test_map_openai_context_management_to_anthropic():
     assert result["edits"][0]["trigger"]["value"] == 200000
 
     # Test OpenAI format with instructions
-    openai_format_with_instructions = [{
-        "type": "compaction",
-        "compact_threshold": 150000,
-        "instructions": "Focus on preserving code snippets"
-    }]
-    result = config.map_openai_context_management_to_anthropic(openai_format_with_instructions)
-    
+    openai_format_with_instructions = [
+        {
+            "type": "compaction",
+            "compact_threshold": 150000,
+            "instructions": "Focus on preserving code snippets",
+        }
+    ]
+    result = config.map_openai_context_management_to_anthropic(
+        openai_format_with_instructions
+    )
+
     assert result is not None
     assert result["edits"][0]["trigger"]["value"] == 150000
     assert result["edits"][0]["instructions"] == "Focus on preserving code snippets"
-    
+
     # Test Anthropic format (should pass through)
     anthropic_format = {
-        "edits": [{
-            "type": "compact_20260112",
-            "trigger": {"type": "input_tokens", "value": 150000}
-        }]
+        "edits": [
+            {
+                "type": "compact_20260112",
+                "trigger": {"type": "input_tokens", "value": 150000},
+            }
+        ]
     }
     result = config.map_openai_context_management_to_anthropic(anthropic_format)
-    
+
     assert result == anthropic_format
 
 
@@ -2839,46 +2877,51 @@ def test_map_openai_params_with_context_management():
     Test that map_openai_params correctly transforms context_management from OpenAI to Anthropic format.
     """
     config = AnthropicConfig()
-    
+
     # Test with OpenAI list format
     non_default_params = {
         "context_management": [{"type": "compaction", "compact_threshold": 200000}]
     }
     optional_params = {}
-    
+
     result = config.map_openai_params(
         non_default_params=non_default_params,
         optional_params=optional_params,
         model="claude-opus-4-6",
-        drop_params=False
+        drop_params=False,
     )
-    
+
     assert "context_management" in result
     assert "edits" in result["context_management"]
     assert result["context_management"]["edits"][0]["type"] == "compact_20260112"
     assert result["context_management"]["edits"][0]["trigger"]["value"] == 200000
-    
+
     # Test with Anthropic dict format (should pass through)
     non_default_params_anthropic = {
         "context_management": {
-            "edits": [{
-                "type": "compact_20260112",
-                "trigger": {"type": "input_tokens", "value": 150000},
-                "instructions": "Focus on preserving code"
-            }]
+            "edits": [
+                {
+                    "type": "compact_20260112",
+                    "trigger": {"type": "input_tokens", "value": 150000},
+                    "instructions": "Focus on preserving code",
+                }
+            ]
         }
     }
     optional_params = {}
-    
+
     result = config.map_openai_params(
         non_default_params=non_default_params_anthropic,
         optional_params=optional_params,
         model="claude-opus-4-6",
-        drop_params=False
+        drop_params=False,
     )
-    
+
     assert "context_management" in result
-    assert result["context_management"] == non_default_params_anthropic["context_management"]
+    assert (
+        result["context_management"]
+        == non_default_params_anthropic["context_management"]
+    )
 
 
 def test_cache_control_in_supported_params():
@@ -2897,9 +2940,7 @@ def test_map_openai_params_with_cache_control():
     """
     config = AnthropicConfig()
 
-    non_default_params = {
-        "cache_control": {"type": "ephemeral"}
-    }
+    non_default_params = {"cache_control": {"type": "ephemeral"}}
     optional_params = {}
 
     result = config.map_openai_params(
@@ -2919,9 +2960,7 @@ def test_map_openai_params_cache_control_ignored_when_not_dict():
     """
     config = AnthropicConfig()
 
-    non_default_params = {
-        "cache_control": "ephemeral"
-    }
+    non_default_params = {"cache_control": "ephemeral"}
     optional_params = {}
 
     result = config.map_openai_params(
@@ -2974,17 +3013,9 @@ def test_compaction_block_empty_list_not_added():
         "type": "message",
         "role": "assistant",
         "model": "claude-opus-4-6",
-        "content": [
-            {
-                "type": "text",
-                "text": "Just a regular response."
-            }
-        ],
+        "content": [{"type": "text", "text": "Just a regular response."}],
         "stop_reason": "end_turn",
-        "usage": {
-            "input_tokens": 10,
-            "output_tokens": 5
-        }
+        "usage": {"input_tokens": 10, "output_tokens": 5},
     }
 
     raw_response = httpx.Response(status_code=200, headers={})
@@ -3001,7 +3032,10 @@ def test_compaction_block_empty_list_not_added():
     # Verify compaction_blocks is not in provider_specific_fields when there are none
     provider_fields = result.choices[0].message.provider_specific_fields
     if provider_fields:
-        assert "compaction_blocks" not in provider_fields or provider_fields.get("compaction_blocks") is None
+        assert (
+            "compaction_blocks" not in provider_fields
+            or provider_fields.get("compaction_blocks") is None
+        )
 
 
 def test_fast_mode_beta_header():
@@ -3014,8 +3048,7 @@ def test_fast_mode_beta_header():
     optional_params = {"speed": "fast"}
 
     result_headers = config.update_headers_with_optional_anthropic_beta(
-        headers=headers,
-        optional_params=optional_params
+        headers=headers, optional_params=optional_params
     )
 
     assert "anthropic-beta" in result_headers
@@ -3029,14 +3062,10 @@ def test_fast_mode_with_other_beta_headers():
     config = AnthropicConfig()
 
     headers = {}
-    optional_params = {
-        "speed": "fast",
-        "output_format": {"type": "json_object"}
-    }
+    optional_params = {"speed": "fast", "output_format": {"type": "json_object"}}
 
     result_headers = config.update_headers_with_optional_anthropic_beta(
-        headers=headers,
-        optional_params=optional_params
+        headers=headers, optional_params=optional_params
     )
 
     assert "anthropic-beta" in result_headers
@@ -3056,9 +3085,7 @@ def test_fast_mode_usage_calculation():
     }
 
     usage = config.calculate_usage(
-        usage_object=usage_object,
-        reasoning_content=None,
-        speed="fast"
+        usage_object=usage_object, reasoning_content=None, speed="fast"
     )
 
     assert usage.prompt_tokens == 1000
@@ -3171,7 +3198,7 @@ def test_fast_mode_parameter_mapping():
         non_default_params=non_default_params,
         optional_params=optional_params,
         model="claude-opus-4-6",
-        drop_params=False
+        drop_params=False,
     )
 
     assert "speed" in result
@@ -3236,9 +3263,9 @@ def test_map_tool_helper_enforces_object_type_when_missing():
     assert "properties" in result["input_schema"]
     assert "query" in result["input_schema"]["properties"]
     # Original parameters dict must not be modified in place
-    assert tool["function"]["parameters"] == original_params, (
-        "parameters dict was mutated; _map_tool_helper should not modify caller data"
-    )
+    assert (
+        tool["function"]["parameters"] == original_params
+    ), "parameters dict was mutated; _map_tool_helper should not modify caller data"
 
 
 def test_map_tool_helper_enforces_object_type_when_wrong_type():
@@ -3264,13 +3291,13 @@ def test_map_tool_helper_enforces_object_type_when_wrong_type():
     result, _ = config._map_tool_helper(tool)
     assert result is not None
     assert result["input_schema"]["type"] == "object"
-    assert result["input_schema"].get("properties") == {}, (
-        "properties should be injected as {} when schema has non-object type and no properties key"
-    )
+    assert (
+        result["input_schema"].get("properties") == {}
+    ), "properties should be injected as {} when schema has non-object type and no properties key"
     # Original parameters dict must not be modified in place
-    assert tool["function"]["parameters"] == original_params, (
-        "parameters dict was mutated; _map_tool_helper should not modify caller data"
-    )
+    assert (
+        tool["function"]["parameters"] == original_params
+    ), "parameters dict was mutated; _map_tool_helper should not modify caller data"
 
 
 def test_map_tool_helper_preserves_valid_object_schema():
diff --git a/tests/test_litellm/llms/anthropic/chat/test_code_interpreter_results_extraction.py b/tests/test_litellm/llms/anthropic/chat/test_code_interpreter_results_extraction.py
new file mode 100644
index 00000000000..60e45c9b8ce
--- /dev/null
+++ b/tests/test_litellm/llms/anthropic/chat/test_code_interpreter_results_extraction.py
@@ -0,0 +1,268 @@
+"""
+Tests for the Responses API _extract_tool_result_output_items path,
+the non-streaming _hidden_params propagation of code_interpreter_results,
+and mock end-to-end streaming integration.
+"""
+
+from unittest.mock import MagicMock
+
+from litellm.llms.anthropic.chat.handler import ModelResponseIterator
+from litellm.main import stream_chunk_builder
+from litellm.responses.litellm_completion_transformation.transformation import (
+    LiteLLMCompletionResponsesConfig,
+)
+from litellm.types.responses.main import (
+    OutputCodeInterpreterCall,
+    OutputCodeInterpreterCallLog,
+)
+from litellm.types.utils import Choices, Message, ModelResponse
+
+
+def _make_model_response(code_interpreter_results=None, provider_specific_fields=None):
+    """Helper to build a ModelResponse with provider_specific_fields on the message."""
+    psf = provider_specific_fields or {}
+    if code_interpreter_results is not None:
+        psf["code_interpreter_results"] = code_interpreter_results
+    msg = Message(content="test", provider_specific_fields=psf if psf else None)
+    choice = Choices(index=0, message=msg, finish_reason="stop")
+    resp = ModelResponse()
+    resp.choices = [choice]
+    return resp
+
+
+def test_extract_tool_result_output_items_from_pydantic_objects():
+    """Non-streaming path: code_interpreter_results are Pydantic OutputCodeInterpreterCall objects."""
+    items = [
+        OutputCodeInterpreterCall(
+            type="code_interpreter_call",
+            id="srvtoolu_01AAA",
+            code="echo hello",
+            container_id=None,
+            status="completed",
+            outputs=[OutputCodeInterpreterCallLog(type="logs", logs="hello\n")],
+        ),
+        OutputCodeInterpreterCall(
+            type="code_interpreter_call",
+            id="srvtoolu_01BBB",
+            code="echo world",
+            container_id=None,
+            status="completed",
+            outputs=[OutputCodeInterpreterCallLog(type="logs", logs="world\n")],
+        ),
+    ]
+    resp = _make_model_response(code_interpreter_results=items)
+    result = LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(resp)
+    assert len(result) == 2
+    assert result[0].id == "srvtoolu_01AAA"
+    assert result[1].id == "srvtoolu_01BBB"
+
+
+def test_extract_tool_result_output_items_from_dicts():
+    """Streaming path: after model_dump(), code_interpreter_results are plain dicts.
+    _extract_tool_result_output_items reconstructs them as Pydantic objects."""
+    items = [
+        {
+            "type": "code_interpreter_call",
+            "id": "srvtoolu_01AAA",
+            "code": "echo hello",
+            "container_id": None,
+            "status": "completed",
+            "outputs": [{"type": "logs", "logs": "hello\n"}],
+        },
+    ]
+    resp = _make_model_response(code_interpreter_results=items)
+    result = LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(resp)
+    assert len(result) == 1
+    assert isinstance(result[0], OutputCodeInterpreterCall)
+    assert result[0].id == "srvtoolu_01AAA"
+
+
+def test_extract_tool_result_output_items_empty():
+    """No code_interpreter_results → empty list."""
+    resp = _make_model_response()
+    result = LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(resp)
+    assert result == []
+
+
+def test_extract_tool_result_output_items_no_provider_specific_fields():
+    """Message with no provider_specific_fields → empty list."""
+    msg = Message(content="test")
+    choice = Choices(index=0, message=msg, finish_reason="stop")
+    resp = ModelResponse()
+    resp.choices = [choice]
+    result = LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(resp)
+    assert result == []
+
+
+def test_in_place_substitution_preserves_ordering():
+    """
+    function_call items matching code_interpreter_results should be replaced
+    in-place, preserving the original output ordering.
+
+    Simulates: [message, function_call(exec1), function_call(regular), function_call(exec2)]
+    Expected:  [message, code_interpreter_call(exec1), function_call(regular), code_interpreter_call(exec2)]
+    """
+    code_results = [
+        OutputCodeInterpreterCall(
+            type="code_interpreter_call",
+            id="srvtoolu_01AAA",
+            code="echo first",
+            container_id=None,
+            status="completed",
+            outputs=[OutputCodeInterpreterCallLog(type="logs", logs="first\n")],
+        ),
+        OutputCodeInterpreterCall(
+            type="code_interpreter_call",
+            id="srvtoolu_01CCC",
+            code="echo third",
+            container_id=None,
+            status="completed",
+            outputs=[OutputCodeInterpreterCallLog(type="logs", logs="third\n")],
+        ),
+    ]
+    resp = _make_model_response(code_interpreter_results=code_results)
+
+    # Build a mock responses_output list with interleaved items
+    class MockItem:
+        def __init__(self, type, call_id=None):
+            self.type = type
+            self.call_id = call_id
+
+    msg_item = MockItem(type="message")
+    fc_exec1 = MockItem(type="function_call", call_id="srvtoolu_01AAA")
+    fc_regular = MockItem(type="function_call", call_id="srvtoolu_01BBB")
+    fc_exec2 = MockItem(type="function_call", call_id="srvtoolu_01CCC")
+
+    responses_output = [msg_item, fc_exec1, fc_regular, fc_exec2]
+
+    # Apply the same logic as _transform_chat_completion_choices_to_responses_output
+    tool_result_items = (
+        LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(resp)
+    )
+    if tool_result_items:
+        result_by_id = {
+            (item.get("id") if isinstance(item, dict) else item.id): item
+            for item in tool_result_items
+        }
+        replaced_ids = set(result_by_id.keys())
+        responses_output = [
+            (
+                result_by_id[getattr(item, "call_id", None)]
+                if (
+                    getattr(item, "type", None) == "function_call"
+                    and getattr(item, "call_id", None) in replaced_ids
+                )
+                else item
+            )
+            for item in responses_output
+        ]
+
+    # Verify ordering: message, code_interpreter(AAA), function_call(BBB), code_interpreter(CCC)
+    assert len(responses_output) == 4
+    assert responses_output[0].type == "message"
+    assert responses_output[1].type == "code_interpreter_call"
+    assert responses_output[1].id == "srvtoolu_01AAA"
+    assert responses_output[2].type == "function_call"
+    assert responses_output[2].call_id == "srvtoolu_01BBB"
+    assert responses_output[3].type == "code_interpreter_call"
+    assert responses_output[3].id == "srvtoolu_01CCC"
+
+
+def test_end_to_end_streaming_chunks_to_code_interpreter_output():
+    """
+    Mock end-to-end test: Anthropic SSE chunks → ModelResponseIterator →
+    stream_chunk_builder → _extract_tool_result_output_items → final output
+    with code_interpreter_call items replacing function_call items.
+
+    This exercises the full streaming data flow without a live server.
+    """
+    # Realistic Anthropic streaming chunks for a single code execution
+    raw_chunks = [
+        {
+            "type": "message_start",
+            "message": {
+                "id": "msg_01XYZ",
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "usage": {"input_tokens": 100, "output_tokens": 1},
+            },
+        },
+        {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "server_tool_use",
+                "id": "srvtoolu_01AAA",
+                "name": "bash_code_execution",
+                "input": {},
+            },
+        },
+        {
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {
+                "type": "input_json_delta",
+                "partial_json": '{"command": "echo e2e_test"}',
+            },
+        },
+        {"type": "content_block_stop", "index": 0},
+        {
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "type": "bash_code_execution_tool_result",
+                "tool_use_id": "srvtoolu_01AAA",
+                "content": {
+                    "type": "bash_code_execution_result",
+                    "stdout": "e2e_test\n",
+                    "stderr": "",
+                    "return_code": 0,
+                },
+            },
+        },
+        {"type": "content_block_stop", "index": 1},
+        {
+            "type": "message_delta",
+            "delta": {"stop_reason": "end_turn"},
+            "usage": {"output_tokens": 50},
+        },
+    ]
+
+    # Step 1: Parse chunks through ModelResponseIterator (Anthropic handler)
+    iterator = ModelResponseIterator(None, sync_stream=True)
+    parsed_chunks = []
+    for chunk in raw_chunks:
+        parsed = iterator.chunk_parser(chunk)
+        d = parsed.model_dump()
+        # In production, CustomStreamWrapper sets the model on each chunk;
+        # stream_chunk_builder requires it.
+        d["model"] = "claude-sonnet-4-20250514"
+        parsed_chunks.append(d)
+
+    # Step 2: Assemble via stream_chunk_builder (simulates end-of-stream)
+    assembled = stream_chunk_builder(chunks=parsed_chunks)
+    assert assembled is not None
+
+    # Verify stream_chunk_builder picked up code_interpreter_results via last-value-wins
+    psf = assembled.choices[0].message.provider_specific_fields
+    assert psf is not None
+    assert "code_interpreter_results" in psf
+    code_results = psf["code_interpreter_results"]
+    assert len(code_results) == 1
+    # After model_dump + stream_chunk_builder, results are plain dicts
+    assert code_results[0]["id"] == "srvtoolu_01AAA"
+    assert code_results[0]["code"] == "echo e2e_test"
+
+    # Step 3: Extract via _extract_tool_result_output_items (Responses API layer)
+    tool_result_items = (
+        LiteLLMCompletionResponsesConfig._extract_tool_result_output_items(assembled)
+    )
+    assert len(tool_result_items) == 1
+    item = tool_result_items[0]
+    # Items are reconstructed as Pydantic OutputCodeInterpreterCall objects
+    assert isinstance(item, OutputCodeInterpreterCall)
+    assert item.type == "code_interpreter_call"
+    assert item.id == "srvtoolu_01AAA"
+    assert item.code == "echo e2e_test"
+    assert item.outputs[0].logs == "e2e_test\n"
diff --git a/tests/test_litellm/proxy/test_aiohttp_session_recovery.py b/tests/test_litellm/proxy/test_aiohttp_session_recovery.py
new file mode 100644
index 00000000000..29bd9a491b7
--- /dev/null
+++ b/tests/test_litellm/proxy/test_aiohttp_session_recovery.py
@@ -0,0 +1,182 @@
+"""
+Tests for shared aiohttp session auto-recovery.
+
+When the shared session closes (e.g. network interruption, idle timeout),
+add_shared_session_to_data should recreate it instead of permanently
+falling back to per-request connections.
+
+Fixes: https://github.com/BerriAI/litellm/issues/23806
+"""
+
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_add_shared_session_attaches_open_session():
+    """When the shared session is open, it should be attached to data."""
+    from litellm.proxy.route_llm_request import add_shared_session_to_data
+
+    mock_session = MagicMock()
+    mock_session.closed = False
+
+    with patch("litellm.proxy.proxy_server.shared_aiohttp_session", mock_session):
+        data = {}
+        await add_shared_session_to_data(data)
+        assert data["shared_session"] is mock_session
+
+
+@pytest.mark.asyncio
+async def test_add_shared_session_recreates_closed_session():
+    """When the shared session is closed, it should be recreated."""
+    import litellm.proxy.route_llm_request as route_module
+    from litellm.proxy import proxy_server as proxy_server_module
+    from litellm.proxy.route_llm_request import add_shared_session_to_data
+
+    # Reset the module-level lock so each test uses the current event loop
+    route_module._shared_session_lock = None
+
+    closed_session = MagicMock()
+    closed_session.closed = True
+
+    new_session = MagicMock()
+    new_session.closed = False
+
+    with patch.object(
+        proxy_server_module,
+        "shared_aiohttp_session",
+        closed_session,
+    ):
+        with patch.object(
+            proxy_server_module,
+            "_initialize_shared_aiohttp_session",
+            new_callable=AsyncMock,
+            return_value=new_session,
+        ) as mock_init:
+            data = {}
+            await add_shared_session_to_data(data)
+
+            mock_init.assert_called_once()
+            assert data["shared_session"] is new_session
+            assert proxy_server_module.shared_aiohttp_session is new_session
+
+
+@pytest.mark.asyncio
+async def test_add_shared_session_handles_recreation_failure():
+    """When recreation fails, data should not contain shared_session."""
+    import litellm.proxy.route_llm_request as route_module
+    from litellm.proxy import proxy_server as proxy_server_module
+    from litellm.proxy.route_llm_request import add_shared_session_to_data
+
+    # Reset the module-level lock so each test uses the current event loop
+    route_module._shared_session_lock = None
+
+    closed_session = MagicMock()
+    closed_session.closed = True
+
+    with patch.object(
+        proxy_server_module,
+        "shared_aiohttp_session",
+        closed_session,
+    ):
+        with patch.object(
+            proxy_server_module,
+            "_initialize_shared_aiohttp_session",
+            new_callable=AsyncMock,
+            return_value=None,
+        ):
+            data = {}
+            await add_shared_session_to_data(data)
+            assert "shared_session" not in data
+
+
+@pytest.mark.asyncio
+async def test_add_shared_session_handles_recreation_exception():
+    """When _initialize_shared_aiohttp_session raises, data should not contain shared_session."""
+    import litellm.proxy.route_llm_request as route_module
+    from litellm.proxy import proxy_server as proxy_server_module
+    from litellm.proxy.route_llm_request import add_shared_session_to_data
+
+    # Reset the module-level lock so each test uses the current event loop
+    route_module._shared_session_lock = None
+
+    closed_session = MagicMock()
+    closed_session.closed = True
+
+    with patch.object(
+        proxy_server_module,
+        "shared_aiohttp_session",
+        closed_session,
+    ):
+        with patch.object(
+            proxy_server_module,
+            "_initialize_shared_aiohttp_session",
+            new_callable=AsyncMock,
+            side_effect=RuntimeError("connection pool exhausted"),
+        ):
+            data = {}
+            await add_shared_session_to_data(data)
+            # Should gracefully handle exception — no shared_session attached
+            assert "shared_session" not in data
+
+
+@pytest.mark.asyncio
+async def test_add_shared_session_no_session_available():
+    """When no session was ever created, data should not contain shared_session."""
+    from litellm.proxy.route_llm_request import add_shared_session_to_data
+
+    with patch("litellm.proxy.proxy_server.shared_aiohttp_session", None):
+        data = {}
+        await add_shared_session_to_data(data)
+        assert "shared_session" not in data
+
+
+@pytest.mark.asyncio
+async def test_add_shared_session_concurrent_recreation_uses_lock():
+    """When multiple coroutines detect a closed session concurrently,
+    only one should recreate it (double-checked locking via asyncio.Lock)."""
+    import litellm.proxy.route_llm_request as route_module
+    from litellm.proxy import proxy_server as proxy_server_module
+    from litellm.proxy.route_llm_request import add_shared_session_to_data
+
+    # Reset the module-level lock so each test is isolated
+    route_module._shared_session_lock = None
+
+    closed_session = MagicMock()
+    closed_session.closed = True
+
+    new_session = MagicMock()
+    new_session.closed = False
+
+    call_count = 0
+
+    async def mock_init():
+        nonlocal call_count
+        call_count += 1
+        # Simulate some async work
+        await asyncio.sleep(0.01)
+        return new_session
+
+    with patch.object(
+        proxy_server_module,
+        "shared_aiohttp_session",
+        closed_session,
+    ):
+        with patch.object(
+            proxy_server_module,
+            "_initialize_shared_aiohttp_session",
+            new_callable=AsyncMock,
+            side_effect=mock_init,
+        ):
+            # Launch 5 concurrent calls
+            results = [{} for _ in range(5)]
+            await asyncio.gather(*(add_shared_session_to_data(d) for d in results))
+
+            # Only 1 coroutine should have called _initialize (the rest see the
+            # re-checked session as open under the lock)
+            assert call_count == 1, f"Expected 1 init call, got {call_count}"
+            # All should have the new session
+            for d in results:
+                assert d.get("shared_session") is new_session
diff --git a/ui/litellm-dashboard/package-lock.json b/ui/litellm-dashboard/package-lock.json
index c062356ebbd..2b62c1c16bb 100644
--- a/ui/litellm-dashboard/package-lock.json
+++ b/ui/litellm-dashboard/package-lock.json
@@ -23,7 +23,7 @@
         "jwt-decode": "^4.0.0",
         "lucide-react": "^0.513.0",
         "moment": "^2.30.1",
-        "next": "^16.1.6",
+        "next": "^16.1.7",
         "openai": "^4.93.0",
         "papaparse": "^5.5.2",
         "react": "^18.3.1",
@@ -92,6 +92,7 @@
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
       "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=10"
@@ -1773,6 +1774,7 @@
       "version": "0.3.13",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
       "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jridgewell/sourcemap-codec": "^1.5.0",
@@ -1783,6 +1785,7 @@
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
       "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=6.0.0"
@@ -1792,12 +1795,14 @@
       "version": "1.5.5",
       "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
       "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/@jridgewell/trace-mapping": {
       "version": "0.3.31",
       "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
       "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jridgewell/resolve-uri": "^3.1.0",
@@ -1828,9 +1833,9 @@
       }
     },
     "node_modules/@next/env": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.1.6.tgz",
-      "integrity": "sha512-N1ySLuZjnAtN3kFnwhAwPvZah8RJxKasD7x1f8shFqhncnWZn4JMfg37diLNuoHsLAlrDfM3g4mawVdtAG8XLQ==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.1.7.tgz",
+      "integrity": "sha512-rJJbIdJB/RQr2F1nylZr/PJzamvNNhfr3brdKP6s/GW850jbtR70QlSfFselvIBbcPUOlQwBakexjFzqLzF6pg==",
       "license": "MIT"
     },
     "node_modules/@next/eslint-plugin-next": {
@@ -1844,9 +1849,9 @@
       }
     },
     "node_modules/@next/swc-darwin-arm64": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.1.6.tgz",
-      "integrity": "sha512-wTzYulosJr/6nFnqGW7FrG3jfUUlEf8UjGA0/pyypJl42ExdVgC6xJgcXQ+V8QFn6niSG2Pb8+MIG1mZr2vczw==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.1.7.tgz",
+      "integrity": "sha512-b2wWIE8sABdyafc4IM8r5Y/dS6kD80JRtOGrUiKTsACFQfWWgUQ2NwoUX1yjFMXVsAwcQeNpnucF2ZrujsBBPg==",
       "cpu": [
         "arm64"
       ],
@@ -1860,9 +1865,9 @@
       }
     },
     "node_modules/@next/swc-darwin-x64": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.1.6.tgz",
-      "integrity": "sha512-BLFPYPDO+MNJsiDWbeVzqvYd4NyuRrEYVB5k2N3JfWncuHAy2IVwMAOlVQDFjj+krkWzhY2apvmekMkfQR0CUQ==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.1.7.tgz",
+      "integrity": "sha512-zcnVaaZulS1WL0Ss38R5Q6D2gz7MtBu8GZLPfK+73D/hp4GFMrC2sudLky1QibfV7h6RJBJs/gOFvYP0X7UVlQ==",
       "cpu": [
         "x64"
       ],
@@ -1876,9 +1881,9 @@
       }
     },
     "node_modules/@next/swc-linux-arm64-gnu": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.1.6.tgz",
-      "integrity": "sha512-OJYkCd5pj/QloBvoEcJ2XiMnlJkRv9idWA/j0ugSuA34gMT6f5b7vOiCQHVRpvStoZUknhl6/UxOXL4OwtdaBw==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.1.7.tgz",
+      "integrity": "sha512-2ant89Lux/Q3VyC8vNVg7uBaFVP9SwoK2jJOOR0L8TQnX8CAYnh4uctAScy2Hwj2dgjVHqHLORQZJ2wH6VxhSQ==",
       "cpu": [
         "arm64"
       ],
@@ -1892,9 +1897,9 @@
       }
     },
     "node_modules/@next/swc-linux-arm64-musl": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.1.6.tgz",
-      "integrity": "sha512-S4J2v+8tT3NIO9u2q+S0G5KdvNDjXfAv06OhfOzNDaBn5rw84DGXWndOEB7d5/x852A20sW1M56vhC/tRVbccQ==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.1.7.tgz",
+      "integrity": "sha512-uufcze7LYv0FQg9GnNeZ3/whYfo+1Q3HnQpm16o6Uyi0OVzLlk2ZWoY7j07KADZFY8qwDbsmFnMQP3p3+Ftprw==",
       "cpu": [
         "arm64"
       ],
@@ -1908,9 +1913,9 @@
       }
     },
     "node_modules/@next/swc-linux-x64-gnu": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.1.6.tgz",
-      "integrity": "sha512-2eEBDkFlMMNQnkTyPBhQOAyn2qMxyG2eE7GPH2WIDGEpEILcBPI/jdSv4t6xupSP+ot/jkfrCShLAa7+ZUPcJQ==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.1.7.tgz",
+      "integrity": "sha512-KWVf2gxYvHtvuT+c4MBOGxuse5TD7DsMFYSxVxRBnOzok/xryNeQSjXgxSv9QpIVlaGzEn/pIuI6Koosx8CGWA==",
       "cpu": [
         "x64"
       ],
@@ -1924,9 +1929,9 @@
       }
     },
     "node_modules/@next/swc-linux-x64-musl": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.1.6.tgz",
-      "integrity": "sha512-oicJwRlyOoZXVlxmIMaTq7f8pN9QNbdes0q2FXfRsPhfCi8n8JmOZJm5oo1pwDaFbnnD421rVU409M3evFbIqg==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.1.7.tgz",
+      "integrity": "sha512-HguhaGwsGr1YAGs68uRKc4aGWxLET+NevJskOcCAwXbwj0fYX0RgZW2gsOCzr9S11CSQPIkxmoSbuVaBp4Z3dA==",
       "cpu": [
         "x64"
       ],
@@ -1940,9 +1945,9 @@
       }
     },
     "node_modules/@next/swc-win32-arm64-msvc": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.1.6.tgz",
-      "integrity": "sha512-gQmm8izDTPgs+DCWH22kcDmuUp7NyiJgEl18bcr8irXA5N2m2O+JQIr6f3ct42GOs9c0h8QF3L5SzIxcYAAXXw==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.1.7.tgz",
+      "integrity": "sha512-S0n3KrDJokKTeFyM/vGGGR8+pCmXYrjNTk2ZozOL1C/JFdfUIL9O1ATaJOl5r2POe56iRChbsszrjMAdWSv7kQ==",
       "cpu": [
         "arm64"
       ],
@@ -1956,9 +1961,9 @@
       }
     },
     "node_modules/@next/swc-win32-x64-msvc": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.1.6.tgz",
-      "integrity": "sha512-NRfO39AIrzBnixKbjuo2YiYhB6o9d8v/ymU9m/Xk8cyVk+k7XylniXkHwjs4s70wedVffc6bQNbufk5v0xEm0A==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.1.7.tgz",
+      "integrity": "sha512-mwgtg8CNZGYm06LeEd+bNnOUfwOyNem/rOiP14Lsz+AnUY92Zq/LXwtebtUiaeVkhbroRCQ0c8GlR4UT1U+0yg==",
       "cpu": [
         "x64"
       ],
@@ -1975,6 +1980,7 @@
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
       "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@nodelib/fs.stat": "2.0.5",
@@ -1988,6 +1994,7 @@
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
       "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 8"
@@ -1997,6 +2004,7 @@
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
       "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@nodelib/fs.scandir": "2.1.5",
@@ -2320,7 +2328,7 @@
       "version": "1.58.1",
       "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.58.1.tgz",
       "integrity": "sha512-6LdVIUERWxQMmUSSQi0I53GgCBYgM2RpGngCPY7hSeju+VrKjq3lvs7HpJoPbDiY5QM5EYRtRX5fvrinnMAz3w==",
-      "devOptional": true,
+      "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "playwright": "1.58.1"
@@ -3425,12 +3433,14 @@
       "version": "15.7.15",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
       "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/react": {
       "version": "18.2.48",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-18.2.48.tgz",
       "integrity": "sha512-qboRCl6Ie70DQQG9hhNREz81jqC1cs9EVNcjQ1AU+jH6NFfSAhVVbrrY/+nSF+Bsk4AOwm9Qa61InvMCyV+H3w==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/prop-types": "*",
@@ -3472,6 +3482,7 @@
       "version": "0.26.0",
       "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.26.0.tgz",
       "integrity": "sha512-WFHp9YUJQ6CKshqoC37iOlHnQSmxNc795UhB26CyBBttrN9svdIrUjl/NjnNmfcwtncN0h/0PPAFWv9ovP8mLA==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/unist": {
@@ -4332,12 +4343,14 @@
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
       "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/anymatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
       "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "normalize-path": "^3.0.0",
@@ -4351,6 +4364,7 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -4363,6 +4377,7 @@
       "version": "5.0.2",
       "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
       "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/argparse": {
@@ -4734,6 +4749,7 @@
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
       "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -4759,6 +4775,7 @@
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
       "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "fill-range": "^7.1.1"
@@ -4874,6 +4891,7 @@
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
       "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 6"
@@ -4997,6 +5015,7 @@
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
       "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "anymatch": "~3.1.2",
@@ -5021,6 +5040,7 @@
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
       "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "is-glob": "^4.0.1"
@@ -5096,6 +5116,7 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
       "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 6"
@@ -5156,6 +5177,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
       "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "dev": true,
       "license": "MIT",
       "bin": {
         "cssesc": "bin/cssesc"
@@ -5569,12 +5591,14 @@
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
       "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==",
+      "dev": true,
       "license": "Apache-2.0"
     },
     "node_modules/dlv": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
       "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/doctrine": {
@@ -6488,6 +6512,7 @@
       "version": "1.20.1",
       "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
       "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "reusify": "^1.0.4"
@@ -6520,6 +6545,7 @@
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
       "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12.0.0"
@@ -6557,6 +6583,7 @@
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
       "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "to-regex-range": "^5.0.1"
@@ -6717,6 +6744,7 @@
       "version": "2.3.2",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
       "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
       "optional": true,
@@ -6867,6 +6895,7 @@
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
       "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "is-glob": "^4.0.3"
@@ -7364,6 +7393,7 @@
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
       "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "binary-extensions": "^2.0.0"
@@ -7416,6 +7446,7 @@
       "version": "2.16.1",
       "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
       "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "hasown": "^2.0.2"
@@ -7476,6 +7507,7 @@
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
       "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -7521,6 +7553,7 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
       "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "is-extglob": "^2.1.1"
@@ -7569,6 +7602,7 @@
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.12.0"
@@ -7845,6 +7879,7 @@
       "version": "1.21.7",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
       "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+      "dev": true,
       "license": "MIT",
       "bin": {
         "jiti": "bin/jiti.js"
@@ -8130,6 +8165,7 @@
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
       "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=14"
@@ -8142,6 +8178,7 @@
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
       "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/locate-path": {
@@ -8595,6 +8632,7 @@
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
       "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 8"
@@ -9167,6 +9205,7 @@
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
       "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "braces": "^3.0.3",
@@ -9180,6 +9219,7 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -9294,6 +9334,7 @@
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
       "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "any-promise": "^1.0.0",
@@ -9343,14 +9384,14 @@
       "license": "MIT"
     },
     "node_modules/next": {
-      "version": "16.1.6",
-      "resolved": "https://registry.npmjs.org/next/-/next-16.1.6.tgz",
-      "integrity": "sha512-hkyRkcu5x/41KoqnROkfTm2pZVbKxvbZRuNvKXLRXxs3VfyO0WhY50TQS40EuKO9SW3rBj/sF3WbVwDACeMZyw==",
+      "version": "16.1.7",
+      "resolved": "https://registry.npmjs.org/next/-/next-16.1.7.tgz",
+      "integrity": "sha512-WM0L7WrSvKwoLegLYr6V+mz+RIofqQgVAfHhMp9a88ms0cFX8iX9ew+snpWlSBwpkURJOUdvCEt3uLl3NNzvWg==",
       "license": "MIT",
       "dependencies": {
-        "@next/env": "16.1.6",
+        "@next/env": "16.1.7",
         "@swc/helpers": "0.5.15",
-        "baseline-browser-mapping": "^2.8.3",
+        "baseline-browser-mapping": "^2.9.19",
         "caniuse-lite": "^1.0.30001579",
         "postcss": "8.4.31",
         "styled-jsx": "5.1.6"
@@ -9362,14 +9403,14 @@
         "node": ">=20.9.0"
       },
       "optionalDependencies": {
-        "@next/swc-darwin-arm64": "16.1.6",
-        "@next/swc-darwin-x64": "16.1.6",
-        "@next/swc-linux-arm64-gnu": "16.1.6",
-        "@next/swc-linux-arm64-musl": "16.1.6",
-        "@next/swc-linux-x64-gnu": "16.1.6",
-        "@next/swc-linux-x64-musl": "16.1.6",
-        "@next/swc-win32-arm64-msvc": "16.1.6",
-        "@next/swc-win32-x64-msvc": "16.1.6",
+        "@next/swc-darwin-arm64": "16.1.7",
+        "@next/swc-darwin-x64": "16.1.7",
+        "@next/swc-linux-arm64-gnu": "16.1.7",
+        "@next/swc-linux-arm64-musl": "16.1.7",
+        "@next/swc-linux-x64-gnu": "16.1.7",
+        "@next/swc-linux-x64-musl": "16.1.7",
+        "@next/swc-win32-arm64-msvc": "16.1.7",
+        "@next/swc-win32-x64-msvc": "16.1.7",
         "sharp": "^0.34.4"
       },
       "peerDependencies": {
@@ -9505,6 +9546,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
       "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -9523,6 +9565,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
       "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 6"
@@ -9867,6 +9910,7 @@
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
       "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/path-scurry": {
@@ -9913,6 +9957,7 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -9925,6 +9970,7 @@
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
       "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -9934,6 +9980,7 @@
       "version": "4.0.7",
       "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
       "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 6"
@@ -9943,7 +9990,7 @@
       "version": "1.58.1",
       "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.58.1.tgz",
       "integrity": "sha512-+2uTZHxSCcxjvGc5C891LrS1/NlxglGxzrC4seZiVjcYVQfUa87wBL6rTDqzGjuoWNjnBzRqKmF6zRYGMvQUaQ==",
-      "devOptional": true,
+      "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "playwright-core": "1.58.1"
@@ -9962,7 +10009,7 @@
       "version": "1.58.1",
       "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.58.1.tgz",
       "integrity": "sha512-bcWzOaTxcW+VOOGBCQgnaKToLJ65d6AqfLVKEWvexyS3AS6rbXl+xdpYRMGSRBClPvyj44njOWoxjNdL/H9UNg==",
-      "devOptional": true,
+      "dev": true,
       "license": "Apache-2.0",
       "bin": {
         "playwright-core": "cli.js"
@@ -9985,6 +10032,7 @@
       "version": "8.5.6",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
       "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "dev": true,
       "funding": [
         {
           "type": "opencollective",
@@ -10013,6 +10061,7 @@
       "version": "15.1.0",
       "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
       "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "postcss-value-parser": "^4.0.0",
@@ -10030,6 +10079,7 @@
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz",
       "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==",
+      "dev": true,
       "funding": [
         {
           "type": "opencollective",
@@ -10055,6 +10105,7 @@
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
       "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
+      "dev": true,
       "funding": [
         {
           "type": "opencollective",
@@ -10097,6 +10148,7 @@
       "version": "6.2.0",
       "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
       "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
+      "dev": true,
       "funding": [
         {
           "type": "opencollective",
@@ -10122,6 +10174,7 @@
       "version": "6.1.2",
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
       "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "cssesc": "^3.0.0",
@@ -10135,6 +10188,7 @@
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
       "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/prelude-ls": {
@@ -10248,6 +10302,7 @@
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
       "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "dev": true,
       "funding": [
         {
           "type": "github",
@@ -11036,6 +11091,7 @@
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
       "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "pify": "^2.3.0"
@@ -11045,6 +11101,7 @@
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
       "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "picomatch": "^2.2.1"
@@ -11057,6 +11114,7 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -11354,6 +11412,7 @@
       "version": "1.22.11",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
       "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "is-core-module": "^2.16.1",
@@ -11394,6 +11453,7 @@
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
       "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "iojs": ">=1.0.0",
@@ -11449,6 +11509,7 @@
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
       "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "dev": true,
       "funding": [
         {
           "type": "github",
@@ -12089,6 +12150,7 @@
       "version": "3.35.1",
       "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
       "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jridgewell/gen-mapping": "^0.3.2",
@@ -12124,6 +12186,7 @@
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
       "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -12159,6 +12222,7 @@
       "version": "3.4.19",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
       "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@alloc/quick-lru": "^5.2.0",
@@ -12196,6 +12260,7 @@
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
       "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@nodelib/fs.stat": "^2.0.2",
@@ -12212,6 +12277,7 @@
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
       "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "is-glob": "^4.0.1"
@@ -12239,6 +12305,7 @@
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
       "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "any-promise": "^1.0.0"
@@ -12248,6 +12315,7 @@
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
       "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "thenify": ">= 3.1.0 < 4"
@@ -12289,6 +12357,7 @@
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
       "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "fdir": "^6.5.0",
@@ -12355,6 +12424,7 @@
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "is-number": "^7.0.0"
@@ -12442,6 +12512,7 @@
       "version": "0.1.13",
       "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
       "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
+      "dev": true,
       "license": "Apache-2.0"
     },
     "node_modules/tsconfig-paths": {
@@ -12558,7 +12629,7 @@
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "devOptional": true,
+      "dev": true,
       "license": "Apache-2.0",
       "bin": {
         "tsc": "bin/tsc",
@@ -12760,6 +12831,7 @@
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/uuid": {
@@ -13213,7 +13285,7 @@
       "version": "8.19.0",
       "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
       "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
-      "devOptional": true,
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
diff --git a/ui/litellm-dashboard/package.json b/ui/litellm-dashboard/package.json
index 2a9bb3e5e20..fce2e09b54c 100644
--- a/ui/litellm-dashboard/package.json
+++ b/ui/litellm-dashboard/package.json
@@ -35,7 +35,7 @@
     "jwt-decode": "^4.0.0",
     "lucide-react": "^0.513.0",
     "moment": "^2.30.1",
-    "next": "^16.1.6",
+    "next": "^16.1.7",
     "openai": "^4.93.0",
     "papaparse": "^5.5.2",
     "react": "^18.3.1",