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

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

@@ -1,5 +1,24 @@
 # 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 - allow empty assistant messages (#3952)
+
+
 ## [integrations/anthropic-v6.0.0] - 2026-09-03
 
 ### 🚀 Features

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

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

@@ -42,6 +42,8 @@ from .utils import (
 
 logger = logging.getLogger(__name__)
 
+_DEFAULT_MAX_TOKENS = 8192
+
 
 @component
 class AnthropicChatGenerator:
@@ -104,6 +106,7 @@ class AnthropicChatGenerator:
         "tool_choice",
         "max_tokens",
         "metadata",
+        "service_tier",
         "stop_sequences",
         "temperature",
         "top_p",
@@ -114,15 +117,17 @@ class AnthropicChatGenerator:
     ]
 
     SUPPORTED_MODELS: ClassVar[list[str]] = [
+        "claude-fable-5-1",
+        "claude-fable-5",
+        "claude-opus-5",
+        "claude-opus-4-8",
+        "claude-opus-4-7",
         "claude-opus-4-6",
+        "claude-opus-4-5-20251101",
+        "claude-sonnet-5",
         "claude-sonnet-4-6",
-        "claude-haiku-4-5-20251001",
         "claude-sonnet-4-5-20250929",
-        "claude-opus-4-5-20251101",
-        "claude-opus-4-1-20250805",
-        "claude-sonnet-4-20250514",
-        "claude-opus-4-20250514",
-        "claude-3-haiku-20240307",
+        "claude-haiku-4-5-20251001",
     ]
     """A non-exhaustive list of chat models supported by this component. See
      https://platform.claude.com/docs/en/about-claude/models/overview for the full list."""
@@ -153,8 +158,12 @@ class AnthropicChatGenerator:
 
             Supported generation_kwargs parameters are:
             - `system`: The system message to be passed to the model.
-            - `max_tokens`: The maximum number of tokens to generate.
+            - `max_tokens`: The maximum number of tokens to generate. Defaults to 8192. A response that hits
+                this limit is cut off; if the model was writing a tool call at the time, that call is dropped
+                and the reply carries a `length` finish reason.
             - `metadata`: A dictionary of metadata to be passed to the model.
+            - `service_tier`: Whether the request may use priority capacity (`auto`) or standard capacity only
+                (`standard_only`). See [service tiers](https://platform.claude.com/docs/en/api/service-tiers).
             - `stop_sequences`: A list of strings that the model should stop generating at.
             - `temperature`: The temperature to use for sampling.
             - `top_p`: The top_p value to use for nucleus sampling.
@@ -316,7 +325,7 @@ class AnthropicChatGenerator:
         # prompt caching
 
         # tools management
-        tools = tools or self.tools
+        tools = tools if tools is not None else self.tools
         flattened_tools = flatten_tools_or_toolsets(tools)
         _check_duplicate_tool_names(flattened_tools)
 
@@ -340,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)
@@ -376,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(
@@ -587,7 +608,7 @@ class AnthropicChatGenerator:
             system=system_messages,
             tools=anthropic_tools,
             stream=streaming_callback is not None,
-            max_tokens=generation_kwargs.pop("max_tokens", 1024),
+            max_tokens=generation_kwargs.pop("max_tokens", _DEFAULT_MAX_TOKENS),
             **generation_kwargs,
         )
 
@@ -636,7 +657,7 @@ class AnthropicChatGenerator:
             system=system_messages,
             tools=anthropic_tools,
             stream=streaming_callback is not None,
-            max_tokens=generation_kwargs.pop("max_tokens", 1024),
+            max_tokens=generation_kwargs.pop("max_tokens", _DEFAULT_MAX_TOKENS),
             **generation_kwargs,
         )
 

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

@@ -77,11 +77,16 @@ class AnthropicFoundryChatGenerator(AnthropicChatGenerator):
     """
 
     SUPPORTED_MODELS: ClassVar[list[str]] = [
+        "claude-fable-5-1",
+        "claude-fable-5",
+        "claude-opus-5",
+        "claude-opus-4-8",
+        "claude-opus-4-7",
         "claude-opus-4-6",
+        "claude-opus-4-5",
+        "claude-sonnet-5",
         "claude-sonnet-4-6",
         "claude-sonnet-4-5",
-        "claude-opus-4-5",
-        "claude-opus-4-1",
         "claude-haiku-4-5",
     ]
     """A non-exhaustive list of chat models supported by this component.
@@ -122,8 +127,12 @@ class AnthropicFoundryChatGenerator(AnthropicChatGenerator):
             for more details.
             Supported generation_kwargs parameters are:
             - `system`: The system message to be passed to the model.
