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

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

@@ -1,5 +1,17 @@
 # Changelog
 
+## [integrations/anthropic-v6.1.0] - 2026-09-22
+
+### 🐛 Bug Fixes
+
+- Anthropic - respect an empty runtime tools list (#3977)
+- Drop Anthropic tool calls truncated at max_tokens and raise the default limit (#3982)
+
+### 🧹 Chores
+
+- Refresh Anthropic model lists and expose service_tierupdates (#3983)
+
+
 ## [integrations/anthropic-v6.0.1] - 2026-09-14
 
 ### 🐛 Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: anthropic-haystack
-Version: 6.1.0
+Version: 6.2.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.1.0 → anthropic_haystack-6.2.0}/src/haystack_integrations/components/generators/anthropic/chat/chat_generator.py

@@ -349,6 +349,11 @@ class AnthropicChatGenerator:
 
     def _resolve_flattened_generation_kwargs(self, generation_kwargs: dict[str, Any]) -> dict[str, Any]:
         generation_kwargs = generation_kwargs.copy()
+        # Copy the nested dicts the flattened kwargs write into; a shallow copy would share them with the
+        # component's init-time generation_kwargs, so a per-run flattened kwarg would persist across runs.
+        for key in ("tool_choice", "thinking", "output_config"):
+            if isinstance(generation_kwargs.get(key), dict):
+                generation_kwargs[key] = dict(generation_kwargs[key])
 
         disable_parallel_tool_use = generation_kwargs.pop("disable_parallel_tool_use", None)
         parallel_tool_use = generation_kwargs.pop("parallel_tool_use", None)
@@ -385,6 +390,13 @@ 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
+
         return generation_kwargs
 
     def _process_response(

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

@@ -481,6 +481,7 @@ class TestRun:
                     "parallel_tool_use": None,
                     "tool_choice_type": None,
                     "adaptive_thinking_effort": None,
+                    "thinking_display": None,
                 },
                 {},
             ),
@@ -517,6 +518,46 @@ class TestRun:
                     "service_tier": "standard_only",
                 },
             ),
+            (
+                {
+                    "adaptive_thinking_effort": "high",
+                    "thinking_display": "summarized",
+                },
+                {
+                    "thinking": {"type": "adaptive", "display": "summarized"},
+                    "output_config": {"effort": "high"},
+                },
+            ),
+            (
+                # thinking_display is merged into an explicitly passed thinking dict
+                {
+                    "thinking": {"type": "adaptive"},
+                    "thinking_display": "omitted",
+                },
+                {
+                    "thinking": {"type": "adaptive", "display": "omitted"},
+                },
+            ),
+            (
+                # thinking_display is dropped when thinking is disabled through a flattened kwarg
+                {
+                    "adaptive_thinking_effort": "none",
+                    "thinking_display": "summarized",
+                },
+                {
+                    "thinking": {"type": "disabled"},
+                },
+            ),
+            (
+                # thinking_display is dropped when thinking is disabled through an explicit thinking dict
+                {
+                    "thinking": {"type": "disabled"},
+                    "thinking_display": "summarized",
+                },
+                {
+                    "thinking": {"type": "disabled"},
+                },
+            ),
         ],
     )
     def test_run_with_flattened_generation_kwargs(
@@ -538,6 +579,41 @@ class TestRun:
         assert actual_kwargs.get("output_config") == expected_kwargs.get("output_config")
         assert actual_kwargs.get("service_tier") == expected_kwargs.get("service_tier")
 
+    def test_run_with_flattened_generation_kwargs_does_not_leak_across_runs(self, chat_messages, mock_chat_completion):
+        init_generation_kwargs = {
+            "tool_choice": {"type": "auto"},
+            "thinking": {"type": "adaptive"},
+            "output_config": {"effort": "low"},
+        }
+        component = AnthropicChatGenerator(
+            api_key=Secret.from_token("test-api-key"),
+            generation_kwargs=init_generation_kwargs,
+        )
+
+        component.run(
+            chat_messages,
+            generation_kwargs={
+                "parallel_tool_use": False,
+                "thinking_display": "summarized",
+                "adaptive_thinking_effort": "high",
+            },
+        )
+        first_kwargs = mock_chat_completion.call_args.kwargs
+        assert first_kwargs["tool_choice"] == {"type": "auto", "disable_parallel_tool_use": True}
+        assert first_kwargs["thinking"] == {"type": "adaptive", "display": "summarized"}
+        assert first_kwargs["output_config"] == {"effort": "high"}
+
+        component.run(chat_messages)
+        second_kwargs = mock_chat_completion.call_args.kwargs
+        assert second_kwargs["tool_choice"] == {"type": "auto"}
+        assert second_kwargs["thinking"] == {"type": "adaptive"}
+        assert second_kwargs["output_config"] == {"effort": "low"}
+        assert component.generation_kwargs == {
+            "tool_choice": {"type": "auto"},
+            "thinking": {"type": "adaptive"},
+            "output_config": {"effort": "low"},
+        }
+
 
 class TestAnthropicServerTools:
     def test_init_with_anthropic_server_tools(self, monkeypatch):