vellum-ai 1.4.2__py3-none-any.whl → 1.5.1__py3-none-any.whl

vellum/workflows/integrations/tests/test_vellum_integration_service.py

@@ -0,0 +1,225 @@
+import pytest
+from unittest import mock
+
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
+
+
+def test_vellum_integration_service_get_tool_definition_success():
+    """Test that tool definitions are successfully retrieved from Vellum API"""
+    with mock.patch(
+        "vellum.workflows.integrations.vellum_integration_service.create_vellum_client"
+    ) as mock_create_client:
+        # GIVEN a mock Vellum client configured to return a tool definition
+        mock_client = mock.MagicMock()
+        mock_create_client.return_value = mock_client
+
+        mock_response = mock.MagicMock()
+        mock_response.name = "GITHUB_CREATE_AN_ISSUE"
+        mock_response.description = "Create a new issue in a GitHub repository"
+        mock_response.parameters = {
+            "type": "object",
+            "properties": {
+                "repo": {"type": "string", "description": "Repository name"},
+                "title": {"type": "string", "description": "Issue title"},
+                "body": {"type": "string", "description": "Issue body"},
+            },
+            "required": ["repo", "title"],
+        }
+        mock_response.provider = "COMPOSIO"
+
+        mock_client.integrations.retrieve_integration_tool_definition.return_value = mock_response
+
+        # WHEN we request a tool definition
+        service = VellumIntegrationService()
+        result = service.get_tool_definition(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+        )
+
+        # THEN the tool definition should be returned with all expected fields
+        assert result["name"] == "GITHUB_CREATE_AN_ISSUE"
+        assert result["description"] == "Create a new issue in a GitHub repository"
+        assert result["provider"] == "COMPOSIO"
+        assert "properties" in result["parameters"]
+        assert "repo" in result["parameters"]["properties"]
+
+        # AND the API should have been called with the correct parameters
+        mock_client.integrations.retrieve_integration_tool_definition.assert_called_once_with(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+        )
+
+
+def test_vellum_integration_service_get_tool_definition_api_error():
+    """Test that API errors are properly handled when retrieving tool definitions"""
+    with mock.patch(
+        "vellum.workflows.integrations.vellum_integration_service.create_vellum_client"
+    ) as mock_create_client:
+        # GIVEN a mock client that raises an exception when retrieving tool definitions
+        mock_client = mock.MagicMock()
+        mock_create_client.return_value = mock_client
+
+        mock_client.integrations.retrieve_integration_tool_definition.side_effect = Exception("Tool not found")
+
+        # WHEN we attempt to get a tool definition for an invalid tool
+        service = VellumIntegrationService()
+
+        # THEN it should raise a NodeException with appropriate error message
+        with pytest.raises(NodeException) as exc_info:
+            service.get_tool_definition(
+                integration="GITHUB",
+                provider="COMPOSIO",
+                tool_name="INVALID_TOOL",
+            )
+
+        assert "Failed to retrieve tool definition" in str(exc_info.value)
+        assert "Tool not found" in str(exc_info.value)
+
+
+def test_vellum_integration_service_execute_tool_success():
+    """Test that tools are successfully executed via Vellum API"""
+    with mock.patch(
+        "vellum.workflows.integrations.vellum_integration_service.create_vellum_client"
+    ) as mock_create_client:
+        # GIVEN a mock client configured to return successful execution results
+        mock_client = mock.MagicMock()
+        mock_create_client.return_value = mock_client
+
+        mock_response = mock.MagicMock()
+        mock_response.data = {
+            "success": True,
+            "issue_id": 123,
+            "issue_url": "https://github.com/user/repo/issues/123",
+        }
+
+        mock_client.integrations.execute_integration_tool.return_value = mock_response
+
+        # WHEN we execute a tool with valid arguments
+        service = VellumIntegrationService()
+        result = service.execute_tool(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+            arguments={
+                "repo": "user/repo",
+                "title": "Test Issue",
+                "body": "Test body",
+            },
+        )
+
+        # THEN the execution result should contain expected data
+        assert result["success"] is True
+        assert result["issue_id"] == 123
+        assert result["issue_url"] == "https://github.com/user/repo/issues/123"
+
+        # AND the API should have been called with correct parameters
+        mock_client.integrations.execute_integration_tool.assert_called_once_with(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="GITHUB_CREATE_AN_ISSUE",
+            arguments={
+                "repo": "user/repo",
+                "title": "Test Issue",
+                "body": "Test body",
+            },
+        )
+
+
+def test_vellum_integration_service_execute_tool_api_error():
+    """Test that execution errors are properly handled"""
+    with mock.patch(
+        "vellum.workflows.integrations.vellum_integration_service.create_vellum_client"
+    ) as mock_create_client:
+        # GIVEN a mock client that raises an exception during tool execution
+        mock_client = mock.MagicMock()
+        mock_create_client.return_value = mock_client
+
+        mock_client.integrations.execute_integration_tool.side_effect = Exception("Authentication failed")
+
+        # WHEN we attempt to execute a tool that encounters an error
+        service = VellumIntegrationService()
+
+        # THEN it should raise a NodeException with appropriate error message
+        with pytest.raises(NodeException) as exc_info:
+            service.execute_tool(
+                integration="GITHUB",
+                provider="COMPOSIO",
+                tool_name="GITHUB_CREATE_AN_ISSUE",
+                arguments={"repo": "user/repo"},
+            )
+
+        assert "Failed to execute tool" in str(exc_info.value)
+        assert "Authentication failed" in str(exc_info.value)
+
+
+def test_vellum_integration_service_execute_tool_empty_response():
+    """Test that empty response data is handled gracefully"""
+    with mock.patch(
+        "vellum.workflows.integrations.vellum_integration_service.create_vellum_client"
+    ) as mock_create_client:
+        # GIVEN a mock client that returns an empty response
+        mock_client = mock.MagicMock()
+        mock_create_client.return_value = mock_client
+
+        mock_response = mock.MagicMock()
+        mock_response.data = {}
+
+        mock_client.integrations.execute_integration_tool.return_value = mock_response
+
+        # WHEN we execute a tool that returns empty data
+        service = VellumIntegrationService()
+        result = service.execute_tool(
+            integration="SLACK",
+            provider="COMPOSIO",
+            tool_name="SLACK_SEND_MESSAGE",
+            arguments={
+                "channel": "#general",
+                "message": "Hello, world!",
+            },
+        )
+
+        # THEN an empty dictionary should be returned without errors
+        assert result == {}
+
+
+def test_vellum_integration_service_multiple_tool_executions():
+    """Test that the service handles multiple sequential tool executions"""
+    with mock.patch(
+        "vellum.workflows.integrations.vellum_integration_service.create_vellum_client"
+    ) as mock_create_client:
+        # GIVEN a mock client configured to return different responses for each call
+        mock_client = mock.MagicMock()
+        mock_create_client.return_value = mock_client
+
+        responses = [
+            mock.MagicMock(data={"result": "first"}),
+            mock.MagicMock(data={"result": "second"}),
+        ]
+        mock_client.integrations.execute_integration_tool.side_effect = responses
+
+        # WHEN we execute multiple tools in sequence
+        service = VellumIntegrationService()
+
+        result1 = service.execute_tool(
+            integration="GITHUB",
+            provider="COMPOSIO",
+            tool_name="TOOL_1",
+            arguments={"arg": "val1"},
+        )
+
+        result2 = service.execute_tool(
+            integration="SLACK",
+            provider="COMPOSIO",
+            tool_name="TOOL_2",
+            arguments={"arg": "val2"},
+        )
+
+        # THEN each tool execution should return its respective result
+        assert result1["result"] == "first"
+        assert result2["result"] == "second"
+
+        # AND the API should have been called twice
+        assert mock_client.integrations.execute_integration_tool.call_count == 2