-            - `max_tokens`: The maximum number of tokens to generate.
+            - `max_tokens`: The maximum number of tokens to generate. Defaults to 8192. A response that hits
+                this limit is cut off; if the model was writing a tool call at the time, that call is dropped
+                and the reply carries a `length` finish reason.
             - `metadata`: A dictionary of metadata to be passed to the model.
+            - `service_tier`: Whether the request may use priority capacity (`auto`) or standard capacity only
+                (`standard_only`). See [service tiers](https://platform.claude.com/docs/en/api/service-tiers).
             - `stop_sequences`: A list of strings that the model should stop generating at.
             - `temperature`: The temperature to use for sampling.
             - `top_p`: The top_p value to use for nucleus sampling.

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

@@ -2,6 +2,7 @@ import json
 from copy import deepcopy
 from typing import Any, Literal, TypeAlias, cast, get_args
 
+from haystack import logging
 from haystack.dataclasses.chat_message import (
     ChatMessage,
     ChatRole,
@@ -32,6 +33,8 @@ from anthropic.types import (
     ToolUseBlockParam,
 )
 
+logger = logging.getLogger(__name__)
+
 # See https://docs.anthropic.com/en/api/messages for supported formats
 ImageFormat = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 IMAGE_SUPPORTED_FORMATS: list[ImageFormat] = list(get_args(ImageFormat))
@@ -392,9 +395,29 @@ def _convert_chat_completion_to_chat_message(
     """
     tool_calls = []
     reasoning_contents = []
-    reasoning_text = ""
 
-    for block in anthropic_response.content:
+    # A `max_tokens` stop reason cuts the response off mid-block. If that block was a tool call, its arguments are
+    # incomplete: Anthropic still returns a `tool_use` block, but only the keys it managed to finish. Running the
+    # tool with those arguments would act on the wrong input, so the call is dropped here. Instead, the reply carries
+    # the `length` finish reason which mirrors the streaming path, where the truncated JSON fails to parse and the tool
+    # call is dropped.
+    blocks = anthropic_response.content
+    truncated_tool_call = (
+        anthropic_response.stop_reason == "max_tokens" and bool(blocks) and blocks[-1].type == "tool_use"
+    )
+    if truncated_tool_call:
+        truncated_block = blocks[-1]
+        logger.warning(
+            "The model hit the `max_tokens` limit while writing the arguments of tool call `{tool_name}`, so they "
+            "are incomplete and the tool call will be skipped. Raise `max_tokens` in `generation_kwargs` to give "
+            "the model room to finish. Tool call ID: {tool_call_id}, partial arguments: {arguments}",
+            tool_name=truncated_block.name,
+            tool_call_id=truncated_block.id,
+            arguments=truncated_block.input,
+        )
+        blocks = blocks[:-1]
+
+    for block in blocks:
         reasoning_content: dict[str, Any] = {}
         if block.type == "tool_use":
             tool_calls.append(ToolCall(tool_name=block.name, arguments=block.input, id=block.id))
@@ -420,30 +443,25 @@ def _convert_chat_completion_to_chat_message(
     text = ""
 
     if not (ignore_tools_thinking_messages and tool_calls):
-        text = " ".join(block.text for block in anthropic_response.content if block.type == "text")
-
-    message = ChatMessage.from_assistant(text=text, tool_calls=tool_calls, reasoning=reasoning)
+        text = " ".join(block.text for block in blocks if block.type == "text")
 
     # Dump the chat completion to a dict
     response_dict = anthropic_response.model_dump()
-    usage = _get_openai_compatible_usage(response_dict)
-    message._meta.update(
-        {
-            "model": response_dict.get("model", None),
-            "index": 0,
-            "finish_reason": FINISH_REASON_MAPPING.get(response_dict.get("stop_reason" or "")),
-            "usage": usage,
-        }
-    )
+    meta: dict[str, Any] = {
+        "model": response_dict.get("model", None),
+        "index": 0,
+        "finish_reason": FINISH_REASON_MAPPING.get(response_dict.get("stop_reason")),
+        "usage": _get_openai_compatible_usage(response_dict),
+    }
 
     # keep raw content so server-tool blocks can be replayed on later turns
-    content_blocks = response_dict.get("content") or []
-    if _has_server_tool_blocks(content_blocks):
-        message._meta["raw_content_for_server_tools"] = content_blocks
-    if citations := _extract_citations(content_blocks):
-        message._meta["citations"] = citations
+    raw_content_blocks = response_dict.get("content") or []
+    if _has_server_tool_blocks(raw_content_blocks):
+        meta["raw_content_for_server_tools"] = raw_content_blocks
+    if citations := _extract_citations(raw_content_blocks):
+        meta["citations"] = citations
 
-    return message
+    return ChatMessage.from_assistant(text=text, tool_calls=tool_calls, reasoning=reasoning, meta=meta)
 
 
 def _convert_anthropic_chunk_to_streaming_chunk(

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

@@ -46,7 +46,7 @@ class AnthropicVertexChatGenerator(AnthropicChatGenerator):
 
     messages = [ChatMessage.from_user("What's Natural Language Processing?")]
     client = AnthropicVertexChatGenerator(
-                model="claude-sonnet-4@20250514",
+                model="claude-sonnet-4-5@20250929",
                 project_id="your-project-id", region="your-region"
             )
     response = client.run(messages)
@@ -57,7 +57,7 @@ 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@20250514', 'index': 0, 'finish_reason': 'end_turn',
+    >> _name=None, _meta={'model': 'claude-sonnet-4-5@20250929', 'index': 0, 'finish_reason': 'end_turn',
     >> 'usage': {'input_tokens': 15, 'output_tokens': 64}})]}
     ```
 
@@ -69,13 +69,16 @@ class AnthropicVertexChatGenerator(AnthropicChatGenerator):
     """
 
     SUPPORTED_MODELS: ClassVar[list[str]] = [
+        "claude-fable-5-1",
+        "claude-fable-5",
+        "claude-opus-5",
+        "claude-opus-4-8",
+        "claude-opus-4-7",
         "claude-opus-4-6",
+        "claude-opus-4-5@20251101",
+        "claude-sonnet-5",
         "claude-sonnet-4-6",
         "claude-sonnet-4-5@20250929",
-        "claude-sonnet-4@20250514",
-        "claude-opus-4-5@20251101",
-        "claude-opus-4-1@20250805",
-        "claude-opus-4@20250514",
         "claude-haiku-4-5@20251001",
     ]
     """A non-exhaustive list of chat models supported by this component. See
@@ -85,7 +88,7 @@ class AnthropicVertexChatGenerator(AnthropicChatGenerator):
         self,
         region: str,
         project_id: str,
-        model: str = "claude-sonnet-4@20250514",
+        model: str = "claude-sonnet-4-5@20250929",
         streaming_callback: Callable[[StreamingChunk], None] | None = None,
         generation_kwargs: dict[str, Any] | None = None,
         ignore_tools_thinking_messages: bool = True,
@@ -109,8 +112,12 @@ class AnthropicVertexChatGenerator(AnthropicChatGenerator):
 
             Supported generation_kwargs parameters are:
             - `system`: The system message to be passed to the model.
-            - `max_tokens`: The maximum number of tokens to generate.
+            - `max_tokens`: The maximum number of tokens to generate. Defaults to 8192. A response that hits
+                this limit is cut off; if the model was writing a tool call at the time, that call is dropped
+                and the reply carries a `length` finish reason.
             - `metadata`: A dictionary of metadata to be passed to the model.
+            - `service_tier`: Whether the request may use priority capacity (`auto`) or standard capacity only
+                (`standard_only`). See [service tiers](https://platform.claude.com/docs/en/api/service-tiers).
             - `stop_sequences`: A list of strings that the model should stop generating at.
             - `temperature`: The temperature to use for sampling.
             - `top_p`: The top_p value to use for nucleus sampling.

{anthropic_haystack-6.0.1 → 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,
                 },
                 {},
             ),
@@ -509,6 +510,54 @@ class TestRun:
                     "thinking": {"type": "disabled"},
                 },
             ),
+            (
+                {
+                    "service_tier": "standard_only",
+                },
+                {
+                    "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(
@@ -528,6 +577,42 @@ class TestRun:
         assert actual_kwargs.get("tool_choice") == expected_kwargs.get("tool_choice")
         assert actual_kwargs.get("thinking") == expected_kwargs.get("thinking")
         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:
@@ -569,6 +654,12 @@ class TestAnthropicServerTools:
         assert len(kwargs["tools"]) == 2
         assert kwargs["tools"][-1] == {"type": "web_search_20250305"}
 
+    def test_run_with_empty_tools_override(self, chat_messages, mock_chat_completion, tools):
+        component = AnthropicChatGenerator(api_key=Secret.from_token("test-api-key"), tools=tools)
+        component.run(messages=chat_messages, tools=[])
+        _, kwargs = mock_chat_completion.call_args
+        assert kwargs["tools"] == []
+
 
 class TestMixedToolsAndToolsets:
     def test_init_with_mixed_tools_and_toolsets(self, monkeypatch):

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

@@ -182,6 +182,135 @@ class TestConvertChatCompletionToChatMessage:
         assert message.meta["raw_content_for_server_tools"][2]["citations"][0]["encrypted_index"] == "ENCRYPTED_INDEX"
 
 
+class TestTruncatedToolCall:
+    def test_truncated_tool_call_is_dropped(self, caplog):
+        chat_completion = Message(
+            id="msg_01MZF",
+            content=[
+                ToolUseBlock(
+                    type="tool_use",
+                    id="toolu_01",
+                    name="update_description",
+                    # the model never got to write `description`
+                    input={"issue_id": "AGE-144"},
+                )
+            ],
+            model="claude-sonnet-4-5",
+            role="assistant",
+            stop_reason="max_tokens",
+            type="message",
+            usage=Usage(input_tokens=57, output_tokens=8192),
+        )
+
+        chat_message = _convert_chat_completion_to_chat_message(chat_completion, ignore_tools_thinking_messages=True)
+
+        assert chat_message.tool_calls == []
+        assert chat_message.meta["finish_reason"] == "length"
+        assert "max_tokens" in caplog.text
+        assert "update_description" in caplog.text
+
+    def test_completed_tool_calls_before_the_truncated_one_are_kept(self):
+        """Only the final block is cut off, so earlier tool calls in the same reply are still usable."""
+        chat_completion = Message(
+            id="msg_01MZF",
+            content=[
+                ToolUseBlock(type="tool_use", id="toolu_01", name="weather", input={"city": "Paris"}),
+                ToolUseBlock(type="tool_use", id="toolu_02", name="update_description", input={}),
+            ],
+            model="claude-sonnet-4-5",
+            role="assistant",
+            stop_reason="max_tokens",
+            type="message",
+            usage=Usage(input_tokens=57, output_tokens=8192),
+        )
+
+        chat_message = _convert_chat_completion_to_chat_message(chat_completion, ignore_tools_thinking_messages=True)
+
+        assert [tool_call.tool_name for tool_call in chat_message.tool_calls] == ["weather"]
+
+    def test_tool_call_is_kept_when_the_response_ended_normally(self):
+        chat_completion = Message(
+            id="msg_01MZF",
+            content=[ToolUseBlock(type="tool_use", id="toolu_01", name="weather", input={"city": "Paris"})],
+            model="claude-sonnet-4-5",
+            role="assistant",
+            stop_reason="tool_use",
+            type="message",
+            usage=Usage(input_tokens=57, output_tokens=40),
+        )
+
+        chat_message = _convert_chat_completion_to_chat_message(chat_completion, ignore_tools_thinking_messages=True)
+
+        assert [tool_call.tool_name for tool_call in chat_message.tool_calls] == ["weather"]
+        assert chat_message.meta["finish_reason"] == "tool_calls"
+
+    def test_text_truncated_at_max_tokens_is_kept(self):
+        """Only tool calls are dropped: truncated text is still the model's answer, just a shorter one."""
+        chat_completion = Message(
+            id="msg_01MZF",
+            content=[TextBlock(type="text", text="The capital of France is", citations=None)],
+            model="claude-sonnet-4-5",
+            role="assistant",
+            stop_reason="max_tokens",
+            type="message",
+            usage=Usage(input_tokens=57, output_tokens=8192),
+        )
+
+        chat_message = _convert_chat_completion_to_chat_message(chat_completion, ignore_tools_thinking_messages=True)
+
+        assert chat_message.text == "The capital of France is"
+        assert chat_message.meta["finish_reason"] == "length"
+
+    @pytest.mark.parametrize("is_async", [False, True])
+    async def test_streaming_truncated_tool_call_is_dropped(self, is_async):
+        generator = AnthropicChatGenerator(api_key=Secret.from_token("test-api-key"))
+        raw_chunks = [
+            RawMessageStartEvent(
+                message=Message(
+                    id="msg_123",
+                    content=[],
+                    model="claude-sonnet-4-5",
+                    role="assistant",
+                    stop_reason=None,
+                    stop_sequence=None,
+                    type="message",
+                    usage=Usage(input_tokens=100, output_tokens=1),
+                ),
+                type="message_start",
+            ),
+            RawContentBlockStartEvent(
+                content_block=ToolUseBlock(id="toolu_01", input={}, name="update_description", type="tool_use"),
+                index=0,
+                type="content_block_start",
+            ),
+            RawContentBlockDeltaEvent(
+                delta=InputJSONDelta(
+                    partial_json='{"issue_id": "AGE-144", "description": "Lorem ip', type="input_json_delta"
+                ),
+                index=0,
+                type="content_block_delta",
+            ),
+            RawMessageDeltaEvent(
+                delta=Delta(stop_reason="max_tokens", stop_sequence=None),
+                type="message_delta",
+                usage=MessageDeltaUsage(output_tokens=8192),
+            ),
+        ]
+
+        if is_async:
+
+            async def _astream():
+                for chunk in raw_chunks:
+                    yield chunk
+
+            message = (await generator._process_response_async(_astream()))["replies"][0]
+        else:
+            message = generator._process_response(raw_chunks)["replies"][0]
+
+        assert message.tool_calls == []
+        assert message.meta["finish_reason"] == "length"
+
+
 class TestConvertAnthropicChunkToStreamingChunk:
     def test_convert_anthropic_completion_chunks_with_multiple_tool_calls_and_reasoning_to_streaming_chunks(self):
         """

{anthropic_haystack-6.0.1 → anthropic_haystack-6.2.0}/tests/test_vertex_chat_generator.py

@@ -20,7 +20,7 @@ class TestUnit:
         component = AnthropicVertexChatGenerator(region="us-central1", project_id="test-project-id")
         assert component.region == "us-central1"
         assert component.project_id == "test-project-id"
-        assert component.model == "claude-sonnet-4@20250514"
+        assert component.model == "claude-sonnet-4-5@20250929"
         assert component.streaming_callback is None
         assert not component.generation_kwargs
         assert component.ignore_tools_thinking_messages
@@ -31,14 +31,14 @@ class TestUnit:
         component = AnthropicVertexChatGenerator(
             region="us-central1",
             project_id="test-project-id",
-            model="claude-sonnet-4@20250514",
+            model="claude-sonnet-4-5@20250929",
             streaming_callback=print_streaming_chunk,
             generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"},
             ignore_tools_thinking_messages=False,
         )
         assert component.region == "us-central1"
         assert component.project_id == "test-project-id"
-        assert component.model == "claude-sonnet-4@20250514"
+        assert component.model == "claude-sonnet-4-5@20250929"
         assert component.streaming_callback is print_streaming_chunk
         assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"}
         assert component.ignore_tools_thinking_messages is False
@@ -54,7 +54,7 @@ class TestUnit:
             "init_parameters": {
                 "region": "us-central1",
                 "project_id": "test-project-id",
-                "model": "claude-sonnet-4@20250514",
+                "model": "claude-sonnet-4-5@20250929",
                 "streaming_callback": None,
                 "generation_kwargs": {},
                 "ignore_tools_thinking_messages": True,
@@ -85,7 +85,7 @@ class TestUnit:
             "init_parameters": {
                 "region": "us-central1",
                 "project_id": "test-project-id",
-                "model": "claude-sonnet-4@20250514",
+                "model": "claude-sonnet-4-5@20250929",
                 "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
                 "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"},
                 "ignore_tools_thinking_messages": False,
@@ -105,7 +105,7 @@ class TestUnit:
             "init_parameters": {
                 "region": "us-central1",
                 "project_id": "test-project-id",
-                "model": "claude-sonnet-4@20250514",
+                "model": "claude-sonnet-4-5@20250929",
                 "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
                 "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"},
                 "ignore_tools_thinking_messages": True,
@@ -116,7 +116,7 @@ class TestUnit:
             },
         }
         component = AnthropicVertexChatGenerator.from_dict(data)
-        assert component.model == "claude-sonnet-4@20250514"
+        assert component.model == "claude-sonnet-4-5@20250929"
         assert component.region == "us-central1"
         assert component.project_id == "test-project-id"
         assert component.streaming_callback is print_streaming_chunk
@@ -220,7 +220,7 @@ class TestIntegration:
 
     def test_default_inference_params(self, chat_messages):
         client = AnthropicVertexChatGenerator(
-            region=os.environ.get("REGION"), project_id=os.environ.get("PROJECT_ID"), model="claude-sonnet-4@20250514"
+            region=os.environ.get("REGION"), project_id=os.environ.get("PROJECT_ID"), model="claude-sonnet-4-5@20250929"
         )
         response = client.run(chat_messages)
 
@@ -243,7 +243,7 @@ class TestIntegration:
         component = AnthropicVertexChatGenerator(
             region=os.environ.get("REGION"),
             project_id=os.environ.get("PROJECT_ID"),
-            model="claude-sonnet-4@20250514",
+            model="claude-sonnet-4-5@20250929",
         )
         results = await component.run_async(messages=[ChatMessage.from_user("What's the capital of France?")])
         assert len(results["replies"]) == 1