anthropic-haystack 6.2.0__tar.gz → 7.0.0__tar.gz

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [integrations/anthropic-v6.3.0] - 2026-10-01
+
+### 🚜 Refactor
+
+- Generalize flattened generation_kwargs for tool_choice/thinking/output_config (#4028)
+
+
+## [integrations/anthropic-v6.2.0] - 2026-09-24
+
+### 🚀 Features
+
+- Add thinking_display flattened generation_kwarg to Anthropic and Bedrock chat generators (#3993)
+
+
 ## [integrations/anthropic-v6.1.0] - 2026-09-22
 
 ### 🐛 Bug Fixes

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: anthropic-haystack
-Version: 6.2.0
+Version: 7.0.0
 Summary: An integration of Anthropic Claude models into the Haystack framework.
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/anthropic#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/src/haystack_integrations/components/generators/anthropic/chat/chat_generator.py

@@ -19,7 +19,7 @@ from haystack.tools import (
     flatten_tools_or_toolsets,
     serialize_tools_or_toolset,
 )
-from haystack.utils.auth import Secret, deserialize_secrets_inplace
+from haystack.utils.auth import Secret
 from haystack.utils.callable_serialization import deserialize_callable, serialize_callable
 
 from anthropic import Anthropic, AsyncAnthropic
@@ -37,6 +37,7 @@ from .utils import (
     _convert_messages_to_anthropic_format,
     _extract_citations,
     _has_server_tool_blocks,
+    _merge_streaming_usage,
     _process_reasoning_contents,
 )
 
@@ -278,7 +279,6 @@ class AnthropicChatGenerator:
         :returns:
             The deserialized component instance.
         """
-        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
         deserialize_tools_or_toolset_inplace(data["init_parameters"], key="tools")
         init_params = data.get("init_parameters", {})
         serialized_callback_handler = init_params.get("streaming_callback")
@@ -369,11 +369,6 @@ class AnthropicChatGenerator:
             tool_choice["disable_parallel_tool_use"] = disable_parallel_tool_use
             tool_choice.setdefault("type", "auto")  # default value
 
-        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
-
         thinking_budget_tokens = generation_kwargs.pop("thinking_budget_tokens", None)
         if thinking_budget_tokens is not None:
             thinking = generation_kwargs.setdefault("thinking", {})
@@ -390,12 +385,14 @@ class AnthropicChatGenerator:
                 output_config = generation_kwargs.setdefault("output_config", {})
                 output_config["effort"] = adaptive_thinking_effort
 
-        thinking_display = generation_kwargs.pop("thinking_display", None)
-        if thinking_display is not None:
-            thinking = generation_kwargs.setdefault("thinking", {})
-            # `display` is only accepted with enabled or adaptive thinking, so it's dropped when thinking is disabled
-            if thinking.get("type") != "disabled":
-                thinking["display"] = thinking_display
+        for nested_name in ("tool_choice", "thinking", "output_config"):
+            prefix = f"{nested_name}_"
+            for key in [k for k in generation_kwargs if k.startswith(prefix)]:
+                value = generation_kwargs.pop(key)
+                if value is not None:
+                    nested_key = key[len(prefix) :]
+                    nested_dict = generation_kwargs.setdefault(nested_name, {})
+                    nested_dict[nested_key] = value
 
         return generation_kwargs
 
@@ -418,15 +415,14 @@ class AnthropicChatGenerator:
             model: str | None = None
             tool_call_index = -1
             in_server_tool_block = False
-            input_tokens = None
+            start_usage: dict[str, Any] = {}
             component_info = ComponentInfo.from_component(self)
             for chunk in response:
                 if chunk.type in ["message_start", "content_block_start", "content_block_delta", "message_delta"]:
-                    # Extract model from message_start chunks
+                    # Extract model and full usage from message_start chunks
                     if chunk.type == "message_start":
                         model = chunk.message.model
-                        if chunk.message.usage.input_tokens is not None:
-                            input_tokens = chunk.message.usage.input_tokens
+                        start_usage = chunk.message.usage.model_dump()
 
                     if chunk.type == "content_block_start":
                         if chunk.content_block.type == "tool_use":
@@ -448,10 +444,9 @@ class AnthropicChatGenerator:
                 {"received_at": datetime.now(timezone.utc).isoformat(), "model": model},
             )
 
-            if input_tokens is not None:
-                if "usage" not in completion.meta:
-                    completion.meta["usage"] = {}
-                completion.meta["usage"]["input_tokens"] = input_tokens
+            # `completion.meta["usage"]` is the usage of the last message_delta chunk
+            if usage := _merge_streaming_usage(start_usage=start_usage, delta_usage=completion.meta.get("usage")):
+                completion.meta["usage"] = usage
 
             # keep the raw content so server-tool blocks can be replayed on later turns
             if self.anthropic_server_tools:
@@ -498,7 +493,7 @@ class AnthropicChatGenerator:
             model: str | None = None
             tool_call_index = -1
             in_server_tool_block = False
-            input_tokens = None
+            start_usage: dict[str, Any] = {}
             component_info = ComponentInfo.from_component(self)
             async for chunk in response:
                 if chunk.type in [
@@ -507,11 +502,10 @@ class AnthropicChatGenerator:
                     "content_block_delta",
                     "message_delta",
                 ]:
-                    # Extract model from message_start chunks
+                    # Extract model and full usage from message_start chunks
                     if chunk.type == "message_start":
                         model = chunk.message.model
-                        if chunk.message.usage.input_tokens is not None:
-                            input_tokens = chunk.message.usage.input_tokens
+                        start_usage = chunk.message.usage.model_dump()
 
                     if chunk.type == "content_block_start":
                         if chunk.content_block.type == "tool_use":
@@ -536,10 +530,9 @@ class AnthropicChatGenerator:
                 {"received_at": datetime.now(timezone.utc).isoformat(), "model": model},
             )
 
-            if input_tokens is not None:
-                if "usage" not in completion.meta:
-                    completion.meta["usage"] = {}
-                completion.meta["usage"]["input_tokens"] = input_tokens
+            # `completion.meta["usage"]` is the usage of the last message_delta chunk
+            if usage := _merge_streaming_usage(start_usage=start_usage, delta_usage=completion.meta.get("usage")):
+                completion.meta["usage"] = usage
 
             # keep the raw content so server-tool blocks can be replayed on later turns
             if self.anthropic_server_tools:

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/src/haystack_integrations/components/generators/anthropic/chat/foundry_chat_generator.py

@@ -18,7 +18,6 @@ from haystack.tools import (
 from haystack.utils import (
     Secret,
     deserialize_callable,
-    deserialize_secrets_inplace,
     serialize_callable,
 )
 
@@ -68,8 +67,9 @@ class AnthropicFoundryChatGenerator(AnthropicChatGenerator):
     >> focuses on enabling computers to understand, interpret, and generate human language. It involves developing
     >> techniques and algorithms to analyze and process text or speech data, allowing machines to comprehend and
     >> communicate in natural languages like English, Spanish, or Chinese.")],
-    >> _name=None, _meta={'model': 'claude-sonnet-4-5', 'index': 0, 'finish_reason': 'end_turn',
-    >> 'usage': {'input_tokens': 15, 'output_tokens': 64}})]}
+    >> _name=None, _meta={'model': 'claude-sonnet-4-5', 'index': 0, 'finish_reason': 'stop',
+    >> 'usage': {'prompt_tokens': 15, 'completion_tokens': 64, 'cache_read_input_tokens': 0,
+    >> 'cache_creation_input_tokens': 0, ...}})]}
     ```
 
     For more details on supported models and their capabilities, refer to the Anthropic
@@ -258,7 +258,6 @@ class AnthropicFoundryChatGenerator(AnthropicChatGenerator):
             The deserialized component instance.
         """
         deserialize_tools_or_toolset_inplace(data["init_parameters"], key="tools")
-        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
 
         init_params = data.get("init_parameters", {})
         if serialized_callback := init_params.get("streaming_callback"):

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/src/haystack_integrations/components/generators/anthropic/chat/utils.py

@@ -387,6 +387,22 @@ def _get_openai_compatible_usage(response_dict: dict) -> dict:
     return usage
 
 
+def _merge_streaming_usage(start_usage: dict[str, Any], delta_usage: dict[str, Any] | None) -> dict[str, Any]:
+    """
+    Combines the usage of a streamed response into the format a non-streamed response reports.
+
+    The `message_start` event carries the full `Usage`, including the `cache_creation` split by TTL and the
+    `service_tier`. The `message_delta` event carries the final cumulative counts, but only a subset of the fields.
+
+    :param start_usage: The usage of the `message_start` event.
+    :param delta_usage: The usage of the last `message_delta` event, or `None` if the stream had none.
+    :returns: The `message_start` usage with every non-null `message_delta` count written over it, converted with
+        `_get_openai_compatible_usage`.
+    """
+    usage = {**start_usage, **{key: value for key, value in (delta_usage or {}).items() if value is not None}}
+    return _get_openai_compatible_usage({"usage": usage})
+
+
 def _convert_chat_completion_to_chat_message(
     anthropic_response: Any, ignore_tools_thinking_messages: bool
 ) -> ChatMessage:

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/src/haystack_integrations/components/generators/anthropic/chat/vertex_chat_generator.py

@@ -57,8 +57,9 @@ class AnthropicVertexChatGenerator(AnthropicChatGenerator):
     >> focuses on enabling computers to understand, interpret, and generate human language. It involves developing
     >> techniques and algorithms to analyze and process text or speech data, allowing machines to comprehend and
     >> communicate in natural languages like English, Spanish, or Chinese.")],
-    >> _name=None, _meta={'model': 'claude-sonnet-4-5@20250929', 'index': 0, 'finish_reason': 'end_turn',
-    >> 'usage': {'input_tokens': 15, 'output_tokens': 64}})]}
+    >> _name=None, _meta={'model': 'claude-sonnet-4-5@20250929', 'index': 0, 'finish_reason': 'stop',
+    >> 'usage': {'prompt_tokens': 15, 'completion_tokens': 64, 'cache_read_input_tokens': 0,
+    >> 'cache_creation_input_tokens': 0, ...}})]}
     ```
 
     For more details on supported models and their capabilities, refer to the Anthropic

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/src/haystack_integrations/token_counters/anthropic/token_counter.py

@@ -7,7 +7,7 @@ from typing import Any
 from haystack import default_from_dict, default_to_dict
 from haystack.dataclasses import ChatMessage
 from haystack.tools import ToolsType, flatten_tools_or_toolsets
-from haystack.utils.auth import Secret, deserialize_secrets_inplace
+from haystack.utils.auth import Secret
 
 from anthropic import Anthropic
 from anthropic.types import ToolParam
@@ -132,5 +132,4 @@ class AnthropicTokenCounter:
         :param data: The dictionary to deserialize from.
         :returns: The deserialized token counter.
         """
-        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
         return default_from_dict(cls, data)

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/tests/test_chat_generator.py

@@ -539,23 +539,27 @@ class TestRun:
                 },
             ),
             (
-                # thinking_display is dropped when thinking is disabled through a flattened kwarg
+                # thinking type in_between with effort
                 {
-                    "adaptive_thinking_effort": "none",
+                    "thinking_type": "in_between",
                     "thinking_display": "summarized",
+                    "output_config_effort": "high",
                 },
                 {
-                    "thinking": {"type": "disabled"},
+                    "thinking": {"type": "in_between", "display": "summarized"},
+                    "output_config": {"effort": "high"},
                 },
             ),
             (
-                # thinking_display is dropped when thinking is disabled through an explicit thinking dict
+                # thinking type adaptive with effort
                 {
-                    "thinking": {"type": "disabled"},
+                    "thinking_type": "adaptive",
                     "thinking_display": "summarized",
+                    "output_config_effort": "high",
                 },
                 {
-                    "thinking": {"type": "disabled"},
+                    "thinking": {"type": "adaptive", "display": "summarized"},
+                    "output_config": {"effort": "high"},
                 },
             ),
         ],
@@ -897,12 +901,14 @@ class TestIntegration:
         assert "Paris" in message.text
         assert "claude-sonnet-4-5" in message.meta["model"]
         assert message.meta["finish_reason"] == "stop"
+        assert "prompt_tokens" in message.meta["usage"]
+        assert "completion_tokens" in message.meta["usage"]
+        # only the message_start event carries `service_tier` when streaming
+        assert message.meta["usage"]["service_tier"] is not None
 
         if streaming:
             assert callback.counter > 1
             assert "Paris" in callback.responses
-            assert "input_tokens" in message.meta["usage"]
-            assert "output_tokens" in message.meta["usage"]
 
     def test_live_run_wrong_model(self, chat_messages):
         component = AnthropicChatGenerator(model="something-obviously-wrong")
@@ -934,11 +940,8 @@ class TestIntegration:
         assert tool_call.tool_name == "weather"
         assert tool_call.arguments == {"city": "Paris"}
         assert message.meta["finish_reason"] == "tool_calls"
-        if streaming:
-            assert "output_tokens" in message.meta["usage"]
-            assert "input_tokens" in message.meta["usage"]
-        else:
-            assert "completion_tokens" in message.meta["usage"]
+        assert "prompt_tokens" in message.meta["usage"]
+        assert "completion_tokens" in message.meta["usage"]
 
         new_messages = [
             *initial_messages,
@@ -1191,8 +1194,8 @@ class TestIntegration:
         assert tool_call.tool_name == "weather"
         assert tool_call.arguments == {"city": "Paris"}
         assert message.meta["finish_reason"] == "tool_calls"
-        assert "output_tokens" in message.meta["usage"]
-        assert "input_tokens" in message.meta["usage"]
+        assert "completion_tokens" in message.meta["usage"]
+        assert "prompt_tokens" in message.meta["usage"]
 
         new_messages = [
             *initial_messages,
@@ -1206,16 +1209,20 @@ class TestIntegration:
         assert len(final_message.text) > 0
         assert "paris" in final_message.text.lower()
 
+    @pytest.mark.parametrize("streaming", [False, True])
     @pytest.mark.parametrize("cache_enabled", [True, False])
     @pytest.mark.parametrize("cache_location", ["system", "user"])
-    def test_prompt_caching_live_run(self, cache_enabled, cache_location):
+    def test_prompt_caching_live_run(self, cache_enabled, cache_location, streaming):
         """
-        Prompt caching works whether the cache_control marker sits on the system or the user message.
+        Prompt caching works whether the cache_control marker sits on the system or the user message, with and
+        without streaming.
         """
         generation_kwargs = {"extra_headers": {"anthropic-beta": "prompt-caching-2024-07-31"}} if cache_enabled else {}
 
         claude_llm = AnthropicChatGenerator(
-            api_key=Secret.from_env_var("ANTHROPIC_API_KEY"), generation_kwargs=generation_kwargs
+            api_key=Secret.from_env_var("ANTHROPIC_API_KEY"),
+            generation_kwargs=generation_kwargs,
+            streaming_callback=print_streaming_chunk if streaming else None,
         )
 
         # see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching#cache-limitations
@@ -1243,6 +1250,8 @@ class TestIntegration:
                 token_usage.get("cache_creation_input_tokens", 0) > 1024
                 or token_usage.get("cache_read_input_tokens", 0) > 1024
             ), f"Unexpected usage stats: {token_usage}"
+            # the split of cache writes by TTL, which only the message_start event carries when streaming
+            assert token_usage["cache_creation"] is not None
         else:
             assert token_usage.get("cache_creation_input_tokens", 0) == 0
             assert token_usage.get("cache_read_input_tokens", 0) == 0

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/tests/test_chat_generator_async.py

@@ -132,8 +132,10 @@ class TestIntegration:
         assert "paris" in message.text.lower()
         assert "claude-sonnet-4-5" in message.meta["model"]
         assert message.meta["finish_reason"] == "stop"
-        assert "input_tokens" in message.meta["usage"]
-        assert "output_tokens" in message.meta["usage"]
+        assert "prompt_tokens" in message.meta["usage"]
+        assert "completion_tokens" in message.meta["usage"]
+        # only the message_start event carries `service_tier` when streaming
+        assert message.meta["usage"]["service_tier"] is not None
 
         # Verify streaming behavior
         assert counter > 1  # Should have received multiple chunks

{anthropic_haystack-6.2.0 → anthropic_haystack-7.0.0}/tests/test_utils.py

@@ -4,6 +4,7 @@ from dataclasses import replace
 
 import pytest
 from anthropic.types import (
+    CacheCreation,
     InputJSONDelta,
     Message,
     MessageDeltaUsage,
@@ -52,6 +53,7 @@ from haystack_integrations.components.generators.anthropic.chat.utils import (
     _finalize_reasoning_group,
     _get_openai_compatible_usage,
     _has_server_tool_blocks,
+    _merge_streaming_usage,
 )
 
 CITATION = {
@@ -627,11 +629,14 @@ class TestConvertAnthropicChunkToStreamingChunk:
         message = generator._process_response(raw_chunks)
         usage = message["replies"][0].meta["usage"]
         assert isinstance(usage, dict)
-        assert usage["cache_creation_input_tokens"] is None
-        assert usage["cache_read_input_tokens"] is None
-        assert usage["input_tokens"] == 393
-        assert usage["output_tokens"] == 77
+        assert usage["cache_creation_input_tokens"] == 0
+        assert usage["cache_read_input_tokens"] == 0
+        assert usage["prompt_tokens"] == 393
+        assert usage["completion_tokens"] == 77
         assert usage["server_tool_use"] is None
+        assert usage["service_tier"] == "standard"
+        assert "input_tokens" not in usage
+        assert "output_tokens" not in usage
 
     def test_accumulate_raw_content_blocks_from_stream(self):
         component_info = ComponentInfo(name="test", type="test")
@@ -1568,3 +1573,41 @@ class TestOpenAICompatibleUsage:
     @pytest.mark.parametrize("response_dict", [{}, {"usage": {}}], ids=["no_usage_key", "empty_usage"])
     def test_empty_usage_is_unchanged(self, response_dict):
         assert _get_openai_compatible_usage(response_dict) == {}
+
+
+class TestMergeStreamingUsage:
+    def test_cache_creation_split_is_kept(self):
+        """`message_delta` usage has no `cache_creation`, so the split must come from `message_start`."""
+        start_usage = Usage(
+            input_tokens=10,
+            output_tokens=1,
+            cache_read_input_tokens=2000,
+            cache_creation_input_tokens=1500,
+            cache_creation=CacheCreation(ephemeral_5m_input_tokens=500, ephemeral_1h_input_tokens=1000),
+            service_tier="standard",
+        ).model_dump()
+        delta_usage = MessageDeltaUsage(
+            input_tokens=10, output_tokens=77, cache_read_input_tokens=2000, cache_creation_input_tokens=1500
+        ).model_dump()
+
+        usage = _merge_streaming_usage(start_usage=start_usage, delta_usage=delta_usage)
+
+        assert usage["prompt_tokens"] == 3510
+        assert usage["completion_tokens"] == 77
+        assert usage["cache_read_input_tokens"] == 2000
+        assert usage["cache_creation_input_tokens"] == 1500
+        assert usage["cache_creation"] == {"ephemeral_5m_input_tokens": 500, "ephemeral_1h_input_tokens": 1000}
+        assert usage["service_tier"] == "standard"
+        assert "input_tokens" not in usage
+        assert "output_tokens" not in usage
+
+    def test_null_delta_counts_keep_start_counts(self):
+        start_usage = {"input_tokens": 393, "output_tokens": 3, "cache_read_input_tokens": 0}
+        delta_usage = {"input_tokens": None, "output_tokens": 77, "cache_read_input_tokens": None}
+
+        usage = _merge_streaming_usage(start_usage=start_usage, delta_usage=delta_usage)
+
+        assert usage == {"prompt_tokens": 393, "completion_tokens": 77, "cache_read_input_tokens": 0}
+
+    def test_no_usage_returns_empty_dict(self):
+        assert _merge_streaming_usage(start_usage={}, delta_usage=None) == {}