vellum/workflows/integrations/vellum_integration_service.py

@@ -0,0 +1,96 @@
+from typing import Any, Dict
+
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.vellum_client import create_vellum_client
+
+
+class VellumIntegrationService:
+    """Vellum Integration Service for retrieving tool definitions and executing tools.
+
+    This service uses the native Vellum client SDK to interact with Vellum's integration
+    endpoints, providing functionality similar to ComposioService but using Vellum's
+    own integration infrastructure.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the VellumIntegrationService with a Vellum client."""
+        self._client = create_vellum_client()
+
+    def get_tool_definition(
+        self,
+        integration: str,
+        provider: str,
+        tool_name: str,
+    ) -> Dict[str, Any]:
+        """Retrieve a tool definition from Vellum integrations.
+
+        Args:
+            integration: The integration name (e.g., "GITHUB", "SLACK")
+            provider: The integration provider name (e.g., "COMPOSIO")
+            tool_name: The tool's unique name as specified by the provider
+
+        Returns:
+            Dict containing the tool definition with name, description, and parameters
+
+        Raises:
+            NodeException: If the tool definition cannot be retrieved
+        """
+        try:
+            response = self._client.integrations.retrieve_integration_tool_definition(
+                integration=integration,
+                provider=provider,
+                tool_name=tool_name,
+            )
+
+            # Convert the response to a dict format matching what's expected
+            return {
+                "name": response.name,
+                "description": response.description,
+                "parameters": response.parameters,
+                "provider": response.provider,
+            }
+        except Exception as e:
+            error_message = f"Failed to retrieve tool definition for {tool_name}: {str(e)}"
+            raise NodeException(
+                message=error_message,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+            ) from e
+
+    def execute_tool(
+        self,
+        integration: str,
+        provider: str,
+        tool_name: str,
+        arguments: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Execute a tool through Vellum integrations.
+
+        Args:
+            integration: The integration name (e.g., "GITHUB", "SLACK")
+            provider: The integration provider name (e.g., "COMPOSIO")
+            tool_name: The tool's unique name as specified by the provider
+            arguments: Arguments to pass to the tool
+
+        Returns:
+            Dict containing the execution result data
+
+        Raises:
+            NodeException: If the tool execution fails
+        """
+        try:
+            response = self._client.integrations.execute_integration_tool(
+                integration=integration,
+                provider=provider,
+                tool_name=tool_name,
+                arguments=arguments,
+            )
+
+            # Return the data from the response
+            return response.data
+        except Exception as e:
+            error_message = f"Failed to execute tool {tool_name}: {str(e)}"
+            raise NodeException(
+                message=error_message,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+            ) from e

vellum/workflows/nodes/bases/base.py

@@ -439,6 +439,7 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
         *,
         state: Optional[StateType] = None,
         context: Optional[WorkflowContext] = None,
+        inputs: Optional[Dict[str, Any]] = None,
     ):
         if state:
             self.state = state
@@ -459,7 +460,27 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
             self.state = state_type()
 
         self._context = context or WorkflowContext()
-        inputs: Dict[str, Any] = {}
+        inputs_memo: Dict[str, Any] = inputs.copy() if inputs else {}
+        if inputs:
+            for input_key, input_value in inputs.items():
+                path_parts = input_key.split(".")
+                dir_path = path_parts[:-1]
+                leaf = path_parts[-1]
+                base: Any = self.__class__
+
+                for attr_name in dir_path:
+                    if hasattr(base, attr_name):
+                        base = getattr(base, attr_name)
+                    elif isinstance(base, dict) and attr_name in base:
+                        base = base[attr_name]
+                    else:
+                        break
+
+                if isinstance(base, dict):
+                    base[leaf] = input_value
+                else:
+                    setattr(base, leaf, input_value)
+
         for descriptor in self.__class__:
             if not descriptor.instance:
                 continue
@@ -468,12 +489,12 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
                 # We don't want to resolve attributes that are _meant_ to be descriptors
                 continue
 
-            resolved_value = resolve_value(descriptor.instance, self.state, path=descriptor.name, memo=inputs)
+            resolved_value = resolve_value(descriptor.instance, self.state, path=descriptor.name, memo=inputs_memo)
             setattr(self, descriptor.name, resolved_value)
 
         # We only want to store the attributes that were actually set as inputs, not every attribute that exists.
         all_inputs = {}
-        for key, value in inputs.items():
+        for key, value in inputs_memo.items():
             path_parts = key.split(".")
             node_attribute_descriptor = getattr(self.__class__, path_parts[0])
             inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -130,6 +130,11 @@ class InlineSubworkflowNode(
                 )
 
     def _compile_subworkflow_inputs(self) -> InputsType:
+        if self.subworkflow is None:
+            raise NodeException(
+                message="InlineSubworkflowNode requires a subworkflow to be defined",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
         inputs_class = self.subworkflow.get_inputs_class()
         try:
             if self.subworkflow_inputs is undefined:

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -57,6 +57,7 @@ from vellum.workflows.utils.functions import (
     compile_function_definition,
     compile_inline_workflow_function_definition,
     compile_mcp_tool_definition,
+    compile_vellum_integration_tool_definition,
     compile_workflow_deployment_function_definition,
     get_mcp_tool_name,
 )
@@ -151,11 +152,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 elif isinstance(function, ComposioToolDefinition):
                     normalized_functions.append(compile_composio_tool_definition(function))
                 elif isinstance(function, VellumIntegrationToolDefinition):
-                    # TODO: Implement compile_vellum_integration_tool_definition
-                    raise NotImplementedError(
-                        "VellumIntegrationToolDefinition support coming soon. "
-                        "This will be implemented when compile_vellum_integration_tool_definition is created."
-                    )
+                    normalized_functions.append(compile_vellum_integration_tool_definition(function))
                 elif isinstance(function, MCPServer):
                     tool_definitions = compile_mcp_tool_definition(function)
                     for tool_def in tool_definitions:

vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -21,6 +21,7 @@ from vellum.workflows.expressions.concat import ConcatExpression
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.integrations.composio_service import ComposioService
 from vellum.workflows.integrations.mcp_service import MCPService
+from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
@@ -263,6 +264,34 @@ class MCPNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         yield from []
 
 
+class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
+    """Node that executes a Vellum Integration tool with function call output."""
+
+    vellum_integration_tool: VellumIntegrationToolDefinition
+
+    def run(self) -> Iterator[BaseOutput]:
+        arguments = self._extract_function_arguments()
+
+        try:
+            vellum_service = VellumIntegrationService()
+            result = vellum_service.execute_tool(
+                integration=self.vellum_integration_tool.integration,
+                provider=self.vellum_integration_tool.provider.value,
+                tool_name=self.vellum_integration_tool.name,
+                arguments=arguments,
+            )
+        except Exception as e:
+            raise NodeException(
+                message=f"Error executing Vellum Integration tool '{self.vellum_integration_tool.name}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+        # Add result to chat history
+        self._add_function_result_to_chat_history(result, self.state)
+
+        yield from []
+
+
 class ElseNode(BaseNode[ToolCallingState]):
     """Node that executes when no function conditions match."""
 
@@ -465,11 +494,16 @@ def create_function_node(
         )
         return node
     elif isinstance(function, VellumIntegrationToolDefinition):
-        # TODO: Implement VellumIntegrationNode
-        raise NotImplementedError(
-            "VellumIntegrationToolDefinition support coming soon. "
-            "This will be implemented when the VellumIntegrationService is created."
+        node = type(
+            f"VellumIntegrationNode_{function.name}",
+            (VellumIntegrationNode,),
+            {
+                "vellum_integration_tool": function,
+                "function_call_output": tool_prompt_node.Outputs.results,
+                "__module__": __name__,
+            },
         )
+        return node
     elif is_workflow_class(function):
         function.is_dynamic = True
         node = type(