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

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

@@ -1,11 +1,29 @@
 # Changelog
 
+## [integrations/amazon_bedrock-v4.0.0] - 2025-08-29
+
+### 🚀 Features
+
+- [**breaking**] Update AmazonBedrockChatGenerator to use the new fields in `StreamingChunk` (#2216)
+- [**breaking**] Use `ReasoningContent` to store reasoning content in `ChatMessage` instead of `ChatMessage.meta` (#2226)
+
+
+### 🧹 Chores
+
+- Standardize readmes - part 2 (#2205)
+
 ## [integrations/amazon_bedrock-v3.11.0] - 2025-08-21
 
 ### 🚀 Features
 
 - Add `AmazonBedrockDocumentImageEmbedder` component (#2185)
 
+### 🧹 Chores
+
+- Add framework name into UserAgent header for bedrock integration (#2168)
+- Standardize readmes - part 1 (#2202)
+
+
 ## [integrations/amazon_bedrock-v3.10.0] - 2025-08-06
 
 ### 🚀 Features

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 4.0.0
+Version: 4.1.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

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.1.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/chat_generator.py

@@ -27,6 +27,7 @@ from haystack_integrations.components.generators.amazon_bedrock.chat.utils impor
     _parse_completion_response,
     _parse_streaming_response,
     _parse_streaming_response_async,
+    _validate_guardrail_config,
 )
 
 logger = logging.getLogger(__name__)
@@ -154,10 +155,11 @@ class AmazonBedrockChatGenerator:
         aws_region_name: Optional[Secret] = Secret.from_env_var(["AWS_DEFAULT_REGION"], strict=False),  # noqa: B008
         aws_profile_name: Optional[Secret] = Secret.from_env_var(["AWS_PROFILE"], strict=False),  # noqa: B008
         generation_kwargs: Optional[Dict[str, Any]] = None,
-        stop_words: Optional[List[str]] = None,
         streaming_callback: Optional[StreamingCallbackT] = None,
         boto3_config: Optional[Dict[str, Any]] = None,
         tools: Optional[Union[List[Tool], Toolset]] = None,
+        *,
+        guardrail_config: Optional[Dict[str, str]] = None,
     ) -> None:
         """
         Initializes the `AmazonBedrockChatGenerator` with the provided parameters. The parameters are passed to the
@@ -179,10 +181,6 @@ class AmazonBedrockChatGenerator:
         :param generation_kwargs: Keyword arguments sent to the model. These parameters are specific to a model.
             You can find the model specific arguments in the AWS Bedrock API
             [documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html).
-        :param stop_words: A list of stop words that stop the model from generating more text
-            when encountered. You can provide them using this parameter or using the model's `generation_kwargs`
-            under a model's specific key for stop words.
-            For example, you can provide stop words for Anthropic Claude in the `stop_sequences` key.
         :param streaming_callback: A callback function called when a new token is received from the stream.
             By default, the model is not set up for streaming. To enable streaming, set this parameter to a callback
             function that handles the streaming chunks. The callback function receives a
@@ -190,6 +188,19 @@ class AmazonBedrockChatGenerator:
             the streaming mode on.
         :param boto3_config: The configuration for the boto3 client.
         :param tools: A list of Tool objects or a Toolset that the model can use. Each tool should have a unique name.
+        :param guardrail_config: Optional configuration for a guardrail that has been created in Amazon Bedrock.
+            This must be provided as a dictionary matching either
+            [GuardrailConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GuardrailConfiguration.html).
+            or, in streaming mode (when `streaming_callback` is set),
+            [GuardrailStreamConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailStreamConfiguration.html).
+            If `trace` is set to `enabled`, the guardrail trace will be included under the `trace` key in the `meta`
+            attribute of the resulting `ChatMessage`.
+            Note: Enabling guardrails in streaming mode may introduce additional latency.
+            To manage this, you can adjust the `streamProcessingMode` parameter.
+            See the
+            [Guardrails Streaming documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails-streaming.html)
+            for more information.
+
 
         :raises ValueError: If the model name is empty or None.
         :raises AmazonBedrockConfigurationError: If the AWS environment is not configured correctly or the model is
@@ -204,12 +215,15 @@ class AmazonBedrockChatGenerator:
         self.aws_session_token = aws_session_token
         self.aws_region_name = aws_region_name
         self.aws_profile_name = aws_profile_name
-        self.stop_words = stop_words or []
         self.streaming_callback = streaming_callback
         self.boto3_config = boto3_config
+
         _check_duplicate_tool_names(list(tools or []))  # handles Toolset as well
         self.tools = tools
 
+        _validate_guardrail_config(guardrail_config=guardrail_config, streaming=streaming_callback is not None)
+        self.guardrail_config = guardrail_config
+
         def resolve_secret(secret: Optional[Secret]) -> Optional[str]:
             return secret.resolve_value() if secret else None
 
@@ -237,7 +251,6 @@ class AmazonBedrockChatGenerator:
             raise AmazonBedrockConfigurationError(msg) from exception
 
         self.generation_kwargs = generation_kwargs or {}
-        self.stop_words = stop_words or []
         self.async_session: Optional[aioboto3.Session] = None
 
     def _get_async_session(self) -> aioboto3.Session:
@@ -291,11 +304,11 @@ class AmazonBedrockChatGenerator:
             aws_region_name=self.aws_region_name.to_dict() if self.aws_region_name else None,
             aws_profile_name=self.aws_profile_name.to_dict() if self.aws_profile_name else None,
             model=self.model,
-            stop_words=self.stop_words,
             generation_kwargs=self.generation_kwargs,
             streaming_callback=callback_name,
             boto3_config=self.boto3_config,
             tools=serialize_tools_or_toolset(self.tools),
+            guardrail_config=self.guardrail_config,
         )
 
     @classmethod
@@ -308,6 +321,12 @@ class AmazonBedrockChatGenerator:
             Instance of `AmazonBedrockChatGenerator`.
         """
         init_params = data.get("init_parameters", {})
+
+        stop_words = init_params.pop("stop_words", None)
+        msg = "stop_words parameter will be ignored. Use the `stopSequences` key in `generation_kwargs` instead."
+        if stop_words:
+            logger.warning(msg)
+
         serialized_callback_handler = init_params.get("streaming_callback")
         if serialized_callback_handler:
             data["init_parameters"]["streaming_callback"] = deserialize_callable(serialized_callback_handler)
@@ -387,6 +406,8 @@ class AmazonBedrockChatGenerator:
             params["toolConfig"] = tool_config
         if additional_fields:
             params["additionalModelRequestFields"] = additional_fields
+        if self.guardrail_config:
+            params["guardrailConfig"] = self.guardrail_config
 
         # overloads that exhaust finite Literals(bool) not treated as exhaustive
         # see https://github.com/python/mypy/issues/14764

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

@@ -273,6 +273,7 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
     :param model: The model ID used for generation, included in message metadata.
     :returns: List of ChatMessage objects containing the assistant's response(s) with appropriate metadata.
     """
+
     replies = []
     if "output" in response_body and "message" in response_body["output"]:
         message = response_body["output"]["message"]
@@ -280,7 +281,7 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
             content_blocks = message["content"]
 
             # Common meta information
-            base_meta = {
+            meta = {
                 "model": model,
                 "index": 0,
                 "finish_reason": FINISH_REASON_MAPPING.get(response_body.get("stopReason", "")),
@@ -291,6 +292,9 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
                     "total_tokens": response_body.get("usage", {}).get("totalTokens", 0),
                 },
             }
+            # guardrail trace
+            if "trace" in response_body:
+                meta["trace"] = response_body["trace"]
 
             # Process all content blocks and combine them into a single message
             text_content = []
@@ -329,7 +333,7 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
                 ChatMessage.from_assistant(
                     " ".join(text_content),
                     tool_calls=tool_calls,
-                    meta=base_meta,
+                    meta=meta,
                     reasoning=ReasoningContent(
                         reasoning_text=reasoning_text, extra={"reasoning_contents": reasoning_contents}
                     )
@@ -355,6 +359,7 @@ def _convert_event_to_streaming_chunk(
     :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
     # (e.g. for messageStart and contentBlockStop)
     base_meta = {"model": model, "received_at": datetime.now(timezone.utc).isoformat()}
@@ -426,19 +431,23 @@ def _convert_event_to_streaming_chunk(
             meta=base_meta,
         )
 
-    elif "metadata" in event and "usage" in event["metadata"]:
-        metadata = event["metadata"]
-        streaming_chunk = StreamingChunk(
-            content="",
-            meta={
-                **base_meta,
-                "usage": {
-                    "prompt_tokens": metadata["usage"].get("inputTokens", 0),
-                    "completion_tokens": metadata["usage"].get("outputTokens", 0),
-                    "total_tokens": metadata["usage"].get("totalTokens", 0),
-                },
-            },
-        )
+    elif "metadata" in event:
+        event_meta = event["metadata"]
+        chunk_meta: Dict[str, Any] = {**base_meta}
+
+        if "usage" in event_meta:
+            usage = event_meta["usage"]
+            chunk_meta["usage"] = {
+                "prompt_tokens": usage.get("inputTokens", 0),
+                "completion_tokens": usage.get("outputTokens", 0),
+                "total_tokens": usage.get("totalTokens", 0),
+            }
+        if "trace" in event_meta:
+            chunk_meta["trace"] = event_meta["trace"]
+
+        # Only create chunk if we added usage or trace data
+        if len(chunk_meta) > len(base_meta):
+            streaming_chunk = StreamingChunk(content="", meta=chunk_meta)
 
     streaming_chunk.component_info = component_info
 
@@ -547,8 +556,15 @@ def _parse_streaming_response(
             content_block_idxs.add(content_block_idx)
         streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
+
     reply = _convert_streaming_chunks_to_chat_message(chunks=chunks)
+
+    # both the reasoning content and the trace are ignored in _convert_streaming_chunks_to_chat_message
+    # so we need to process them separately
     reasoning_content = _process_reasoning_contents(chunks=chunks)
+    if chunks[-1].meta and "trace" in chunks[-1].meta:
+        reply.meta["trace"] = chunks[-1].meta["trace"]
+
     reply = ChatMessage.from_assistant(
         text=reply.text,
         meta=reply.meta,
@@ -556,6 +572,7 @@ def _parse_streaming_response(
         tool_calls=reply.tool_calls,
         reasoning=reasoning_content,
     )
+
     return [reply]
 
 
@@ -594,3 +611,24 @@ async def _parse_streaming_response_async(
         reasoning=reasoning_content,
     )
     return [reply]
+
+
+def _validate_guardrail_config(guardrail_config: Optional[Dict[str, str]] = None, streaming: bool = False) -> None:
+    """
+    Validate the guardrail configuration.
+
+    :param guardrail_config: The guardrail configuration.
+    :param streaming: Whether the streaming is enabled.
+
+    :raises ValueError: If the guardrail configuration is invalid.
+    """
+    if guardrail_config is None:
+        return
+
+    required_fields = {"guardrailIdentifier", "guardrailVersion"}
+    if not required_fields.issubset(guardrail_config):
+        msg = "`guardrailIdentifier` and `guardrailVersion` fields are required in guardrail configuration."
+        raise ValueError(msg)
+    if not streaming and "streamProcessingMode" in guardrail_config:
+        msg = "`streamProcessingMode` field is only supported for streaming (when `streaming_callback` is not None)."
+        raise ValueError(msg)

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

@@ -1,3 +1,4 @@
+import os
 from typing import Any, Dict, Optional
 
 import pytest
@@ -122,6 +123,7 @@ class TestAmazonBedrockChatGenerator:
             generation_kwargs={"temperature": 0.7},
             streaming_callback=print_streaming_chunk,
             boto3_config=boto3_config,
+            guardrail_config={"guardrailIdentifier": "test", "guardrailVersion": "test"},
         )
         expected_dict = {
             "type": CLASS_TYPE,
@@ -133,10 +135,10 @@ class TestAmazonBedrockChatGenerator:
                 "aws_profile_name": {"type": "env_var", "env_vars": ["AWS_PROFILE"], "strict": False},
                 "model": "cohere.command-r-plus-v1:0",
                 "generation_kwargs": {"temperature": 0.7},
-                "stop_words": [],
                 "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
                 "boto3_config": boto3_config,
                 "tools": None,
+                "guardrail_config": {"guardrailIdentifier": "test", "guardrailVersion": "test"},
             },
         }
 
@@ -165,6 +167,8 @@ class TestAmazonBedrockChatGenerator:
                     "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
                     "boto3_config": boto3_config,
                     "tools": None,
+                    "stop_words": ["stop"],  # this parameter will be ignored
+                    "guardrail_config": None,
                 },
             }
         )
@@ -224,8 +228,7 @@ class TestAmazonBedrockChatGenerator:
 
         generator = AmazonBedrockChatGenerator(
             model="anthropic.claude-3-5-sonnet-20240620-v1:0",
-            generation_kwargs={"temperature": 0.7},
-            stop_words=["eviscerate"],
+            generation_kwargs={"temperature": 0.7, "stopSequences": ["eviscerate"]},
             streaming_callback=print_streaming_chunk,
             tools=[tool],
         )
@@ -252,8 +255,7 @@ class TestAmazonBedrockChatGenerator:
                         "aws_region_name": {"type": "env_var", "env_vars": ["AWS_DEFAULT_REGION"], "strict": False},
                         "aws_profile_name": {"type": "env_var", "env_vars": ["AWS_PROFILE"], "strict": False},
                         "model": "anthropic.claude-3-5-sonnet-20240620-v1:0",
-                        "generation_kwargs": {"temperature": 0.7},
-                        "stop_words": ["eviscerate"],
+                        "generation_kwargs": {"temperature": 0.7, "stopSequences": ["eviscerate"]},
                         "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
                         "boto3_config": None,
                         "tools": [
@@ -270,6 +272,7 @@ class TestAmazonBedrockChatGenerator:
                                 },
                             }
                         ],
+                        "guardrail_config": None,
                     },
                 }
             },
@@ -283,7 +286,7 @@ class TestAmazonBedrockChatGenerator:
 
     def test_prepare_request_params_tool_config(self, top_song_tool_config, mock_boto3_session, set_env_variables):
         generator = AmazonBedrockChatGenerator(model="anthropic.claude-3-5-sonnet-20240620-v1:0")
-        request_params, callback = generator._prepare_request_params(
+        request_params, _ = generator._prepare_request_params(
             messages=[ChatMessage.from_user("What's the capital of France?")],
             generation_kwargs={"toolConfig": top_song_tool_config},
             tools=None,
@@ -291,6 +294,17 @@ class TestAmazonBedrockChatGenerator:
         assert request_params["messages"] == [{"content": [{"text": "What's the capital of France?"}], "role": "user"}]
         assert request_params["toolConfig"] == top_song_tool_config
 
+    def test_prepare_request_params_guardrail_config(self, mock_boto3_session, set_env_variables):
+        generator = AmazonBedrockChatGenerator(
+            model="anthropic.claude-3-5-sonnet-20240620-v1:0",
+            guardrail_config={"guardrailIdentifier": "test", "guardrailVersion": "test"},
+        )
+        request_params, _ = generator._prepare_request_params(
+            messages=[ChatMessage.from_user("What's the capital of France?")],
+        )
+        assert request_params["messages"] == [{"content": [{"text": "What's the capital of France?"}], "role": "user"}]
+        assert request_params["guardrailConfig"] == {"guardrailIdentifier": "test", "guardrailVersion": "test"}
+
 
 # In the CI, those tests are skipped if AWS Authentication fails
 @pytest.mark.integration
@@ -653,6 +667,32 @@ class TestAmazonBedrockChatGeneratorInference:
         assert len(final_message.text) > 0
         assert "hello" in final_message.text.lower()
 
+    @pytest.mark.skipif(
+        not os.getenv("AWS_BEDROCK_GUARDRAIL_ID") or not os.getenv("AWS_BEDROCK_GUARDRAIL_VERSION"),
+        reason=(
+            "Export AWS_BEDROCK_GUARDRAIL_ID and AWS_BEDROCK_GUARDRAIL_VERSION environment variables corresponding"
+            "to a Bedrock Guardrail to run this test."
+        ),
+    )
+    @pytest.mark.parametrize("streaming_callback", [None, print_streaming_chunk])
+    def test_live_run_with_guardrail(self, streaming_callback):
+        messages = [ChatMessage.from_user("Should I invest in Tesla or Apple?")]
+        component = AmazonBedrockChatGenerator(
+            model="anthropic.claude-3-5-sonnet-20240620-v1:0",
+            guardrail_config={
+                "guardrailIdentifier": os.getenv("AWS_BEDROCK_GUARDRAIL_ID"),
+                "guardrailVersion": os.getenv("AWS_BEDROCK_GUARDRAIL_VERSION"),
+                "trace": "enabled",
+            },
+            streaming_callback=streaming_callback,
+        )
+        results = component.run(messages=messages)
+
+        assert results["replies"][0].meta["finish_reason"] == "content_filter"
+        assert results["replies"][0].text == "Sorry, the model cannot answer this question."
+        assert "trace" in results["replies"][0].meta
+        assert "guardrail" in results["replies"][0].meta["trace"]
+
     @pytest.mark.parametrize("model_name", [MODELS_TO_TEST_WITH_TOOLS[0]])  # just one model is enough
     def test_pipeline_with_amazon_bedrock_chat_generator(self, model_name, tools):
         """

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.1.0}/tests/test_chat_generator_utils.py

@@ -21,6 +21,7 @@ from haystack_integrations.components.generators.amazon_bedrock.chat.utils impor
     _format_tools,
     _parse_completion_response,
     _parse_streaming_response,
+    _validate_guardrail_config,
 )
 
 
@@ -603,6 +604,71 @@ class TestAmazonBedrockChatGeneratorUtils:
         )
         assert replies[0] == expected_message
 
+    def test_extract_replies_with_guardrail(self, mock_boto3_session):
+        model = "anthropic.claude-3-5-sonnet-20240620-v1:0"
+
+        trace = {
+            "guardrail": {
+                "inputAssessment": {
+                    "test_guardrail_id": {
+                        "topicPolicy": {
+                            "topics": [
+                                {"name": "Investments topic", "type": "DENY", "action": "BLOCKED", "detected": True}
+                            ]
+                        },
+                        "invocationMetrics": {
+                            "guardrailProcessingLatency": 273,
+                            "usage": {
+                                "topicPolicyUnits": 1,
+                                "contentPolicyUnits": 0,
+                                "wordPolicyUnits": 0,
+                                "sensitiveInformationPolicyUnits": 0,
+                                "sensitiveInformationPolicyFreeUnits": 0,
+                                "contextualGroundingPolicyUnits": 0,
+                                "contentPolicyImageUnits": 0,
+                            },
+                            "guardrailCoverage": {"textCharacters": {"guarded": 48, "total": 48}},
+                        },
+                    }
+                },
+                "actionReason": "Guardrail blocked.",
+            }
+        }
+
+        response_body = {
+            "ResponseMetadata": {
+                "RequestId": "7f2b43ef-fb52-40e4-ab14-8cc1edaf5013",
+                "HTTPStatusCode": 200,
+                "HTTPHeaders": {
+                    "date": "Thu, 18 Sep 2025 09:14:48 GMT",
+                    "content-type": "application/json",
+                    "content-length": "835",
+                    "connection": "keep-alive",
+                    "x-amzn-requestid": "7f2b43ef-fb52-40e4-ab14-8cc1edaf5013",
+                },
+                "RetryAttempts": 0,
+            },
+            "output": {
+                "message": {"role": "assistant", "content": [{"text": "Sorry, the model cannot answer this question."}]}
+            },
+            "stopReason": "guardrail_intervened",
+            "usage": {"inputTokens": 0, "outputTokens": 0, "totalTokens": 0},
+            "metrics": {"latencyMs": 316},
+            "trace": trace,
+        }
+
+        replies = _parse_completion_response(response_body, model)
+        assert len(replies) == 1
+        assert replies[0].text == "Sorry, the model cannot answer this question."
+        assert replies[0].role == ChatRole.ASSISTANT
+        assert replies[0].meta == {
+            "model": model,
+            "finish_reason": "content_filter",
+            "index": 0,
+            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+            "trace": trace,
+        }
+
     def test_process_streaming_response_one_tool_call(self, mock_boto3_session):
         """
         Test that process_streaming_response correctly handles streaming events and accumulates responses
@@ -1034,6 +1100,82 @@ class TestAmazonBedrockChatGeneratorUtils:
         ]
         assert replies == expected_messages
 
+    def test_parse_streaming_response_with_guardrail(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 = []
+
+        trace = {
+            "guardrail": {
+                "inputAssessment": {
+                    "vodp82dpe5xv": {
+                        "test_guardrail_id": {
+                            "topicPolicy": {
+                                "topics": [
+                                    {"name": "Investments topic", "type": "DENY", "action": "BLOCKED", "detected": True}
+                                ]
+                            },
+                            "invocationMetrics": {
+                                "guardrailProcessingLatency": 299,
+                                "usage": {
+                                    "topicPolicyUnits": 1,
+                                    "contentPolicyUnits": 0,
+                                    "wordPolicyUnits": 0,
+                                    "sensitiveInformationPolicyUnits": 0,
+                                    "sensitiveInformationPolicyFreeUnits": 0,
+                                    "contextualGroundingPolicyUnits": 0,
+                                    "contentPolicyImageUnits": 0,
+                                },
+                                "guardrailCoverage": {"textCharacters": {"guarded": 48, "total": 48}},
+                            },
+                        }
+                    },
+                    "actionReason": "Guardrail blocked.",
+                }
+            }
+        }
+
+        events = [
+            {"messageStart": {"role": "assistant"}},
+            {
+                "contentBlockDelta": {
+                    "delta": {"text": "Sorry, the model cannot answer this question."},
+                    "contentBlockIndex": 0,
+                }
+            },
+            {"contentBlockStop": {"contentBlockIndex": 0}},
+            {"messageStop": {"stopReason": "guardrail_intervened"}},
+            {
+                "metadata": {
+                    "usage": {"inputTokens": 0, "outputTokens": 0, "totalTokens": 0},
+                    "metrics": {"latencyMs": 334},
+                    "trace": trace,
+                }
+            },
+        ]
+
+        def test_callback(chunk: StreamingChunk):
+            streaming_chunks.append(chunk)
+
+        replies = _parse_streaming_response(events, test_callback, model, ComponentInfo(type=type_))
+
+        expected_messages = [
+            ChatMessage.from_assistant(
+                text="Sorry, the model cannot answer this question.",
+                meta={
+                    "completion_start_time": ANY,
+                    "model": model,
+                    "index": 0,
+                    "finish_reason": "content_filter",
+                    "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+                    "trace": trace,
+                },
+            )
+        ]
+        assert replies == expected_messages
+
     def test_convert_streaming_chunks_to_chat_message_tool_call_with_empty_arguments(self):
         chunks = [
             StreamingChunk(
@@ -1229,3 +1371,35 @@ class TestAmazonBedrockChatGeneratorUtils:
         assert message._meta["index"] == 0
         assert message._meta["finish_reason"] == "tool_calls"
         assert message._meta["usage"] == {"completion_tokens": 84, "prompt_tokens": 349, "total_tokens": 433}
+
+    def test_validate_guardrail_config_with_valid_configs(self):
+        _validate_guardrail_config(guardrail_config=None, streaming=False)
+        _validate_guardrail_config(
+            guardrail_config={"guardrailIdentifier": "test", "guardrailVersion": "test"}, streaming=False
+        )
+        _validate_guardrail_config(
+            guardrail_config={"guardrailIdentifier": "test", "guardrailVersion": "test"}, streaming=True
+        )
+        _validate_guardrail_config(
+            guardrail_config={
+                "guardrailIdentifier": "test",
+                "guardrailVersion": "test",
+                "streamProcessingMode": "enabled",
+            },
+            streaming=True,
+        )
+
+    def test_validate_guardrail_config_with_invalid_configs(self):
+        with pytest.raises(ValueError, match="`guardrailIdentifier` and `guardrailVersion` fields are required"):
+            _validate_guardrail_config(guardrail_config={"guardrailIdentifier": "test"}, streaming=False)
+        with pytest.raises(ValueError, match="`guardrailIdentifier` and `guardrailVersion` fields are required"):
+            _validate_guardrail_config(guardrail_config={"guardrailVersion": "test"}, streaming=False)
+        with pytest.raises(ValueError, match="`streamProcessingMode` field is only supported for streaming"):
+            _validate_guardrail_config(
+                guardrail_config={
+                    "guardrailIdentifier": "test",
+                    "guardrailVersion": "test",
+                    "streamProcessingMode": "test",
+                },
+                streaming=False,
+            )

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.1.0}/tests/test_document_image_embedder.py

@@ -195,7 +195,7 @@ class TestAmazonBedrockDocumentImageEmbedder:
             # Process images directly
             for doc in docs:
                 image_byte_stream = ByteStream.from_file_path(filepath=doc.meta["file_path"], mime_type="image/jpeg")
-                mime_type, base64_image = _encode_image_to_base64(image_byte_stream)
+                _, base64_image = _encode_image_to_base64(image_byte_stream)
                 base64_images.append(base64_image)
 
             result = embedder._embed_titan(images=base64_images)