amazon-bedrock-haystack 6.2.0__tar.gz → 6.3.0__tar.gz

{amazon_bedrock_haystack-6.2.0 → amazon_bedrock_haystack-6.3.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [integrations/amazon_bedrock-v6.2.0] - 2026-01-13
+
+### 🚀 Features
+
+- Support flattened generation_kwargs with AmazonBedrockChatGenerator (#2741)
+
+
 ## [integrations/amazon_bedrock-v6.1.1] - 2026-01-13
 
 ### 🌀 Miscellaneous

{amazon_bedrock_haystack-6.2.0 → amazon_bedrock_haystack-6.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 6.2.0
+Version: 6.3.0
 Summary: An integration of AWS S3 and Bedrock as a Downloader and Generator components.
 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
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Requires-Dist: aioboto3>=14.0.0
 Requires-Dist: boto3>=1.28.57
-Requires-Dist: haystack-ai>=2.22.0
+Requires-Dist: haystack-ai>=2.23.0
 Description-Content-Type: text/markdown
 
 # amazon-bedrock-haystack

{amazon_bedrock_haystack-6.2.0 → amazon_bedrock_haystack-6.3.0}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.22.0", "boto3>=1.28.57", "aioboto3>=14.0.0"]
+dependencies = ["haystack-ai>=2.23.0", "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-6.2.0 → amazon_bedrock_haystack-6.3.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/chat_generator.py

@@ -423,27 +423,31 @@ class AmazonBedrockChatGenerator:
 
     def _resolve_flattened_generation_kwargs(self, generation_kwargs: dict[str, Any]) -> dict[str, Any]:
         generation_kwargs = generation_kwargs.copy()
-        if "disable_parallel_tool_use" in generation_kwargs:
-            disable_parallel_tool_use = generation_kwargs.pop("disable_parallel_tool_use")
-            tool_choice = generation_kwargs.setdefault("tool_choice", {})
-            tool_choice["disable_parallel_tool_use"] = disable_parallel_tool_use
 
-        if "parallel_tool_use" in generation_kwargs:
-            parallel_tool_use = generation_kwargs.pop("parallel_tool_use")
+        disable_parallel_tool_use = generation_kwargs.pop("disable_parallel_tool_use", None)
+        parallel_tool_use = generation_kwargs.pop("parallel_tool_use", None)
+
+        if disable_parallel_tool_use is not None and parallel_tool_use is not None:
+            msg = "Cannot set both disable_parallel_tool_use and parallel_tool_use"
+            raise ValueError(msg)
+        elif parallel_tool_use is not None:
             disable_parallel_tool_use = not parallel_tool_use
+
+        if disable_parallel_tool_use is not None:
             tool_choice = generation_kwargs.setdefault("tool_choice", {})
             tool_choice["disable_parallel_tool_use"] = disable_parallel_tool_use
+            tool_choice.setdefault("type", "auto")  # default value
 
-        if "tool_choice_type" in generation_kwargs:
-            tool_choice_type = generation_kwargs.pop("tool_choice_type")
+        tool_choice_type = generation_kwargs.pop("tool_choice_type", None)
+        if tool_choice_type is not None:
             tool_choice = generation_kwargs.setdefault("tool_choice", {})
             tool_choice["type"] = tool_choice_type
 
-        if "thinking_budget_tokens" in generation_kwargs:
-            thinking_budget_tokens = generation_kwargs.pop("thinking_budget_tokens")
+        thinking_budget_tokens = generation_kwargs.pop("thinking_budget_tokens", None)
+        if thinking_budget_tokens is not None:
             thinking = generation_kwargs.setdefault("thinking", {})
             thinking["budget_tokens"] = thinking_budget_tokens
-            thinking["type"] = "enabled"
+            thinking.setdefault("type", "enabled")
 
         return generation_kwargs
 

{amazon_bedrock_haystack-6.2.0 → amazon_bedrock_haystack-6.3.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/utils.py

@@ -60,6 +60,24 @@ def _format_tools(tools: list[Tool] | None = None) -> dict[str, Any] | None:
     return {"tools": tool_specs} if tool_specs else None
 
 
+def _convert_image_content_to_bedrock_format(image_content: ImageContent) -> dict[str, Any]:
+    """
+    Convert a Haystack ImageContent to Bedrock format.
+    """
+
+    image_format = image_content.mime_type.split("/")[-1] if image_content.mime_type else None
+    if image_format not in IMAGE_SUPPORTED_FORMATS:
+        err_msg = (
+            f"Unsupported image format: {image_format}. "
+            f"Bedrock supports the following image formats: {IMAGE_SUPPORTED_FORMATS}"
+        )
+        raise ValueError(err_msg)
+
+    source = {"bytes": base64.b64decode(image_content.base64_image)}
+
+    return {"image": {"format": image_format, "source": source}}
+
+
 def _format_tool_call_message(tool_call_message: ChatMessage) -> dict[str, Any]:
     """
     Format a Haystack ChatMessage containing tool calls into Bedrock format.
@@ -94,19 +112,30 @@ def _format_tool_result_message(tool_call_result_message: ChatMessage) -> dict[s
     """
     # Assuming tool call result messages will only contain tool results
     tool_results = []
-    for result in tool_call_result_message.tool_call_results:
-        try:
-            json_result = json.loads(result.result)
-            content = [{"json": json_result}]
-        except json.JSONDecodeError:
-            content = [{"text": result.result}]
+    for tool_call_result in tool_call_result_message.tool_call_results:
+        if isinstance(tool_call_result.result, str):
+            try:
+                json_result = json.loads(tool_call_result.result)
+                content = [{"json": json_result}]
+            except json.JSONDecodeError:
+                content = [{"text": tool_call_result.result}]
+        elif isinstance(tool_call_result.result, list):
+            content = []
+            for item in tool_call_result.result:
+                if isinstance(item, TextContent):
+                    content.append({"text": item.text})
+                elif isinstance(item, ImageContent):
+                    content.append(_convert_image_content_to_bedrock_format(item))
+        else:
+            err_msg = "Unsupported content type in tool call result"
+            raise ValueError(err_msg)
 
         tool_results.append(
             {
                 "toolResult": {
-                    "toolUseId": result.origin.id,
+                    "toolUseId": tool_call_result.origin.id,
                     "content": content,
-                    **({"status": "error"} if result.error else {}),
+                    **({"status": "error"} if tool_call_result.error else {}),
                 }
             }
         )
@@ -217,16 +246,7 @@ def _format_text_image_message(message: ChatMessage) -> dict[str, Any]:
             if message.is_from(ChatRole.ASSISTANT):
                 err_msg = "Image content is not supported for assistant messages"
                 raise ValueError(err_msg)
-
-            image_format = part.mime_type.split("/")[-1] if part.mime_type else None
-            if image_format not in IMAGE_SUPPORTED_FORMATS:
-                err_msg = (
-                    f"Unsupported image format: {image_format}. "
-                    f"Bedrock supports the following image formats: {IMAGE_SUPPORTED_FORMATS}"
-                )
-                raise ValueError(err_msg)
-            source = {"bytes": base64.b64decode(part.base64_image)}
-            bedrock_content_blocks.append({"image": {"format": image_format, "source": source}})
+            bedrock_content_blocks.append(_convert_image_content_to_bedrock_format(part))
 
     return {"role": message.role.value, "content": bedrock_content_blocks}
 

{amazon_bedrock_haystack-6.2.0 → amazon_bedrock_haystack-6.3.0}/tests/test_chat_generator.py

@@ -3,10 +3,11 @@ from typing import Any
 
 import pytest
 from haystack import Pipeline
+from haystack.components.agents import Agent
 from haystack.components.generators.utils import print_streaming_chunk
 from haystack.components.tools import ToolInvoker
-from haystack.dataclasses import ChatMessage, ChatRole, ImageContent, StreamingChunk, ToolCall
-from haystack.tools import Tool, Toolset
+from haystack.dataclasses import ChatMessage, ChatRole, ImageContent, StreamingChunk, TextContent, ToolCall
+from haystack.tools import Tool, Toolset, create_tool_from_function
 
 from haystack_integrations.components.generators.amazon_bedrock import AmazonBedrockChatGenerator
 
@@ -409,21 +410,68 @@ class TestAmazonBedrockChatGenerator:
             ]
         }
 
-    def test_prepare_request_params_with_flattened_generation_kwargs(self, mock_boto3_session, set_env_variables):
+    @pytest.mark.parametrize(
+        "generation_kwargs,additional_model_request_fields",
+        [
+            (
+                {
+                    "parallel_tool_use": False,
+                    "tool_choice_type": "any",
+                    "thinking_budget_tokens": 1024,
+                },
+                {
+                    "tool_choice": {"disable_parallel_tool_use": True, "type": "any"},
+                    "thinking": {"budget_tokens": 1024, "type": "enabled"},
+                },
+            ),
+            (
+                {
+                    "parallel_tool_use": True,
+                    "tool_choice_type": "all",
+                },
+                {
+                    "tool_choice": {"disable_parallel_tool_use": False, "type": "all"},
+                },
+            ),
+            (
+                {
+                    "parallel_tool_use": True,
+                },
+                {
+                    "tool_choice": {"disable_parallel_tool_use": False, "type": "auto"},
+                },
+            ),
+            (
+                {
+                    "disable_parallel_tool_use": True,
+                },
+                {
+                    "tool_choice": {"disable_parallel_tool_use": True, "type": "auto"},
+                },
+            ),
+            (
+                {
+                    "thinking_budget_tokens": None,
+                    "parallel_tool_use": None,
+                    "tool_choice_type": None,
+                },
+                {},
+            ),
+        ],
+    )
+    def test_prepare_request_params_with_flattened_generation_kwargs(
+        self, mock_boto3_session, set_env_variables, generation_kwargs, additional_model_request_fields
+    ):
         generator = AmazonBedrockChatGenerator(model="anthropic.claude-3-5-sonnet-20240620-v1:0")
         request_params, _ = generator._prepare_request_params(
             messages=[ChatMessage.from_user("What's the capital of France?")],
-            generation_kwargs={
-                "parallel_tool_use": False,
-                "tool_choice_type": "any",
-                "thinking_budget_tokens": 1024,
-            },
+            generation_kwargs=generation_kwargs,
         )
 
-        assert request_params["additionalModelRequestFields"] == {
-            "tool_choice": {"disable_parallel_tool_use": True, "type": "any"},
-            "thinking": {"budget_tokens": 1024, "type": "enabled"},
-        }
+        if not additional_model_request_fields:
+            assert "additionalModelRequestFields" not in request_params
+        else:
+            assert request_params["additionalModelRequestFields"] == additional_model_request_fields
 
 
 # In the CI, those tests are skipped if AWS Authentication fails
@@ -467,6 +515,30 @@ class TestAmazonBedrockChatGeneratorInference:
         assert first_reply.text
         assert "apple" in first_reply.text.lower()
 
+    @pytest.mark.parametrize("model_name", MODELS_TO_TEST_WITH_IMAGE_INPUT)
+    def test_live_run_agent_with_images_in_tool_result(self, model_name, test_files_path):
+        def retrieve_image():
+            return [
+                TextContent("Here is the retrieved image."),
+                ImageContent.from_file_path(test_files_path / "apple.jpg", size=(100, 100)),
+            ]
+
+        image_retriever_tool = create_tool_from_function(
+            name="retrieve_image", description="Tool to retrieve an image", function=retrieve_image
+        )
+        image_retriever_tool.outputs_to_string = {"raw_result": True}
+
+        agent = Agent(
+            chat_generator=AmazonBedrockChatGenerator(model=model_name),
+            system_prompt="You are an Agent that can retrieve images and describe them.",
+            tools=[image_retriever_tool],
+        )
+
+        user_message = ChatMessage.from_user("Retrieve the image and describe it in max 5 words.")
+        result = agent.run(messages=[user_message])
+
+        assert "apple" in result["last_message"].text.lower()
+
     @pytest.mark.parametrize("model_name", MODELS_TO_TEST)
     def test_default_inference_with_streaming(self, model_name, chat_messages):
         streaming_callback_called = False

{amazon_bedrock_haystack-6.2.0 → amazon_bedrock_haystack-6.3.0}/tests/test_chat_generator_utils.py

@@ -9,6 +9,7 @@ from haystack.dataclasses import (
     ImageContent,
     ReasoningContent,
     StreamingChunk,
+    TextContent,
     ToolCall,
     ToolCallDelta,
 )
@@ -120,6 +121,52 @@ class TestAmazonBedrockChatGeneratorUtils:
             {"role": "assistant", "content": [{"text": "The weather in Paris is sunny and 25°C."}]},
         ]
 
+    def test_format_messages_tool_result_with_image(self):
+        base64_image = (
+            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+        )
+
+        messages = [
+            ChatMessage.from_user("Retrieve the image and describe it in max 5 words."),
+            ChatMessage.from_assistant(
+                tool_calls=[ToolCall(id="123", tool_name="image_retriever", arguments={"query": "random query"})]
+            ),
+            ChatMessage.from_tool(
+                tool_result=[
+                    TextContent("Here's the retrieved image"),
+                    ImageContent(base64_image=base64_image, mime_type="image/png"),
+                ],
+                origin=ToolCall(id="123", tool_name="image_retriever", arguments={"query": "random query"}),
+            ),
+            ChatMessage.from_assistant("Beautiful landscape with mountains"),
+        ]
+        formatted_system_prompts, formatted_messages = _format_messages(messages)
+        assert formatted_system_prompts == []
+        assert formatted_messages == [
+            {"role": "user", "content": [{"text": "Retrieve the image and describe it in max 5 words."}]},
+            {
+                "role": "assistant",
+                "content": [
+                    {"toolUse": {"toolUseId": "123", "name": "image_retriever", "input": {"query": "random query"}}}
+                ],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "toolResult": {
+                            "toolUseId": "123",
+                            "content": [
+                                {"text": "Here's the retrieved image"},
+                                {"image": {"format": "png", "source": {"bytes": base64.b64decode(base64_image)}}},
+                            ],
+                        }
+                    }
+                ],
+            },
+            {"role": "assistant", "content": [{"text": "Beautiful landscape with mountains"}]},
+        ]
+
     def test_format_message_thinking(self):
         assistant_message = ChatMessage.from_assistant(
             "This is a test message.",