amazon-bedrock-haystack 3.11.0__tar.gz → 4.0.0__tar.gz

{amazon_bedrock_haystack-3.11.0 → amazon_bedrock_haystack-4.0.0}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [integrations/amazon_bedrock-v3.11.0] - 2025-08-21
+
+### 🚀 Features
+
+- Add `AmazonBedrockDocumentImageEmbedder` component (#2185)
+
 ## [integrations/amazon_bedrock-v3.10.0] - 2025-08-06
 
 ### 🚀 Features

{amazon_bedrock_haystack-3.11.0 → amazon_bedrock_haystack-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 3.11.0
+Version: 4.0.0
 Summary: An integration of Amazon Bedrock as an AmazonBedrockGenerator component.
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/amazon_bedrock#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
 Requires-Dist: aioboto3>=14.0.0
 Requires-Dist: boto3>=1.28.57
-Requires-Dist: haystack-ai>=2.16.0
+Requires-Dist: haystack-ai>=2.17.1
 Description-Content-Type: text/markdown
 
 # amazon-bedrock-haystack
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 
 - [Integration page](https://haystack.deepset.ai/integrations/amazon-bedrock)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/amazon_bedrock/CHANGELOG.md)
------
+---
 
 ## Contributing
 

{amazon_bedrock_haystack-3.11.0 → amazon_bedrock_haystack-4.0.0}/README.md

@@ -5,7 +5,7 @@
 
 - [Integration page](https://haystack.deepset.ai/integrations/amazon-bedrock)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/amazon_bedrock/CHANGELOG.md)
------
+---
 
 ## Contributing
 

{amazon_bedrock_haystack-3.11.0 → amazon_bedrock_haystack-4.0.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.16.0", "boto3>=1.28.57", "aioboto3>=14.0.0"]
+dependencies = ["haystack-ai>=2.17.1", "boto3>=1.28.57", "aioboto3>=14.0.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/amazon_bedrock#readme"

{amazon_bedrock_haystack-3.11.0 → amazon_bedrock_haystack-4.0.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/utils.py

@@ -5,16 +5,20 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from botocore.eventstream import EventStream
 from haystack import logging
+from haystack.components.generators.utils import _convert_streaming_chunks_to_chat_message
 from haystack.dataclasses import (
     AsyncStreamingCallbackT,
     ChatMessage,
     ChatRole,
     ComponentInfo,
+    FinishReason,
     ImageContent,
+    ReasoningContent,
     StreamingChunk,
     SyncStreamingCallbackT,
     TextContent,
     ToolCall,
+    ToolCallDelta,
 )
 from haystack.tools import Tool
 
@@ -24,6 +28,16 @@ logger = logging.getLogger(__name__)
 # see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html for supported formats
 IMAGE_SUPPORTED_FORMATS = ["png", "jpeg", "gif", "webp"]
 
+# see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html
+FINISH_REASON_MAPPING: Dict[str, FinishReason] = {
+    "end_turn": "stop",
+    "stop_sequence": "stop",
+    "max_tokens": "length",
+    "guardrail_intervened": "content_filter",
+    "content_filtered": "content_filter",
+    "tool_use": "tool_calls",
+}
+
 
 # Haystack to Bedrock util methods
 def _format_tools(tools: Optional[List[Tool]] = None) -> Optional[Dict[str, Any]]:
@@ -57,8 +71,8 @@ def _format_tool_call_message(tool_call_message: ChatMessage) -> Dict[str, Any]:
     content: List[Dict[str, Any]] = []
 
     # tool call messages can contain reasoning content
-    if reasoning_contents := tool_call_message.meta.get("reasoning_contents"):
-        content.extend(_format_reasoning_contents(reasoning_contents=reasoning_contents))
+    if reasoning_content := tool_call_message.reasoning:
+        content.extend(_format_reasoning_content(reasoning_content=reasoning_content))
 
     # Tool call message can contain text
     if tool_call_message.text:
@@ -162,16 +176,16 @@ def _repair_tool_result_messages(bedrock_formatted_messages: List[Dict[str, Any]
     return [msg for _, msg in repaired_bedrock_formatted_messages]
 
 
-def _format_reasoning_contents(reasoning_contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def _format_reasoning_content(reasoning_content: ReasoningContent) -> List[Dict[str, Any]]:
     """
-    Format reasoning contents to match Bedrock's expected structure.
+    Format ReasoningContent to match Bedrock's expected structure.
 
-    :param reasoning_contents: List of reasoning content dictionaries from Haystack ChatMessage metadata.
+    :param reasoning_content: ReasoningContent object containing reasoning contents to format.
     :returns: List of formatted reasoning content dictionaries for Bedrock.
     """
     formatted_contents = []
-    for reasoning_content in reasoning_contents:
-        formatted_content = {"reasoningContent": reasoning_content["reasoning_content"]}
+    for content in reasoning_content.extra.get("reasoning_contents", []):
+        formatted_content = {"reasoningContent": content["reasoning_content"]}
         if reasoning_text := formatted_content["reasoningContent"].pop("reasoning_text", None):
             formatted_content["reasoningContent"]["reasoningText"] = reasoning_text
         if redacted_content := formatted_content["reasoningContent"].pop("redacted_content", None):
@@ -192,8 +206,8 @@ def _format_text_image_message(message: ChatMessage) -> Dict[str, Any]:
 
     bedrock_content_blocks: List[Dict[str, Any]] = []
     # Add reasoning content if available as the first content block
-    if message.meta.get("reasoning_contents"):
-        bedrock_content_blocks.extend(_format_reasoning_contents(reasoning_contents=message.meta["reasoning_contents"]))
+    if message.reasoning:
+        bedrock_content_blocks.extend(_format_reasoning_content(reasoning_content=message.reasoning))
 
     for part in content_parts:
         if isinstance(part, TextContent):
@@ -269,7 +283,7 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
             base_meta = {
                 "model": model,
                 "index": 0,
-                "finish_reason": response_body.get("stopReason"),
+                "finish_reason": FINISH_REASON_MAPPING.get(response_body.get("stopReason", "")),
                 "usage": {
                     # OpenAI's format for usage for cross ChatGenerator compatibility
                     "prompt_tokens": response_body.get("usage", {}).get("inputTokens", 0),
@@ -303,11 +317,26 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
                         reasoning_content["redacted_content"] = reasoning_content.pop("redactedContent")
                     reasoning_contents.append({"reasoning_content": reasoning_content})
 
-            # If reasoning contents were found, add them to the base meta
-            base_meta.update({"reasoning_contents": reasoning_contents})
+            reasoning_text = ""
+            for content in reasoning_contents:
+                if "reasoning_text" in content["reasoning_content"]:
+                    reasoning_text += content["reasoning_content"]["reasoning_text"]["text"]
+                elif "redacted_content" in content["reasoning_content"]:
+                    reasoning_text += "[REDACTED]"
 
             # Create a single ChatMessage with combined text and tool calls
-            replies.append(ChatMessage.from_assistant(" ".join(text_content), tool_calls=tool_calls, meta=base_meta))
+            replies.append(
+                ChatMessage.from_assistant(
+                    " ".join(text_content),
+                    tool_calls=tool_calls,
+                    meta=base_meta,
+                    reasoning=ReasoningContent(
+                        reasoning_text=reasoning_text, extra={"reasoning_contents": reasoning_contents}
+                    )
+                    if reasoning_contents
+                    else None,
+                )
+            )
 
     return replies
 
@@ -328,9 +357,8 @@ def _convert_event_to_streaming_chunk(
     """
     # Initialize an empty StreamingChunk to return if no relevant event is found
     # (e.g. for messageStart and contentBlockStop)
-    streaming_chunk = StreamingChunk(
-        content="", meta={"model": model, "received_at": datetime.now(timezone.utc).isoformat()}
-    )
+    base_meta = {"model": model, "received_at": datetime.now(timezone.utc).isoformat()}
+    streaming_chunk = StreamingChunk(content="", meta=base_meta)
 
     if "contentBlockStart" in event:
         # contentBlockStart always has the key "contentBlockIndex"
@@ -340,26 +368,15 @@ def _convert_event_to_streaming_chunk(
             tool_start = block_start["start"]["toolUse"]
             streaming_chunk = StreamingChunk(
                 content="",
-                meta={
-                    "model": model,
-                    # This is always 0 b/c it represents the choice index
-                    "index": 0,
-                    # We follow the same format used in the OpenAIChatGenerator
-                    "tool_calls": [  # Optional[List[ChoiceDeltaToolCall]]
-                        {
-                            "index": block_idx,  # int
-                            "id": tool_start["toolUseId"],  # Optional[str]
-                            "function": {  # Optional[ChoiceDeltaToolCallFunction]
-                                # Will accumulate deltas as string
-                                "arguments": "",  # Optional[str]
-                                "name": tool_start["name"],  # Optional[str]
-                            },
-                            "type": "function",  # Optional[Literal["function"]]
-                        }
-                    ],
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
-                },
+                index=block_idx,
+                tool_calls=[
+                    ToolCallDelta(
+                        index=block_idx,
+                        id=tool_start["toolUseId"],
+                        tool_name=tool_start["name"],
+                    )
+                ],
+                meta=base_meta,
             )
 
     elif "contentBlockDelta" in event:
@@ -370,39 +387,22 @@ def _convert_event_to_streaming_chunk(
         if "text" in delta:
             streaming_chunk = StreamingChunk(
                 content=delta["text"],
-                meta={
-                    "model": model,
-                    # This is always 0 b/c it represents the choice index
-                    "index": 0,
-                    "tool_calls": None,
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
-                },
+                index=block_idx,
+                meta=base_meta,
             )
         # This only occurs when accumulating the arguments for a toolUse
         # The content_block for this tool should already exist at this point
         elif "toolUse" in delta:
             streaming_chunk = StreamingChunk(
                 content="",
-                meta={
-                    "model": model,
-                    # This is always 0 b/c it represents the choice index
-                    "index": 0,
-                    "tool_calls": [  # Optional[List[ChoiceDeltaToolCall]]
-                        {
-                            "index": block_idx,  # int
-                            "id": None,  # Optional[str]
-                            "function": {  # Optional[ChoiceDeltaToolCallFunction]
-                                # Will accumulate deltas as string
-                                "arguments": delta["toolUse"].get("input", ""),  # Optional[str]
-                                "name": None,  # Optional[str]
-                            },
-                            "type": "function",  # Optional[Literal["function"]]
-                        }
-                    ],
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
-                },
+                index=block_idx,
+                tool_calls=[
+                    ToolCallDelta(
+                        index=block_idx,
+                        arguments=delta["toolUse"].get("input", ""),
+                    )
+                ],
+                meta=base_meta,
             )
         # This is for accumulating reasoning content deltas
         elif "reasoningContent" in delta:
@@ -411,28 +411,19 @@ def _convert_event_to_streaming_chunk(
                 reasoning_content["redacted_content"] = reasoning_content.pop("redactedContent")
             streaming_chunk = StreamingChunk(
                 content="",
+                index=block_idx,
                 meta={
-                    "model": model,
-                    "index": 0,
-                    "tool_calls": None,
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
+                    **base_meta,
                     "reasoning_contents": [{"index": block_idx, "reasoning_content": reasoning_content}],
                 },
             )
 
     elif "messageStop" in event:
-        finish_reason = event["messageStop"].get("stopReason")
+        finish_reason = FINISH_REASON_MAPPING.get(event["messageStop"].get("stopReason"))
         streaming_chunk = StreamingChunk(
             content="",
-            meta={
-                "model": model,
-                # This is always 0 b/c it represents the choice index
-                "index": 0,
-                "tool_calls": None,
-                "finish_reason": finish_reason,
-                "received_at": datetime.now(timezone.utc).isoformat(),
-            },
+            finish_reason=finish_reason,
+            meta=base_meta,
         )
 
     elif "metadata" in event and "usage" in event["metadata"]:
@@ -440,12 +431,7 @@ def _convert_event_to_streaming_chunk(
         streaming_chunk = StreamingChunk(
             content="",
             meta={
-                "model": model,
-                # This is always 0 b/c it represents the choice index
-                "index": 0,
-                "tool_calls": None,
-                "finish_reason": None,
-                "received_at": datetime.now(timezone.utc).isoformat(),
+                **base_meta,
                 "usage": {
                     "prompt_tokens": metadata["usage"].get("inputTokens", 0),
                     "completion_tokens": metadata["usage"].get("outputTokens", 0),
@@ -459,7 +445,7 @@ def _convert_event_to_streaming_chunk(
     return streaming_chunk
 
 
-def _process_reasoning_contents(chunks: List[StreamingChunk]) -> List[Dict[str, Any]]:
+def _process_reasoning_contents(chunks: List[StreamingChunk]) -> Optional[ReasoningContent]:
     """
     Process reasoning contents from a list of StreamingChunk objects into the Bedrock expected format.
 
@@ -491,6 +477,8 @@ def _process_reasoning_contents(chunks: List[StreamingChunk]) -> List[Dict[str,
                     )
                 if redacted_content:
                     formatted_reasoning_contents.append({"reasoning_content": {"redacted_content": redacted_content}})
+
+                # Reset accumulators for new group
                 reasoning_text = ""
                 reasoning_signature = None
                 redacted_content = None
@@ -516,85 +504,22 @@ def _process_reasoning_contents(chunks: List[StreamingChunk]) -> List[Dict[str,
         if redacted_content:
             formatted_reasoning_contents.append({"reasoning_content": {"redacted_content": redacted_content}})
 
-    return formatted_reasoning_contents
-
-
-def _convert_streaming_chunks_to_chat_message(chunks: List[StreamingChunk]) -> ChatMessage:
-    """
-    Converts a list of streaming chunks into a ChatMessage object.
-
-    The function processes streaming chunks to build a ChatMessage object, including extracting and constructing
-    tool calls, managing metadata such as model type, finish reason, and usage information.
-    The tool call processing handles accumulating data across the chunks and attempts to parse JSON-formatted
-    arguments for tool calls.
-
-    :param chunks: A list of StreamingChunk objects representing parts of the assistant's response.
-
-    :returns:
-        A ChatMessage object constructed from the streaming chunks, containing the aggregated text, processed tool
-        calls, and metadata.
-    """
-    # Join all text content from the chunks
-    text = "".join([chunk.content for chunk in chunks])
-
-    # If reasoning content is present in any chunk, accumulate it
-    reasoning_contents = _process_reasoning_contents(chunks=chunks)
-
-    # Process tool calls if present in any chunk
-    tool_calls = []
-    tool_call_data: Dict[int, Dict[str, str]] = {}  # Track tool calls by index
-    for chunk_payload in chunks:
-        tool_calls_meta = chunk_payload.meta.get("tool_calls")
-        if tool_calls_meta is not None:
-            for delta in tool_calls_meta:
-                # We use the index of the tool call to track it across chunks since the ID is not always provided
-                if delta["index"] not in tool_call_data:
-                    tool_call_data[delta["index"]] = {"id": "", "name": "", "arguments": ""}
-
-                # Save the ID if present
-                if delta.get("id"):
-                    tool_call_data[delta["index"]]["id"] = delta["id"]
-
-                if delta.get("function"):
-                    if delta["function"].get("name"):
-                        tool_call_data[delta["index"]]["name"] += delta["function"]["name"]
-                    if delta["function"].get("arguments"):
-                        tool_call_data[delta["index"]]["arguments"] += delta["function"]["arguments"]
-
-    # Convert accumulated tool call data into ToolCall objects
-    for call_data in tool_call_data.values():
-        try:
-            arguments = json.loads(call_data.get("arguments", "{}")) if call_data.get("arguments") else {}
-            tool_calls.append(ToolCall(id=call_data["id"], tool_name=call_data["name"], arguments=arguments))
-        except json.JSONDecodeError:
-            logger.warning(
-                "Amazon Bedrock returned a malformed JSON string for tool call arguments. This tool call will be "
-                "skipped. Tool call ID: {tool_id}, Tool name: {tool_name}, Arguments: {tool_arguments}",
-                tool_id=call_data["id"],
-                tool_name=call_data["name"],
-                tool_arguments=call_data["arguments"],
-            )
-
-    # finish_reason can appear in different places so we look for the last one
-    finish_reasons = [
-        chunk.meta.get("finish_reason") for chunk in chunks if chunk.meta.get("finish_reason") is not None
-    ]
-    finish_reason = finish_reasons[-1] if finish_reasons else None
-
-    # usage is usually last but we look for it as well
-    usages = [chunk.meta.get("usage") for chunk in chunks if chunk.meta.get("usage") is not None]
-    usage = usages[-1] if usages else None
-
-    meta = {
-        "model": chunks[-1].meta["model"],
-        "index": 0,
-        "finish_reason": finish_reason,
-        "completion_start_time": chunks[0].meta.get("received_at"),  # first chunk received
-        "usage": usage,
-        "reasoning_contents": reasoning_contents,
-    }
-
-    return ChatMessage.from_assistant(text=text or None, tool_calls=tool_calls, meta=meta)
+    # Combine all reasoning texts into a single string for the main reasoning_text field
+    final_reasoning_text = ""
+    for content in formatted_reasoning_contents:
+        if "reasoning_text" in content["reasoning_content"]:
+            # mypy somehow thinks that content["reasoning_content"]["reasoning_text"]["text"] can be of type None
+            final_reasoning_text += content["reasoning_content"]["reasoning_text"]["text"]  # type: ignore[operator]
+        elif "redacted_content" in content["reasoning_content"]:
+            final_reasoning_text += "[REDACTED]"
+
+    return (
+        ReasoningContent(
+            reasoning_text=final_reasoning_text, extra={"reasoning_contents": formatted_reasoning_contents}
+        )
+        if formatted_reasoning_contents
+        else None
+    )
 
 
 def _parse_streaming_response(
@@ -612,13 +537,26 @@ def _parse_streaming_response(
     :param component_info: ComponentInfo object
     :return: List of ChatMessage objects
     """
+    content_block_idxs = set()
     chunks: List[StreamingChunk] = []
     for event in response_stream:
         streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model, component_info=component_info)
+        content_block_idx = streaming_chunk.index
+        if content_block_idx is not None and content_block_idx not in content_block_idxs:
+            streaming_chunk.start = True
+            content_block_idxs.add(content_block_idx)
         streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
-    replies = [_convert_streaming_chunks_to_chat_message(chunks=chunks)]
-    return replies
+    reply = _convert_streaming_chunks_to_chat_message(chunks=chunks)
+    reasoning_content = _process_reasoning_contents(chunks=chunks)
+    reply = ChatMessage.from_assistant(
+        text=reply.text,
+        meta=reply.meta,
+        name=reply.name,
+        tool_calls=reply.tool_calls,
+        reasoning=reasoning_content,
+    )
+    return [reply]
 
 
 async def _parse_streaming_response_async(
@@ -636,10 +574,23 @@ async def _parse_streaming_response_async(
     :param component_info: ComponentInfo object
     :return: List of ChatMessage objects
     """
+    content_block_idxs = set()
     chunks: List[StreamingChunk] = []
     async for event in response_stream:
         streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model, component_info=component_info)
+        content_block_idx = streaming_chunk.index
+        if content_block_idx is not None and content_block_idx not in content_block_idxs:
+            streaming_chunk.start = True
+            content_block_idxs.add(content_block_idx)
         await streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
-    replies = [_convert_streaming_chunks_to_chat_message(chunks=chunks)]
-    return replies
+    reply = _convert_streaming_chunks_to_chat_message(chunks=chunks)
+    reasoning_content = _process_reasoning_contents(chunks=chunks)
+    reply = ChatMessage.from_assistant(
+        text=reply.text,
+        meta=reply.meta,
+        name=reply.name,
+        tool_calls=reply.tool_calls,
+        reasoning=reasoning_content,
+    )
+    return [reply]

{amazon_bedrock_haystack-3.11.0 → amazon_bedrock_haystack-4.0.0}/tests/test_chat_generator.py

@@ -392,7 +392,7 @@ class TestAmazonBedrockChatGeneratorInference:
             assert tool_call.id, "Tool call does not contain value for 'id' key"
             assert tool_call.tool_name == "weather"
             assert tool_call.arguments["city"] in ["Paris", "Berlin"]
-            assert tool_call_message.meta["finish_reason"] == "tool_use"
+            assert tool_call_message.meta["finish_reason"] == "tool_calls"
 
         # Mock the response we'd get from ToolInvoker
         tool_result_messages = [
@@ -438,12 +438,14 @@ class TestAmazonBedrockChatGeneratorInference:
         assert isinstance(tool_call_message, ChatMessage), "Tool message is not a ChatMessage instance"
         assert ChatMessage.is_from(tool_call_message, ChatRole.ASSISTANT), "Tool message is not from the assistant"
 
+        assert tool_call_message.reasoning is not None, "Tool message does not contain reasoning"
+
         tool_calls = tool_call_message.tool_calls
         assert len(tool_calls) == 1
         assert tool_calls[0].id, "Tool call does not contain value for 'id' key"
         assert tool_calls[0].tool_name == "weather"
         assert tool_calls[0].arguments["city"] == "Paris"
-        assert tool_call_message.meta["finish_reason"] == "tool_use"
+        assert tool_call_message.meta["finish_reason"] == "tool_calls"
 
         # Mock the response we'd get from ToolInvoker
         tool_result_messages = [
@@ -489,12 +491,14 @@ class TestAmazonBedrockChatGeneratorInference:
         assert isinstance(tool_call_message, ChatMessage), "Tool message is not a ChatMessage instance"
         assert ChatMessage.is_from(tool_call_message, ChatRole.ASSISTANT), "Tool message is not from the assistant"
 
+        assert tool_call_message.reasoning is not None, "Tool message does not contain reasoning"
+
         tool_calls = tool_call_message.tool_calls
         assert len(tool_calls) == 1
         assert tool_calls[0].id, "Tool call does not contain value for 'id' key"
         assert tool_calls[0].tool_name == "weather"
         assert tool_calls[0].arguments["city"] == "Paris"
-        assert tool_call_message.meta["finish_reason"] == "tool_use"
+        assert tool_call_message.meta["finish_reason"] == "tool_calls"
 
         # Mock the response we'd get from ToolInvoker
         tool_result_messages = [
@@ -533,7 +537,8 @@ class TestAmazonBedrockChatGeneratorInference:
 
         assert len(results["replies"]) > 0, "No replies received"
         assert isinstance(
-            results["replies"][0].meta["reasoning_contents"][0]["reasoning_content"]["redacted_content"], bytes
+            results["replies"][0].reasoning.extra["reasoning_contents"][0]["reasoning_content"]["redacted_content"],
+            bytes,
         )
 
     def test_live_run_with_redacted_thinking_streaming(self, tools):
@@ -560,7 +565,8 @@ class TestAmazonBedrockChatGeneratorInference:
 
         assert len(results["replies"]) > 0, "No replies received"
         assert isinstance(
-            results["replies"][0].meta["reasoning_contents"][0]["reasoning_content"]["redacted_content"], bytes
+            results["replies"][0].reasoning.extra["reasoning_contents"][0]["reasoning_content"]["redacted_content"],
+            bytes,
         )
 
     @pytest.mark.parametrize("model_name", STREAMING_TOOL_MODELS)
@@ -591,7 +597,7 @@ class TestAmazonBedrockChatGeneratorInference:
             assert tool_call.id, "Tool call does not contain value for 'id' key"
             assert tool_call.tool_name == "weather"
             assert tool_call.arguments["city"] in ["Paris", "Berlin"]
-            assert tool_call_message.meta["finish_reason"] == "tool_use"
+            assert tool_call_message.meta["finish_reason"] == "tool_calls"
 
         # Mock the response we'd get from ToolInvoker
         tool_result_messages = [
@@ -633,7 +639,7 @@ class TestAmazonBedrockChatGeneratorInference:
         assert tool_call.id is not None
         assert tool_call.tool_name == "hello_world"
         assert tool_call.arguments == {}
-        assert message.meta["finish_reason"] == "tool_use"
+        assert message.meta["finish_reason"] == "tool_calls"
 
         new_messages = [
             *initial_messages,
@@ -724,7 +730,7 @@ class TestAmazonBedrockChatGeneratorAsyncInference:
             assert tool_call.id, "Tool call does not contain value for 'id' key"
             assert tool_call.tool_name == "weather"
             assert tool_call.arguments["city"] in ["Paris", "Berlin"]
-            assert tool_call_message.meta["finish_reason"] == "tool_use"
+            assert tool_call_message.meta["finish_reason"] == "tool_calls"
 
         # Mock the response we'd get from ToolInvoker
         tool_result_messages = [
@@ -800,7 +806,7 @@ class TestAmazonBedrockChatGeneratorAsyncInference:
             assert tool_call.id, "Tool call does not contain value for 'id' key"
             assert tool_call.tool_name == "weather"
             assert tool_call.arguments["city"] in ["Paris", "Berlin"]
-            assert tool_call_message.meta["finish_reason"] == "tool_use"
+            assert tool_call_message.meta["finish_reason"] == "tool_calls"
 
         # Mock the response we'd get from ToolInvoker
         tool_result_messages = [