feat: AnthropicChatGenerator - add Toolset support (#1787)

* AnthropicChatGenerator - add Toolset support

* Use new serialization method for tools

* Update haystack dep to 2.13.1 which includes Toolset

* Small update

Author: vblagoje

integrations/anthropic/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.11.0", "anthropic>=0.47.0"]
+dependencies = ["haystack-ai>=2.13.1", "anthropic>=0.47.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/anthropic#readme"

integrations/anthropic/src/haystack_integrations/components/generators/anthropic/chat/chat_generator.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple
+from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.dataclasses import (
@@ -12,15 +12,15 @@
     ToolCallResult,
     select_streaming_callback,
 )
-from haystack.tools import Tool, _check_duplicate_tool_names
+from haystack.tools import (
+    Tool,
+    Toolset,
+    _check_duplicate_tool_names,
+    deserialize_tools_or_toolset_inplace,
+    serialize_tools_or_toolset,
+)
 from haystack.utils import Secret, deserialize_callable, deserialize_secrets_inplace, serialize_callable
 
-# Compatibility with Haystack 2.12.0 and 2.13.0 - remove after 2.13.0 is released
-try:
-    from haystack.tools import deserialize_tools_or_toolset_inplace
-except ImportError:
-    from haystack.tools import deserialize_tools_inplace as deserialize_tools_or_toolset_inplace
-
 from anthropic import Anthropic, AsyncAnthropic
 
 logger = logging.getLogger(__name__)
@@ -186,7 +186,7 @@ def __init__(
         streaming_callback: Optional[StreamingCallbackT] = None,
         generation_kwargs: Optional[Dict[str, Any]] = None,
         ignore_tools_thinking_messages: bool = True,
-        tools: Optional[List[Tool]] = None,
+        tools: Optional[Union[List[Tool], Toolset]] = None,
     ):
         """
         Creates an instance of AnthropicChatGenerator.
@@ -213,10 +213,10 @@ def __init__(
             `ignore_tools_thinking_messages` is `True`, the generator will drop so-called thinking messages when tool
             use is detected. See the Anthropic [tools](https://docs.anthropic.com/en/docs/tool-use#chain-of-thought-tool-use)
             for more details.
-        :param tools: A list of Tool objects that the model can use. Each tool should have a unique name.
+        :param tools: A list of Tool objects or a Toolset that the model can use. Each tool should have a unique name.
 
         """
-        _check_duplicate_tool_names(tools)
+        _check_duplicate_tool_names(list(tools or []))  # handles Toolset as well
 
         self.api_key = api_key
         self.model = model
@@ -241,15 +241,14 @@ def to_dict(self) -> Dict[str, Any]:
             The serialized component as a dictionary.
         """
         callback_name = serialize_callable(self.streaming_callback) if self.streaming_callback else None
-        serialized_tools = [tool.to_dict() for tool in self.tools] if self.tools else None
         return default_to_dict(
             self,
             model=self.model,
             streaming_callback=callback_name,
             generation_kwargs=self.generation_kwargs,
             api_key=self.api_key.to_dict(),
             ignore_tools_thinking_messages=self.ignore_tools_thinking_messages,
-            tools=serialized_tools,
+            tools=serialize_tools_or_toolset(self.tools),
         )
 
     @classmethod
@@ -402,14 +401,15 @@ def _prepare_request_params(
         self,
         messages: List[ChatMessage],
         generation_kwargs: Optional[Dict[str, Any]] = None,
-        tools: Optional[List[Tool]] = None,
+        tools: Optional[Union[List[Tool], Toolset]] = None,
     ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], Dict[str, Any], List[Dict[str, Any]]]:
         """
         Prepare the parameters for the Anthropic API request.
 
         :param messages: A list of ChatMessage instances representing the input messages.
         :param generation_kwargs: Optional arguments to pass to the Anthropic generation endpoint.
-        :param tools: A list of tools for which the model can prepare calls.
+        :param tools: A list of Tool objects or a Toolset that the model can use. Each tool should
+        have a unique name.
         :returns: A tuple containing:
             - system_messages: List of system messages in Anthropic format
             - non_system_messages: List of non-system messages in Anthropic format
@@ -448,7 +448,8 @@ def _prepare_request_params(
 
         # tools management
         tools = tools or self.tools
-        _check_duplicate_tool_names(tools)
+        tools = list(tools) if isinstance(tools, Toolset) else tools
+        _check_duplicate_tool_names(tools)  # handles Toolset as well
         anthropic_tools = (
             [
                 {
@@ -550,16 +551,16 @@ def run(
         messages: List[ChatMessage],
         streaming_callback: Optional[StreamingCallbackT] = None,
         generation_kwargs: Optional[Dict[str, Any]] = None,
-        tools: Optional[List[Tool]] = None,
+        tools: Optional[Union[List[Tool], Toolset]] = None,
     ):
         """
         Invokes the Anthropic API with the given messages and generation kwargs.
 
         :param messages: A list of ChatMessage instances representing the input messages.
         :param streaming_callback: A callback function that is called when a new token is received from the stream.
         :param generation_kwargs: Optional arguments to pass to the Anthropic generation endpoint.
-        :param tools: A list of tools for which the model can prepare calls. If set, it will override
-        the `tools` parameter set during component initialization.
+        :param tools: A list of Tool objects or a Toolset that the model can use. Each tool should
+        have a unique name. If set, it will override the `tools` parameter set during component initialization.
         :returns: A dictionary with the following keys:
             - `replies`: The responses from the model
         """
@@ -591,16 +592,16 @@ async def run_async(
         messages: List[ChatMessage],
         streaming_callback: Optional[StreamingCallbackT] = None,
         generation_kwargs: Optional[Dict[str, Any]] = None,
-        tools: Optional[List[Tool]] = None,
+        tools: Optional[Union[List[Tool], Toolset]] = None,
     ):
         """
         Async version of the run method. Invokes the Anthropic API with the given messages and generation kwargs.
 
         :param messages: A list of ChatMessage instances representing the input messages.
         :param streaming_callback: A callback function that is called when a new token is received from the stream.
         :param generation_kwargs: Optional arguments to pass to the Anthropic generation endpoint.
-        :param tools: A list of tools for which the model can prepare calls. If set, it will override
-        the `tools` parameter set during component initialization.
+        :param tools: A list of Tool objects or a Toolset that the model can use. Each tool should
+        have a unique name. If set, it will override the `tools` parameter set during component initialization.
         :returns: A dictionary with the following keys:
             - `replies`: The responses from the model
         """

integrations/anthropic/tests/test_chat_generator.py

@@ -21,7 +21,7 @@
 from haystack import Pipeline
 from haystack.components.generators.utils import print_streaming_chunk
 from haystack.dataclasses import ChatMessage, ChatRole, StreamingChunk, ToolCall
-from haystack.tools import Tool
+from haystack.tools import Tool, Toolset
 from haystack.utils.auth import Secret
 
 from haystack_integrations.components.generators.anthropic.chat.chat_generator import (
@@ -876,6 +876,59 @@ def test_live_run_with_tools(self, tools):
         assert len(final_message.text) > 0
         assert "paris" in final_message.text.lower()
 
+    @pytest.mark.skipif(
+        not os.environ.get("ANTHROPIC_API_KEY", None),
+        reason="Export an env var called ANTHROPIC_API_KEY containing the Anthropic API key to run this test.",
+    )
+    @pytest.mark.integration
+    def test_live_run_with_toolset(self):
+        """
+        Integration test that the AnthropicChatGenerator component can run with a Toolset.
+        """
+
+        def weather_function(city: str) -> str:
+            """Get weather information for a city."""
+            weather_data = {"Paris": "22°C, sunny", "London": "15°C, rainy", "Tokyo": "18°C, cloudy"}
+            return weather_data.get(city, "Weather data not available")
+
+        def echo_function(text: str) -> str:
+            """Echo a text."""
+            return text
+
+        # Create tools
+        weather_tool = Tool(
+            name="weather",
+            description="Get weather information for a city",
+            parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+            function=weather_function,
+        )
+
+        echo_tool = Tool(
+            name="echo",
+            description="Echo a text",
+            parameters={"type": "object", "properties": {"text": {"type": "string"}}, "required": ["text"]},
+            function=echo_function,
+        )
+
+        # Create Toolset
+        toolset = Toolset([weather_tool, echo_tool])
+
+        # Test with weather query
+        initial_messages = [ChatMessage.from_user("What's the weather like in Tokyo?")]
+        component = AnthropicChatGenerator(tools=toolset)
+        results = component.run(messages=initial_messages)
+
+        assert len(results["replies"]) == 1
+        message = results["replies"][0]
+
+        assert message.tool_calls
+        tool_call = message.tool_call
+        assert isinstance(tool_call, ToolCall)
+        assert tool_call.id is not None
+        assert tool_call.tool_name == "weather"
+        assert tool_call.arguments == {"city": "Tokyo"}
+        assert message.meta["finish_reason"] == "tool_use"
+
     @pytest.mark.skipif(
         not os.environ.get("ANTHROPIC_API_KEY", None),
         reason="Export an env var called ANTHROPIC_API_KEY containing the Anthropic API key to run this test.",