amazon-bedrock-haystack 3.6.2__tar.gz → 3.8.0__tar.gz

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [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
+
+- Extend error message for unknown model family in AmazonBedrockGenerator (#1733)
+
+
 ## [integrations/amazon_bedrock-v3.6.1] - 2025-05-13
 
 ### 🚜 Refactor

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 3.6.2
+Version: 3.8.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.15.1
 Description-Content-Type: text/markdown
 
 # amazon-bedrock-haystack
@@ -52,13 +52,18 @@ pip install hatch
 
 With `hatch` installed, to run all the tests:
 ```
-hatch run test
+hatch run test:all
 ```
-> Note: there are no integration tests for this project.
 
-To run the linters `ruff` and `mypy`:
+To format your code and perform linting using Ruff (with automatic fixes), run:
 ```
-hatch run lint:all
+hatch run fmt
+```
+
+To check for static type errors, run:
+
+```console
+$ hatch run test:types
 ```
 
 ## License

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/README.md

@@ -26,13 +26,18 @@ pip install hatch
 
 With `hatch` installed, to run all the tests:
 ```
-hatch run test
+hatch run test:all
 ```
-> Note: there are no integration tests for this project.
 
-To run the linters `ruff` and `mypy`:
+To format your code and perform linting using Ruff (with automatic fixes), run:
 ```
-hatch run lint:all
+hatch run fmt
+```
+
+To check for static type errors, run:
+
+```console
+$ hatch run test:types
 ```
 
 ## License

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/examples/bedrock_ranker_example.py

@@ -3,14 +3,14 @@ import os
 from haystack import Document
 from haystack.utils import Secret
 
-from haystack_integrations.components.rankers.amazon_bedrock import BedrockRanker
+from haystack_integrations.components.rankers.amazon_bedrock import AmazonBedrockRanker
 
 # Set up AWS credentials
 # You can also set these as environment variables
 aws_profile_name = os.environ.get("AWS_PROFILE") or "default"
 aws_region_name = os.environ.get("AWS_DEFAULT_REGION") or "eu-central-1"
-# Initialize the BedrockRanker with AWS credentials
-ranker = BedrockRanker(
+# Initialize the AmazonBedrockRanker with AWS credentials
+ranker = AmazonBedrockRanker(
     model="cohere.rerank-v3-5:0",
     top_k=2,
     aws_profile_name=Secret.from_token(aws_profile_name),

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.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.15.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"
@@ -43,38 +43,48 @@ git_describe_command = 'git describe --tags --match="integrations/amazon_bedrock
 
 [tool.hatch.envs.default]
 installer = "uv"
-dependencies = [
-  "coverage[toml]>=6.5",
-  "haystack-pydoc-tools",
-  "pytest",
-  "pytest-asyncio",
-  "pytest-rerunfailures",
-]
+dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-test = "pytest {args:tests}"
-test-cov = "coverage run -m pytest {args:tests}"
-test-cov-retry = "test-cov --reruns 3 --reruns-delay 30 -x"
-cov-report = ["- coverage combine", "coverage report"]
-cov = ["test-cov", "cov-report"]
-cov-retry = ["test-cov-retry", "cov-report"]
 docs = ["pydoc-markdown pydoc/config.yml"]
+fmt = "ruff check --fix {args} && ruff format {args}"
+fmt-check = "ruff check {args} && ruff format --check {args}"
 
-[tool.hatch.envs.lint]
-installer = "uv"
-detached = true
-dependencies = ["pip", "black>=23.1.0", "mypy>=1.0.0", "ruff>=0.0.243"]
+[tool.hatch.envs.test]
+dependencies = [
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-rerunfailures",
+    "mypy",
+    "pip",
+]
 
-[tool.hatch.envs.lint.scripts]
-typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
-style = ["ruff check {args:.}", "black --check --diff {args:.}"]
-fmt = ["black {args:.}", "ruff check --fix {args:.}", "style"]
-all = ["style", "typing"]
+[tool.hatch.envs.test.scripts]
+unit = 'pytest -m "not integration" {args:tests}'
+integration = 'pytest -m "integration" {args:tests}'
+all = 'pytest {args:tests}'
+cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
 
-[tool.black]
-target-version = ["py38"]
-line-length = 120
-skip-string-normalization = true
+types = """mypy -p haystack_integrations.common.amazon_bedrock \
+-p haystack_integrations.components.embedders.amazon_bedrock \
+-p haystack_integrations.components.generators.amazon_bedrock \
+-p haystack_integrations.components.rankers.amazon_bedrock {args}"""
+
+[tool.mypy]
+install_types = true
+non_interactive = true
+check_untyped_defs = true
+disallow_incomplete_defs = true
+
+[[tool.mypy.overrides]]
+# unfortunately, unofficial type stubs do not play well with some features of Bedrock
+module = [
+"aioboto3.*",
+"botocore.*",
+"boto3.*",
+]
+ignore_missing_imports = true
 
 [tool.ruff]
 target-version = "py38"
@@ -150,24 +160,9 @@ omit = ["*/tests/*", "*/__init__.py"]
 show_missing = true
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
-[[tool.mypy.overrides]]
-module = [
-  "aioboto3.*",
-  "botocore.*",
-  "boto3.*",
-  "haystack.*",
-  "haystack_integrations.*",
-  "pytest.*",
-  "numpy.*",
-]
-ignore_missing_imports = true
-
 [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.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/common/amazon_bedrock/utils.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import aioboto3
 import boto3
@@ -22,7 +22,7 @@ def get_aws_session(
     aws_region_name: Optional[str] = None,
     aws_profile_name: Optional[str] = None,
     async_mode: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> Union[boto3.Session, aioboto3.Session]:
     """
     Creates an AWS Session with the given parameters.
@@ -62,7 +62,7 @@ def get_aws_session(
         raise AWSConfigurationError(msg) from e
 
 
-def aws_configured(**kwargs) -> bool:
+def aws_configured(**kwargs: Any) -> bool:
     """
     Checks whether AWS configuration is provided.
     :param kwargs: The kwargs passed down to the generator.

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/components/embedders/amazon_bedrock/document_embedder.py

@@ -74,7 +74,7 @@ class AmazonBedrockDocumentEmbedder:
         meta_fields_to_embed: Optional[List[str]] = None,
         embedding_separator: str = "\n",
         boto3_config: Optional[Dict[str, Any]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         """
         Initializes the AmazonBedrockDocumentEmbedder with the provided parameters. The parameters are passed to the
@@ -186,11 +186,7 @@ class AmazonBedrockDocumentEmbedder:
                     body=json.dumps(body), modelId=self.model, accept="*/*", contentType="application/json"
                 )
             except ClientError as exception:
-                msg = (
-                    f"Could not connect to Amazon Bedrock model {self.model}. "
-                    f"Make sure your AWS environment is configured correctly, "
-                    f"the model is available in the configured AWS region, and you have access."
-                )
+                msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
                 raise AmazonBedrockInferenceError(msg) from exception
 
             response_body = json.loads(response.get("body").read())
@@ -217,11 +213,7 @@ class AmazonBedrockDocumentEmbedder:
                     body=json.dumps(body), modelId=self.model, accept="*/*", contentType="application/json"
                 )
             except ClientError as exception:
-                msg = (
-                    f"Could not connect to Amazon Bedrock model {self.model}. "
-                    f"Make sure your AWS environment is configured correctly, "
-                    f"the model is available in the configured AWS region, and you have access."
-                )
+                msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
                 raise AmazonBedrockInferenceError(msg) from exception
 
             response_body = json.loads(response.get("body").read())

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/components/embedders/amazon_bedrock/text_embedder.py

@@ -63,7 +63,7 @@ class AmazonBedrockTextEmbedder:
         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
         boto3_config: Optional[Dict[str, Any]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         """
         Initializes the AmazonBedrockTextEmbedder with the provided parameters. The parameters are passed to the
@@ -160,11 +160,7 @@ class AmazonBedrockTextEmbedder:
                 body=json.dumps(body), modelId=self.model, accept="*/*", contentType="application/json"
             )
         except ClientError as exception:
-            msg = (
-                f"Could not connect to Amazon Bedrock model {self.model}. "
-                f"Make sure your AWS environment is configured correctly, "
-                f"the model is available in the configured AWS region, and you have access."
-            )
+            msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
             raise AmazonBedrockInferenceError(msg) from exception
 
         response_body = json.loads(response.get("body").read())

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/components/generators/amazon_bedrock/adapters.py

@@ -1,8 +1,9 @@
 import json
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
-from haystack.dataclasses import StreamingChunk
+from botocore.eventstream import EventStream
+from haystack.dataclasses import StreamingChunk, SyncStreamingCallbackT
 
 
 class BedrockModelAdapter(ABC):
@@ -23,7 +24,7 @@ class BedrockModelAdapter(ABC):
         self.max_length = max_length
 
     @abstractmethod
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """
         Prepares the body for the Amazon Bedrock request.
         Each subclass should implement this method to prepare the request body for the specific model.
@@ -44,7 +45,7 @@ class BedrockModelAdapter(ABC):
         responses = [completion.lstrip() for completion in completions]
         return responses
 
-    def get_stream_responses(self, stream, streaming_callback: Callable[[StreamingChunk], None]) -> List[str]:
+    def get_stream_responses(self, stream: EventStream, streaming_callback: SyncStreamingCallbackT) -> List[str]:
         """
         Extracts the responses from the Amazon Bedrock streaming response.
 
@@ -122,7 +123,7 @@ class AnthropicClaudeAdapter(BedrockModelAdapter):
         self.thinking_tag_end = f"</{self.thinking_tag}>\n\n" if self.thinking_tag else "\n\n"
         super().__init__(model_kwargs, max_length)
 
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """
         Prepares the body for the Claude model
 
@@ -210,7 +211,7 @@ class MistralAdapter(BedrockModelAdapter):
     Adapter for the Mistral models.
     """
 
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """
         Prepares the body for the Mistral model
 
@@ -260,7 +261,7 @@ class CohereCommandAdapter(BedrockModelAdapter):
     Adapter for the Cohere Command model.
     """
 
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """
         Prepares the body for the Command model
 
@@ -372,7 +373,7 @@ class AI21LabsJurassic2Adapter(BedrockModelAdapter):
     Model adapter for AI21 Labs' Jurassic 2 models.
     """
 
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """Prepares the body for the Jurassic 2 model.
 
         :param prompt: The prompt to be sent to the model.
@@ -410,7 +411,7 @@ class AmazonTitanAdapter(BedrockModelAdapter):
     Adapter for Amazon's Titan models.
     """
 
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """
         Prepares the body for the Titan model
 
@@ -456,7 +457,7 @@ class MetaLlamaAdapter(BedrockModelAdapter):
     Adapter for Meta's Llama2 models.
     """
 
-    def prepare_body(self, prompt: str, **inference_kwargs) -> Dict[str, Any]:
+    def prepare_body(self, prompt: str, **inference_kwargs: Any) -> Dict[str, Any]:
         """
         Prepares the body for the Llama2 model
 

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.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,
@@ -197,12 +197,6 @@ class AmazonBedrockChatGenerator:
         def resolve_secret(secret: Optional[Secret]) -> Optional[str]:
             return secret.resolve_value() if secret else None
 
-        aws_access_key_id = resolve_secret(aws_access_key_id)
-        aws_secret_access_key = resolve_secret(aws_secret_access_key)
-        aws_session_token = resolve_secret(aws_session_token)
-        aws_region_name = resolve_secret(aws_region_name)
-        aws_profile_name = resolve_secret(aws_profile_name)
-
         config: Optional[Config] = None
         if self.boto3_config:
             config = Config(**self.boto3_config)
@@ -210,11 +204,11 @@ class AmazonBedrockChatGenerator:
         try:
             # sync session
             session = get_aws_session(
-                aws_access_key_id=aws_access_key_id,
-                aws_secret_access_key=aws_secret_access_key,
-                aws_session_token=aws_session_token,
-                aws_region_name=aws_region_name,
-                aws_profile_name=aws_profile_name,
+                aws_access_key_id=resolve_secret(aws_access_key_id),
+                aws_secret_access_key=resolve_secret(aws_secret_access_key),
+                aws_session_token=resolve_secret(aws_session_token),
+                aws_region_name=resolve_secret(aws_region_name),
+                aws_profile_name=resolve_secret(aws_profile_name),
             )
             self.client = session.client("bedrock-runtime", config=config)
 
@@ -227,7 +221,7 @@ class AmazonBedrockChatGenerator:
 
         self.generation_kwargs = generation_kwargs or {}
         self.stop_words = stop_words or []
-        self.async_session = None
+        self.async_session: Optional[aioboto3.Session] = None
 
     def _get_async_session(self) -> aioboto3.Session:
         """
@@ -377,7 +371,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,
@@ -412,6 +408,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,
@@ -427,12 +425,18 @@ class AmazonBedrockChatGenerator:
                 if not response_stream:
                     msg = "No stream found in the response."
                     raise AmazonBedrockInferenceError(msg)
-                replies = _parse_streaming_response(response_stream, callback, self.model)
+                # the type of streaming callback is checked in _prepare_request_params, but mypy doesn't know
+                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)
         except ClientError as exception:
-            msg = f"Could not generate inference for Amazon Bedrock model {self.model} due: {exception}"
+            msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
             raise AmazonBedrockInferenceError(msg) from exception
 
         return {"replies": replies}
@@ -464,6 +468,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,
@@ -483,13 +489,19 @@ class AmazonBedrockChatGenerator:
                     if not response_stream:
                         msg = "No stream found in the response."
                         raise AmazonBedrockInferenceError(msg)
-                    replies = await _parse_streaming_response_async(response_stream, callback, self.model)
+                    # the type of streaming callback is checked in _prepare_request_params, but mypy doesn't know
+                    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)
 
         except ClientError as exception:
-            msg = f"Could not generate inference for Amazon Bedrock model {self.model} due: {exception}"
+            msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
             raise AmazonBedrockInferenceError(msg) from exception
 
         return {"replies": replies}

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/components/generators/amazon_bedrock/chat/utils.py

@@ -8,6 +8,7 @@ from haystack.dataclasses import (
     AsyncStreamingCallbackT,
     ChatMessage,
     ChatRole,
+    ComponentInfo,
     StreamingChunk,
     SyncStreamingCallbackT,
     ToolCall,
@@ -46,7 +47,7 @@ def _format_tool_call_message(tool_call_message: ChatMessage) -> Dict[str, Any]:
     :returns:
         Dictionary representing the tool call message in Bedrock's expected format
     """
-    content = []
+    content: List[Dict[str, Any]] = []
     # Tool call message can contain text
     if tool_call_message.text:
         content.append({"text": tool_call_message.text})
@@ -235,7 +236,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 +247,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 +362,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 +444,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 +452,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 +468,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 +476,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.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/components/generators/amazon_bedrock/generator.py

@@ -107,7 +107,7 @@ class AmazonBedrockGenerator:
         streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
         boto3_config: Optional[Dict[str, Any]] = None,
         model_family: Optional[MODEL_FAMILIES] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         """
         Create a new `AmazonBedrockGenerator` instance.
@@ -234,11 +234,7 @@ class AmazonBedrockGenerator:
             metadata = response.get("ResponseMetadata", {})
 
         except ClientError as exception:
-            msg = (
-                f"Could not connect to Amazon Bedrock model {self.model}. "
-                f"Make sure your AWS environment is configured correctly, "
-                f"the model is available in the configured AWS region, and you have access."
-            )
+            msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
             raise AmazonBedrockInferenceError(msg) from exception
 
         return {"replies": replies, "meta": metadata}

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/src/haystack_integrations/components/rankers/amazon_bedrock/ranker.py

@@ -256,15 +256,15 @@ class AmazonBedrockRanker:
                 sorted_docs.append(doc)
 
             return {"documents": sorted_docs}
-        except ClientError as exception:
-            msg = f"Could not inference Amazon Bedrock model {self.model_name} due to: {exception}"
+        except ClientError as client_error:
+            msg = f"Could not perform inference for Amazon Bedrock model {self.model_name} due to:\n{client_error}"
+            raise AmazonBedrockInferenceError(msg) from client_error
+        except KeyError as key_error:
+            msg = f"Unexpected response format from Amazon Bedrock: {key_error}"
+            raise AmazonBedrockInferenceError(msg) from key_error
+        except Exception as exception:
+            msg = f"Error during Amazon Bedrock API call: {exception}"
             raise AmazonBedrockInferenceError(msg) from exception
-        except KeyError as e:
-            msg = f"Unexpected response format from Amazon Bedrock: {e!s}"
-            raise AmazonBedrockInferenceError(msg) from e
-        except Exception as e:
-            msg = f"Error during Amazon Bedrock API call: {e!s}"
-            raise AmazonBedrockInferenceError(msg) from e
 
 
 class BedrockRanker(AmazonBedrockRanker):

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/tests/test_chat_generator.py

@@ -1,4 +1,3 @@
-import os
 from typing import Any, Dict, Optional
 
 import pytest
@@ -265,14 +264,8 @@ class TestAmazonBedrockChatGenerator:
         assert request_params["toolConfig"] == top_song_tool_config
 
 
+# In the CI, those tests are skipped if AWS Authentication fails
 @pytest.mark.integration
-@pytest.mark.skipif(
-    not os.environ.get("AWS_CI_ROLE_ARN", None) and not os.environ.get("AWS_REGION", None),
-    reason=(
-        "Skipping test because AWS_CI_ROLE_ARN and AWS_REGION environment variables are not set. "
-        "This test requires AWS credentials to run."
-    ),
-)
 class TestAmazonBedrockChatGeneratorInference:
     @pytest.mark.parametrize("model_name", MODELS_TO_TEST)
     def test_default_inference_params(self, model_name, chat_messages):
@@ -305,6 +298,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()
 
@@ -437,14 +431,8 @@ class TestAmazonBedrockChatGeneratorInference:
         )
 
 
+# In the CI, those tests are skipped if AWS Authentication fails
 @pytest.mark.integration
-@pytest.mark.skipif(
-    not os.environ.get("AWS_CI_ROLE_ARN", None) and not os.environ.get("AWS_REGION", None),
-    reason=(
-        "Skipping test because AWS_CI_ROLE_ARN and AWS_REGION environment variables are not set. "
-        "This test requires AWS credentials to run."
-    ),
-)
 class TestAmazonBedrockChatGeneratorAsyncInference:
     """
     Test class for async inference functionality of AmazonBedrockChatGenerator

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/tests/test_chat_generator_utils.py

@@ -1,5 +1,5 @@
 import pytest
-from haystack.dataclasses import ChatMessage, ChatRole, StreamingChunk, ToolCall
+from haystack.dataclasses import ChatMessage, ChatRole, ComponentInfo, StreamingChunk, ToolCall
 from haystack.tools import Tool
 
 from haystack_integrations.components.generators.amazon_bedrock.chat.utils import (
@@ -339,6 +339,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 +382,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 +420,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 +430,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 +481,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 = [

{amazon_bedrock_haystack-3.6.2 → amazon_bedrock_haystack-3.8.0}/tests/test_ranker.py

@@ -1,4 +1,3 @@
-import os
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -52,14 +51,8 @@ def test_bedrock_ranker_run(mock_aws_session):
     assert result["documents"][1].score == 0.7
 
 
+# In the CI, those tests are skipped if AWS Authentication fails
 @pytest.mark.integration
-@pytest.mark.skipif(
-    not os.environ.get("AWS_CI_ROLE_ARN", None) and not os.environ.get("AWS_REGION", None),
-    reason=(
-        "Skipping test because AWS_CI_ROLE_ARN and AWS_REGION environment variables are not set. "
-        "This test requires AWS credentials to run."
-    ),
-)
 def test_amazon_bedrock_ranker_live_run():
     ranker = AmazonBedrockRanker(
         model="cohere.rerank-v3-5:0",