feat: Add GitHub integration with agent_prompts and github_components

integrations/github/src/haystack_integrations/tools/github/issue_commenter_tool.py

@@ -1,19 +1,46 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <[email protected]>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Optional, Union
 
-from haystack import default_from_dict, default_to_dict
 from haystack.tools import ComponentTool
 from haystack.utils import Secret, deserialize_secrets_inplace
 
 from haystack_integrations.components.connectors.github.issue_commenter import GitHubIssueCommenter
 from haystack_integrations.prompts.github.issue_commenter_prompt import ISSUE_COMMENTER_PROMPT, ISSUE_COMMENTER_SCHEMA
+from haystack_integrations.tools.github.utils import deserialize_handlers, serialize_handlers
 
 
 class GitHubIssueCommenterTool(ComponentTool):
     """
     A tool for commenting on GitHub issues.
+
+    :param name: Optional name for the tool.
+    :param description: Optional description.
+    :param parameters: Optional JSON schema defining the parameters expected by the Tool.
+    :param github_token: GitHub personal access token for API authentication
+    :param raise_on_failure: If True, raises exceptions on API errors
+    :param retry_attempts: Number of retry attempts for failed requests
+    :param outputs_to_string:
+        Optional dictionary defining how a tool outputs should be converted into a string.
+        If the source is provided only the specified output key is sent to the handler.
+        If the source is omitted the whole tool result is sent to the handler.
+        Example: {
+            "source": "docs", "handler": format_documents
+        }
+    :param inputs_from_state:
+        Optional dictionary mapping state keys to tool parameter names.
+        Example: {"repository": "repo"} maps state's "repository" to tool's "repo" parameter.
+    :param outputs_to_state:
+        Optional dictionary defining how tool outputs map to keys within state as well as optional handlers.
+        If the source is provided only the specified output key is sent to the handler.
+        Example: {
+            "documents": {"source": "docs", "handler": custom_handler}
+        }
+        If the source is omitted the whole tool result is sent to the handler.
+        Example: {
+            "documents": {"handler": custom_handler}
+        }
     """
 
     def __init__(
@@ -25,13 +52,19 @@ def __init__(
         github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
         raise_on_failure: bool = True,
         retry_attempts: int = 2,
+        outputs_to_string: Optional[Dict[str, Union[str, Callable[[Any], str]]]] = None,
+        inputs_from_state: Optional[Dict[str, str]] = None,
+        outputs_to_state: Optional[Dict[str, Dict[str, Union[str, Callable]]]] = None,
     ):
         self.name = name
         self.description = description
         self.parameters = parameters
         self.github_token = github_token
         self.raise_on_failure = raise_on_failure
         self.retry_attempts = retry_attempts
+        self.outputs_to_string = outputs_to_string
+        self.inputs_from_state = inputs_from_state
+        self.outputs_to_state = outputs_to_state
 
         issue_commenter = GitHubIssueCommenter(
             github_token=github_token,
@@ -43,6 +76,9 @@ def __init__(
             name=name,
             description=description,
             parameters=parameters,
+            outputs_to_string=outputs_to_string,
+            inputs_from_state=inputs_from_state,
+            outputs_to_state=outputs_to_state,
         )
 
     def to_dict(self) -> Dict[str, Any]:
@@ -52,15 +88,23 @@ def to_dict(self) -> Dict[str, Any]:
         :returns:
             Dictionary with serialized data.
         """
-        return default_to_dict(
-            self,
-            name=self.name,
-            description=self.description,
-            parameters=self.parameters,
-            github_token=self.github_token.to_dict() if self.github_token else None,
-            raise_on_failure=self.raise_on_failure,
-            retry_attempts=self.retry_attempts,
-        )
+        serialized = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+            "github_token": self.github_token.to_dict() if self.github_token else None,
+            "raise_on_failure": self.raise_on_failure,
+            "retry_attempts": self.retry_attempts,
+            "outputs_to_string": self.outputs_to_string,
+            "inputs_from_state": self.inputs_from_state,
+            "outputs_to_state": self.outputs_to_state,
+        }
+
+        serialize_handlers(serialized, self.outputs_to_state, self.outputs_to_string)
+        return {
+            "type": "haystack_integrations.tools.github.issue_commenter_tool.GitHubIssueCommenterTool",
+            "data": serialized,
+        }
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "GitHubIssueCommenterTool":
@@ -72,5 +116,7 @@ def from_dict(cls, data: Dict[str, Any]) -> "GitHubIssueCommenterTool":
         :returns:
             Deserialized tool.
         """
-        deserialize_secrets_inplace(data["init_parameters"], keys=["github_token"])
-        return default_from_dict(cls, data)
+        inner_data = data["data"]
+        deserialize_secrets_inplace(inner_data, keys=["github_token"])
+        deserialize_handlers(inner_data)
+        return cls(**inner_data)

integrations/github/tests/test_issue_commenter_tool.py

@@ -5,6 +5,7 @@
 
 from haystack_integrations.prompts.github.issue_commenter_prompt import ISSUE_COMMENTER_PROMPT, ISSUE_COMMENTER_SCHEMA
 from haystack_integrations.tools.github.issue_commenter_tool import GitHubIssueCommenterTool
+from haystack_integrations.tools.github.utils import message_handler
 
 
 class TestGitHubIssueCommenterTool:
@@ -15,18 +16,24 @@ def test_init(self, monkeypatch):
         assert tool.description == ISSUE_COMMENTER_PROMPT
         assert tool.parameters == ISSUE_COMMENTER_SCHEMA
         assert tool.retry_attempts == 2
+        assert tool.outputs_to_string is None
+        assert tool.inputs_from_state is None
+        assert tool.outputs_to_state is None
 
     def test_from_dict(self, monkeypatch):
         monkeypatch.setenv("GITHUB_TOKEN", "test-token")
         tool_dict = {
             "type": "haystack_integrations.tools.github.issue_commenter_tool.GitHubIssueCommenterTool",
-            "init_parameters": {
+            "data": {
                 "name": "issue_commenter",
                 "description": ISSUE_COMMENTER_PROMPT,
                 "parameters": ISSUE_COMMENTER_SCHEMA,
                 "github_token": {"env_vars": ["GITHUB_TOKEN"], "strict": True, "type": "env_var"},
                 "raise_on_failure": True,
                 "retry_attempts": 2,
+                "outputs_to_string": None,
+                "inputs_from_state": None,
+                "outputs_to_state": None,
             },
         }
         tool = GitHubIssueCommenterTool.from_dict(tool_dict)
@@ -36,19 +43,90 @@ def test_from_dict(self, monkeypatch):
         assert tool.github_token == Secret.from_env_var("GITHUB_TOKEN")
         assert tool.raise_on_failure
         assert tool.retry_attempts == 2
+        assert tool.outputs_to_string is None
+        assert tool.inputs_from_state is None
+        assert tool.outputs_to_state is None
 
     def test_to_dict(self, monkeypatch):
         monkeypatch.setenv("GITHUB_TOKEN", "test-token")
         tool = GitHubIssueCommenterTool()
         tool_dict = tool.to_dict()
         assert tool_dict["type"] == "haystack_integrations.tools.github.issue_commenter_tool.GitHubIssueCommenterTool"
-        assert tool_dict["init_parameters"]["name"] == "issue_commenter"
-        assert tool_dict["init_parameters"]["description"] == ISSUE_COMMENTER_PROMPT
-        assert tool_dict["init_parameters"]["parameters"] == ISSUE_COMMENTER_SCHEMA
-        assert tool_dict["init_parameters"]["github_token"] == {
+        assert tool_dict["data"]["name"] == "issue_commenter"
+        assert tool_dict["data"]["description"] == ISSUE_COMMENTER_PROMPT
+        assert tool_dict["data"]["parameters"] == ISSUE_COMMENTER_SCHEMA
+        assert tool_dict["data"]["github_token"] == {
             "env_vars": ["GITHUB_TOKEN"],
             "strict": True,
             "type": "env_var",
         }
-        assert tool_dict["init_parameters"]["raise_on_failure"]
-        assert tool_dict["init_parameters"]["retry_attempts"] == 2
+        assert tool_dict["data"]["raise_on_failure"]
+        assert tool_dict["data"]["retry_attempts"] == 2
+        assert tool_dict["data"]["outputs_to_string"] is None
+        assert tool_dict["data"]["inputs_from_state"] is None
+        assert tool_dict["data"]["outputs_to_state"] is None
+
+    def test_to_dict_with_extra_params(self, monkeypatch):
+        monkeypatch.setenv("GITHUB_TOKEN", "test-token")
+        tool = GitHubIssueCommenterTool(
+            name="test_issue_commenter",
+            description="Test description",
+            parameters={"type": "object", "properties": {}},
+            github_token=None,
+            raise_on_failure=False,
+            retry_attempts=3,
+            outputs_to_string={"handler": message_handler},
+            inputs_from_state={"repository": "repo"},
+            outputs_to_state={"documents": {"source": "docs", "handler": message_handler}},
+        )
+        tool_dict = tool.to_dict()
+        assert tool_dict["type"] == "haystack_integrations.tools.github.issue_commenter_tool.GitHubIssueCommenterTool"
+        assert tool_dict["data"]["name"] == "test_issue_commenter"
+        assert tool_dict["data"]["description"] == "Test description"
+        assert tool_dict["data"]["parameters"] == {"type": "object", "properties": {}}
+        assert tool_dict["data"]["github_token"] is None
+        assert tool_dict["data"]["raise_on_failure"] is False
+        assert tool_dict["data"]["retry_attempts"] == 3
+        assert (
+            tool_dict["data"]["outputs_to_string"]["handler"]
+            == "haystack_integrations.tools.github.utils.message_handler"
+        )
+        assert tool_dict["data"]["inputs_from_state"] == {"repository": "repo"}
+        assert tool_dict["data"]["outputs_to_state"]["documents"]["source"] == "docs"
+        assert (
+            tool_dict["data"]["outputs_to_state"]["documents"]["handler"]
+            == "haystack_integrations.tools.github.utils.message_handler"
+        )
+
+    def test_from_dict_with_extra_params(self, monkeypatch):
+        monkeypatch.setenv("GITHUB_TOKEN", "test-token")
+        tool_dict = {
+            "type": "haystack_integrations.tools.github.issue_commenter_tool.GitHubIssueCommenterTool",
+            "data": {
+                "name": "test_issue_commenter",
+                "description": "Test description",
+                "parameters": {"type": "object", "properties": {}},
+                "github_token": None,
+                "raise_on_failure": False,
+                "retry_attempts": 3,
+                "outputs_to_string": {"handler": "haystack_integrations.tools.github.utils.message_handler"},
+                "inputs_from_state": {"repository": "repo"},
+                "outputs_to_state": {
+                    "documents": {
+                        "source": "docs",
+                        "handler": "haystack_integrations.tools.github.utils.message_handler",
+                    }
+                },
+            },
+        }
+        tool = GitHubIssueCommenterTool.from_dict(tool_dict)
+        assert tool.name == "test_issue_commenter"
+        assert tool.description == "Test description"
+        assert tool.parameters == {"type": "object", "properties": {}}
+        assert tool.github_token is None
+        assert tool.raise_on_failure is False
+        assert tool.retry_attempts == 3
+        assert tool.outputs_to_string["handler"] == message_handler
+        assert tool.inputs_from_state == {"repository": "repo"}
+        assert tool.outputs_to_state["documents"]["source"] == "docs"
+        assert tool.outputs_to_state["documents"]["handler"] == message_handler