amazon-bedrock-haystack 3.7.0__tar.gz → 3.9.0__tar.gz

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [integrations/amazon_bedrock-v3.8.0] - 2025-07-04
+
+### 🚀 Features
+
+- Pass component_info to StreamingChunk in AmazonBedrockChatGenerator (#2042)
+
+### 🧹 Chores
+
+- Remove black (#1985)
+- Improve typing for select_streaming_callback (#2008)
+
+
+## [integrations/amazon_bedrock-v3.7.0] - 2025-06-11
+
+### 🐛 Bug Fixes
+
+- Fix Bedrock types + add py.typed (#1912)
+- Bedrock - do not assume connection issues in case of ClientError (#1921)
+
+### ⚙️ CI
+
+- Bedrock - improve worfklow; skip tests from CI (#1773)
+
+### 🧹 Chores
+
+- Update bedrock_ranker_example.py (#1740)
+- Align core-integrations Hatch scripts (#1898)
+- Update md files for new hatch scripts (#1911)
+
+
 ## [integrations/amazon_bedrock-v3.6.2] - 2025-05-13
 
 ### 🧹 Chores

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 3.7.0
+Version: 3.9.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.13.1
+Requires-Dist: haystack-ai>=2.16.0
 Description-Content-Type: text/markdown
 
 # amazon-bedrock-haystack

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.13.1", "boto3>=1.28.57", "aioboto3>=14.0.0"]
+dependencies = ["haystack-ai>=2.16.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"
@@ -58,6 +58,7 @@ dependencies = [
     "pytest-rerunfailures",
     "mypy",
     "pip",
+    "pillow", # image resizing
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -86,11 +87,6 @@ module = [
 ]
 ignore_missing_imports = true
 
-[tool.black]
-target-version = ["py38"]
-line-length = 120
-skip-string-normalization = true
-
 [tool.ruff]
 target-version = "py38"
 line-length = 120
@@ -168,9 +164,6 @@ exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 [tool.pytest.ini_options]
 addopts = "--strict-markers"
 markers = [
-  "unit: unit tests",
   "integration: integration tests",
-  "embedders: embedders tests",
-  "generators: generators tests",
 ]
 log_cli = true

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/chat_generator.py

@@ -5,7 +5,7 @@ from botocore.config import Config
 from botocore.eventstream import EventStream
 from botocore.exceptions import ClientError
 from haystack import component, default_from_dict, default_to_dict, logging
-from haystack.dataclasses import ChatMessage, StreamingCallbackT, select_streaming_callback
+from haystack.dataclasses import ChatMessage, ComponentInfo, StreamingCallbackT, select_streaming_callback
 from haystack.tools import (
     Tool,
     Toolset,
@@ -56,6 +56,22 @@ class AmazonBedrockChatGenerator:
     client.run(messages, generation_kwargs={"max_tokens": 512})
     ```
 
+    ### Multimodal example
+    ```python
+    from haystack.dataclasses import ChatMessage, ImageContent
+    from haystack_integrations.components.generators.amazon_bedrock import AmazonBedrockChatGenerator
+
+    generator = AmazonBedrockChatGenerator(model="anthropic.claude-3-5-sonnet-20240620-v1:0")
+
+    image_content = ImageContent.from_file_path(file_path="apple.jpg")
+
+    message = ChatMessage.from_user(content_parts=["Describe the image using 10 words at most.", image_content])
+
+    response = generator.run(messages=[message])["replies"][0].text
+
+    print(response)
+    > The image shows a red apple.
+
     ### Tool usage example
     # AmazonBedrockChatGenerator supports Haystack's unified tool architecture, allowing tools to be used
     # across different chat generators. The same tool definitions and usage patterns work consistently
@@ -371,7 +387,9 @@ class AmazonBedrockChatGenerator:
         if additional_fields:
             params["additionalModelRequestFields"] = additional_fields
 
-        callback = select_streaming_callback(
+        # overloads that exhaust finite Literals(bool) not treated as exhaustive
+        # see https://github.com/python/mypy/issues/14764
+        callback = select_streaming_callback(  # type: ignore[call-overload]
             init_callback=self.streaming_callback,
             runtime_callback=streaming_callback,
             requires_async=requires_async,
@@ -406,6 +424,8 @@ class AmazonBedrockChatGenerator:
         :raises AmazonBedrockInferenceError:
             If the Bedrock inference API call fails.
         """
+        component_info = ComponentInfo.from_component(self)
+
         params, callback = self._prepare_request_params(
             messages=messages,
             streaming_callback=streaming_callback,
@@ -422,7 +442,12 @@ class AmazonBedrockChatGenerator:
                     msg = "No stream found in the response."
                     raise AmazonBedrockInferenceError(msg)
                 # the type of streaming callback is checked in _prepare_request_params, but mypy doesn't know
-                replies = _parse_streaming_response(response_stream, callback, self.model)  # type: ignore[arg-type]
+                replies = _parse_streaming_response(
+                    response_stream=response_stream,
+                    streaming_callback=callback,  # type: ignore[arg-type]
+                    model=self.model,
+                    component_info=component_info,
+                )
             else:
                 response = self.client.converse(**params)
                 replies = _parse_completion_response(response, self.model)
@@ -459,6 +484,8 @@ class AmazonBedrockChatGenerator:
         :raises AmazonBedrockInferenceError:
             If the Bedrock inference API call fails.
         """
+        component_info = ComponentInfo.from_component(self)
+
         params, callback = self._prepare_request_params(
             messages=messages,
             streaming_callback=streaming_callback,
@@ -479,7 +506,12 @@ class AmazonBedrockChatGenerator:
                         msg = "No stream found in the response."
                         raise AmazonBedrockInferenceError(msg)
                     # the type of streaming callback is checked in _prepare_request_params, but mypy doesn't know
-                    replies = await _parse_streaming_response_async(response_stream, callback, self.model)  # type: ignore[arg-type]
+                    replies = await _parse_streaming_response_async(
+                        response_stream=response_stream,
+                        streaming_callback=callback,  # type: ignore[arg-type]
+                        model=self.model,
+                        component_info=component_info,
+                    )
                 else:
                     response = await async_client.converse(**params)
                     replies = _parse_completion_response(response, self.model)

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/utils.py

@@ -1,3 +1,4 @@
+import base64
 import json
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple
@@ -8,8 +9,11 @@ from haystack.dataclasses import (
     AsyncStreamingCallbackT,
     ChatMessage,
     ChatRole,
+    ComponentInfo,
+    ImageContent,
     StreamingChunk,
     SyncStreamingCallbackT,
+    TextContent,
     ToolCall,
 )
 from haystack.tools import Tool
@@ -17,6 +21,10 @@ from haystack.tools import Tool
 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"]
+
+
 # Haystack to Bedrock util methods
 def _format_tools(tools: Optional[List[Tool]] = None) -> Optional[Dict[str, Any]]:
     """
@@ -149,6 +157,39 @@ def _repair_tool_result_messages(bedrock_formatted_messages: List[Dict[str, Any]
     return [msg for _, msg in repaired_bedrock_formatted_messages]
 
 
+def _format_text_image_message(message: ChatMessage) -> Dict[str, Any]:
+    """
+    Format a Haystack ChatMessage containing text and optional image content into Bedrock format.
+
+    :param message: Haystack ChatMessage.
+    :returns: Dictionary representing the message in Bedrock's expected format.
+    :raises ValueError: If image content is found in an assistant message or an unsupported image format is used.
+    """
+    content_parts = message._content
+
+    bedrock_content_blocks: List[Dict[str, Any]] = []
+    for part in content_parts:
+        if isinstance(part, TextContent):
+            bedrock_content_blocks.append({"text": part.text})
+
+        elif isinstance(part, ImageContent):
+            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}})
+
+    return {"role": message.role.value, "content": bedrock_content_blocks}
+
+
 def _format_messages(messages: List[ChatMessage]) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
     """
     Format a list of Haystack ChatMessages to the format expected by Bedrock API.
@@ -174,8 +215,7 @@ def _format_messages(messages: List[ChatMessage]) -> Tuple[List[Dict[str, Any]],
         elif msg.tool_call_results:
             bedrock_formatted_messages.append(_format_tool_result_message(msg))
         else:
-            # regular user or assistant messages with only text content
-            bedrock_formatted_messages.append({"role": msg.role.value, "content": [{"text": msg.text}]})
+            bedrock_formatted_messages.append(_format_text_image_message(msg))
 
     repaired_bedrock_formatted_messages = _repair_tool_result_messages(bedrock_formatted_messages)
     return system_prompts, repaired_bedrock_formatted_messages
@@ -235,7 +275,9 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
 
 
 # Bedrock streaming to Haystack util methods
-def _convert_event_to_streaming_chunk(event: Dict[str, Any], model: str) -> StreamingChunk:
+def _convert_event_to_streaming_chunk(
+    event: Dict[str, Any], model: str, component_info: ComponentInfo
+) -> StreamingChunk:
     """
     Convert a Bedrock streaming event to a Haystack StreamingChunk.
 
@@ -244,6 +286,7 @@ def _convert_event_to_streaming_chunk(event: Dict[str, Any], model: str) -> Stre
 
     :param event: Dictionary containing a Bedrock streaming event.
     :param model: The model ID used for generation, included in chunk metadata.
+    :param component_info: ComponentInfo object
     :returns: StreamingChunk object containing the content and metadata extracted from the event.
     """
     # Initialize an empty StreamingChunk to return if no relevant event is found
@@ -358,6 +401,8 @@ def _convert_event_to_streaming_chunk(event: Dict[str, Any], model: str) -> Stre
             },
         )
 
+    streaming_chunk.component_info = component_info
+
     return streaming_chunk
 
 
@@ -438,6 +483,7 @@ def _parse_streaming_response(
     response_stream: EventStream,
     streaming_callback: SyncStreamingCallbackT,
     model: str,
+    component_info: ComponentInfo,
 ) -> List[ChatMessage]:
     """
     Parse a streaming response from Bedrock.
@@ -445,11 +491,12 @@ def _parse_streaming_response(
     :param response_stream: EventStream from Bedrock API
     :param streaming_callback: Callback for streaming chunks
     :param model: The model ID used for generation
+    :param component_info: ComponentInfo object
     :return: List of ChatMessage objects
     """
     chunks: List[StreamingChunk] = []
     for event in response_stream:
-        streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model)
+        streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model, component_info=component_info)
         streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
     replies = [_convert_streaming_chunks_to_chat_message(chunks=chunks)]
@@ -460,6 +507,7 @@ async def _parse_streaming_response_async(
     response_stream: EventStream,
     streaming_callback: AsyncStreamingCallbackT,
     model: str,
+    component_info: ComponentInfo,
 ) -> List[ChatMessage]:
     """
     Parse a streaming response from Bedrock.
@@ -467,11 +515,12 @@ async def _parse_streaming_response_async(
     :param response_stream: EventStream from Bedrock API
     :param streaming_callback: Callback for streaming chunks
     :param model: The model ID used for generation
+    :param component_info: ComponentInfo object
     :return: List of ChatMessage objects
     """
     chunks: List[StreamingChunk] = []
     async for event in response_stream:
-        streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model)
+        streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model, component_info=component_info)
         await streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
     replies = [_convert_streaming_chunks_to_chat_message(chunks=chunks)]

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/tests/conftest.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from unittest.mock import patch
 
 import pytest
@@ -24,3 +25,8 @@ def mock_boto3_session():
 def mock_aioboto3_session():
     with patch("aioboto3.Session") as mock_client:
         yield mock_client
+
+
+@pytest.fixture()
+def test_files_path():
+    return Path(__file__).parent / "test_files"

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/tests/test_chat_generator.py

@@ -4,7 +4,7 @@ import pytest
 from haystack import Pipeline
 from haystack.components.generators.utils import print_streaming_chunk
 from haystack.components.tools import ToolInvoker
-from haystack.dataclasses import ChatMessage, ChatRole, StreamingChunk
+from haystack.dataclasses import ChatMessage, ChatRole, ImageContent, StreamingChunk
 from haystack.tools import Tool
 
 from haystack_integrations.components.generators.amazon_bedrock import AmazonBedrockChatGenerator
@@ -24,6 +24,10 @@ MODELS_TO_TEST_WITH_TOOLS = [
 # so far we've discovered these models support streaming and tool use
 STREAMING_TOOL_MODELS = ["anthropic.claude-3-5-sonnet-20240620-v1:0", "cohere.command-r-plus-v1:0"]
 
+MODELS_TO_TEST_WITH_IMAGE_INPUT = [
+    "us.anthropic.claude-sonnet-4-20250514-v1:0",
+]
+
 
 def weather(city: str):
     """Get weather for a given city."""
@@ -288,6 +292,23 @@ class TestAmazonBedrockChatGeneratorInference:
             assert "prompt_tokens" in first_reply.meta["usage"]
             assert "completion_tokens" in first_reply.meta["usage"]
 
+    @pytest.mark.parametrize("model_name", MODELS_TO_TEST_WITH_IMAGE_INPUT)
+    def test_run_with_image_input(self, model_name, test_files_path):
+        client = AmazonBedrockChatGenerator(model=model_name)
+
+        image_path = test_files_path / "apple.jpg"
+        image_content = ImageContent.from_file_path(image_path, size=(100, 100))
+
+        chat_message = ChatMessage.from_user(content_parts=["What's in the image? Max 5 words.", image_content])
+
+        response = client.run([chat_message])
+
+        first_reply = response["replies"][0]
+        assert isinstance(first_reply, ChatMessage)
+        assert ChatMessage.is_from(first_reply, ChatRole.ASSISTANT)
+        assert first_reply.text
+        assert "apple" in first_reply.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
@@ -298,6 +319,7 @@ class TestAmazonBedrockChatGeneratorInference:
             streaming_callback_called = True
             assert isinstance(chunk, StreamingChunk)
             assert chunk.content is not None
+            assert chunk.component_info is not None
             if not paris_found_in_response:
                 paris_found_in_response = "paris" in chunk.content.lower()
 

{amazon_bedrock_haystack-3.7.0 → amazon_bedrock_haystack-3.9.0}/tests/test_chat_generator_utils.py

@@ -1,9 +1,12 @@
+import base64
+
 import pytest
-from haystack.dataclasses import ChatMessage, ChatRole, StreamingChunk, ToolCall
+from haystack.dataclasses import ChatMessage, ChatRole, ComponentInfo, ImageContent, StreamingChunk, ToolCall
 from haystack.tools import Tool
 
 from haystack_integrations.components.generators.amazon_bedrock.chat.utils import (
     _format_messages,
+    _format_text_image_message,
     _format_tools,
     _parse_completion_response,
     _parse_streaming_response,
@@ -105,6 +108,48 @@ class TestAmazonBedrockChatGeneratorUtils:
             {"role": "assistant", "content": [{"text": "The weather in Paris is sunny and 25°C."}]},
         ]
 
+    def test_format_text_image_message(self):
+        plain_assistant_message = ChatMessage.from_assistant("This is a test message.")
+        formatted_message = _format_text_image_message(plain_assistant_message)
+        assert formatted_message == {
+            "role": "assistant",
+            "content": [{"text": "This is a test message."}],
+        }
+
+        plain_user_message = ChatMessage.from_user("This is a test message.")
+        formatted_message = _format_text_image_message(plain_user_message)
+        assert formatted_message == {
+            "role": "user",
+            "content": [{"text": "This is a test message."}],
+        }
+
+        base64_image = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII="
+        image_content = ImageContent(base64_image)
+        image_message = ChatMessage.from_user(content_parts=["This is a test message.", image_content])
+        formatted_message = _format_text_image_message(image_message)
+        assert formatted_message == {
+            "role": "user",
+            "content": [
+                {"text": "This is a test message."},
+                {"image": {"format": "png", "source": {"bytes": base64.b64decode(base64_image)}}},
+            ],
+        }
+
+    def test_format_text_image_message_errors(self):
+        base64_image = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII="
+        image_content = ImageContent(base64_image)
+        assistant_message_with_image = ChatMessage.from_user(content_parts=["This is a test message.", image_content])
+        assistant_message_with_image._role = ChatRole.ASSISTANT
+        with pytest.raises(ValueError):
+            _format_text_image_message(assistant_message_with_image)
+
+        image_content_unsupported_format = ImageContent(base64_image, mime_type="image/tiff")
+        image_message = ChatMessage.from_user(
+            content_parts=["This is a test message.", image_content_unsupported_format]
+        )
+        with pytest.raises(ValueError):
+            _format_text_image_message(image_message)
+
     def test_formate_messages_multi_tool(self):
         messages = [
             ChatMessage.from_user("What is the weather in Berlin and Paris?"),
@@ -339,6 +384,9 @@ class TestAmazonBedrockChatGeneratorUtils:
         Test that process_streaming_response correctly handles streaming events and accumulates responses
         """
         model = "anthropic.claude-3-5-sonnet-20240620-v1:0"
+        type_ = (
+            "haystack_integrations.components.generators.amazon_bedrock.chat.chat_generator.AmazonBedrockChatGenerator"
+        )
         streaming_chunks = []
 
         def test_callback(chunk: StreamingChunk):
@@ -379,7 +427,11 @@ class TestAmazonBedrockChatGeneratorUtils:
             },
         ]
 
-        replies = _parse_streaming_response(events, test_callback, model)
+        component_info = ComponentInfo(
+            type=type_,
+        )
+
+        replies = _parse_streaming_response(events, test_callback, model, component_info)
         # Pop completion_start_time since it will always change
         replies[0].meta.pop("completion_start_time")
         expected_messages = [
@@ -413,6 +465,9 @@ class TestAmazonBedrockChatGeneratorUtils:
                 "type": "function",
             }
         ]
+        for chunk in streaming_chunks:
+            assert chunk.component_info.type == type_
+            assert chunk.component_info.name is None  # not in a pipeline
 
         # Verify final replies
         assert len(replies) == 1
@@ -420,6 +475,9 @@ class TestAmazonBedrockChatGeneratorUtils:
 
     def test_parse_streaming_response_with_two_tool_calls(self, mock_boto3_session):
         model = "anthropic.claude-3-5-sonnet-20240620-v1:0"
+        type_ = (
+            "haystack_integrations.components.generators.amazon_bedrock.chat.chat_generator.AmazonBedrockChatGenerator"
+        )
         streaming_chunks = []
 
         def test_callback(chunk: StreamingChunk):
@@ -468,7 +526,11 @@ class TestAmazonBedrockChatGeneratorUtils:
             },
         ]
 
-        replies = _parse_streaming_response(events, test_callback, model)
+        component_info = ComponentInfo(
+            type=type_,
+        )
+
+        replies = _parse_streaming_response(events, test_callback, model, component_info)
         # Pop completion_start_time since it will always change
         replies[0].meta.pop("completion_start_time")
         expected_messages = [