vellum-ai 1.5.1__tar.gz → 1.5.2__tar.gz

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.5.1
+Version: 1.5.2
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/ee/vellum_ee/assets/node-definitions.json

@@ -407,6 +407,51 @@
         }
       ]
     },
+    {
+      "id": "527a10bc-30b2-4e36-91d6-91c8e865bac8",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to map over a list of items and execute a Subworkflow on each iteration.\n\n    items: List[MapNodeItemType] - The items to map over\n    max_concurrency: Optional[int] = None - The maximum number of concurrent subworkflow executions\n    subworkflow: Type[\"BaseWorkflow\"] - The Subworkflow to execute\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseAdornmentNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base_adornment_node"
+        ]
+      },
+      "definition": {
+        "name": "MapNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "core",
+          "map_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "3a702aac-7b68-47d3-92e1-264883e9532c",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "0ae85239-a159-48af-b39c-2484eac901df",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
     {
       "id": "7426f273-a43d-4448-a2d2-76d0ee0d069c",
       "display_data": {
@@ -809,25 +854,21 @@
     }
   ],
   "errors": [
-    {
-      "node": "MapNode",
-      "error": "Expected NodeReference items to have an instance"
-    },
     {
       "node": "SubworkflowDeploymentNode",
-      "error": "headers: {'server': 'gunicorn', 'date': 'Tue, 23 Sep 2025 21:40:16 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '58', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Authentication credentials were not provided.'}"
+      "error": "ApiError: headers: {'server': 'gunicorn', 'date': 'Wed, 24 Sep 2025 04:58:53 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '58', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Authentication credentials were not provided.'}"
     },
     {
       "node": "PromptDeploymentNode",
-      "error": "headers: {'server': 'gunicorn', 'date': 'Tue, 23 Sep 2025 21:40:16 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '58', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Authentication credentials were not provided.'}"
+      "error": "ApiError: headers: {'server': 'gunicorn', 'date': 'Wed, 24 Sep 2025 04:58:53 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '58', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Authentication credentials were not provided.'}"
     },
     {
       "node": "SearchNode",
-      "error": "Expected NodeReference query to have an instance"
+      "error": "ValueError: Expected NodeReference query to have an instance"
     },
     {
       "node": "TemplatingNode",
-      "error": "TemplatingNode.Outputs.result"
+      "error": "KeyError: TemplatingNode.Outputs.result"
     }
   ]
 }

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/ee/vellum_ee/scripts/generate_node_definitions.py

@@ -70,7 +70,7 @@ def main() -> None:
                 display_instance = display_class()
                 display_instance.serialize(display_context)
             except Exception as e:
-                errors.append({"node": node_class.__name__, "error": str(e)})
+                errors.append({"node": node_class.__name__, "error": f"{e.__class__.__name__}: {str(e)}"})
 
     result = {"nodes": successful_nodes, "errors": errors}
 

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/ee/vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -1,7 +1,8 @@
 from uuid import UUID
-from typing import Generic, Optional, TypeVar, cast
+from typing import Generic, Optional, Type, TypeVar, cast
 
 from vellum.workflows.nodes import MapNode
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -22,12 +23,19 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
         node = self._node
         node_id = self.node_id
 
-        subworkflow = cast(type[BaseWorkflow], raise_if_descriptor(node.subworkflow))
+        subworkflow_value = raise_if_descriptor(node.subworkflow)
+        subworkflow = (
+            cast(type[BaseWorkflow], subworkflow_value)
+            if subworkflow_value is not None
+            else self._default_workflow_class()
+        )
+
+        items = raise_if_descriptor(node.items)
 
         items_node_input = create_node_input(
             node_id=node_id,
             input_name="items",
-            value=node.items,
+            value=items or [],
             display_context=display_context,
             input_id=self.node_input_ids_by_name.get("items"),
         )
@@ -81,3 +89,9 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
             },
             **self.serialize_generic_fields(display_context),
         }
+
+    def _default_workflow_class(self) -> Type[BaseWorkflow]:
+        class MapNodeSubworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+            pass
+
+        return MapNodeSubworkflow

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.5.1"
+version = "1.5.2"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.5.1",
+            "User-Agent": "vellum-ai/1.5.2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.5.1",
+            "X-Fern-SDK-Version": "1.5.2",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum_ai-1.5.2/src/vellum/workflows/integrations/tests/test_vellum_integration_service.py

@@ -0,0 +1,206 @@
+import pytest
+from unittest import mock
+
+from vellum.workflows.constants import VellumIntegrationProviderType
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
+from vellum.workflows.types.definition import VellumIntegrationToolDetails
+
+
+def test_vellum_integration_service_get_tool_definition_success(vellum_client):
+    """Test that tool definitions are successfully retrieved from Vellum API"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    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(client=mock_client)
+    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 isinstance(result, VellumIntegrationToolDetails)
+    assert result.name == "GITHUB_CREATE_AN_ISSUE"
+    assert result.description == "Create a new issue in a GitHub repository"
+    assert result.provider == VellumIntegrationProviderType.COMPOSIO
+    # Parameters should now be included in the tool details
+    assert result.parameters is not None
+    assert result.parameters["type"] == "object"
+    assert "properties" in result.parameters
+    assert "repo" in result.parameters["properties"]
+    assert "title" 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(vellum_client):
+    """Test that API errors are properly handled when retrieving tool definitions"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+    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(client=mock_client)
+
+    # 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(vellum_client):
+    """Test that tools are successfully executed via Vellum API"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    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(client=mock_client)
+    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(vellum_client):
+    """Test that execution errors are properly handled"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+    mock_client.integrations.execute_integration_tool.side_effect = Exception("Authentication failed")
+
+    # WHEN we attempt to execute a tool that encounters an error
+    service = VellumIntegrationService(client=mock_client)
+
+    # 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(vellum_client):
+    """Test that empty response data is handled gracefully"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    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(client=mock_client)
+    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(vellum_client):
+    """Test that the service handles multiple sequential tool executions"""
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    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(client=mock_client)
+
+    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_ai-1.5.1 → vellum_ai-1.5.2}/src/vellum/workflows/integrations/vellum_integration_service.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
+from vellum.workflows.constants import VellumIntegrationProviderType
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.types.definition import VellumIntegrationToolDetails
 from vellum.workflows.vellum_client import create_vellum_client
 
 
@@ -13,16 +15,16 @@ class VellumIntegrationService:
     own integration infrastructure.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, client: Optional[Any] = None) -> None:
         """Initialize the VellumIntegrationService with a Vellum client."""
-        self._client = create_vellum_client()
+        self._client = client or create_vellum_client()
 
     def get_tool_definition(
         self,
         integration: str,
         provider: str,
         tool_name: str,
-    ) -> Dict[str, Any]:
+    ) -> VellumIntegrationToolDetails:
         """Retrieve a tool definition from Vellum integrations.
 
         Args:
@@ -31,7 +33,7 @@ class VellumIntegrationService:
             tool_name: The tool's unique name as specified by the provider
 
         Returns:
-            Dict containing the tool definition with name, description, and parameters
+            VellumIntegrationToolDetails containing the tool definition with parameters
 
         Raises:
             NodeException: If the tool definition cannot be retrieved
@@ -43,13 +45,13 @@ class VellumIntegrationService:
                 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,
-            }
+            return VellumIntegrationToolDetails(
+                provider=VellumIntegrationProviderType(response.provider),
+                integration=integration,
+                name=response.name,
+                description=response.description,
+                parameters=response.parameters,
+            )
         except Exception as e:
             error_message = f"Failed to retrieve tool definition for {tool_name}: {str(e)}"
             raise NodeException(

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/src/vellum/workflows/types/definition.py

@@ -177,6 +177,17 @@ class VellumIntegrationToolDefinition(UniversalBaseModel):
     description: str
 
 
+class VellumIntegrationToolDetails(VellumIntegrationToolDefinition):
+    """Extended version of VellumIntegrationToolDefinition with runtime parameters.
+
+    This class includes the parameters field which is populated during compilation
+    from the Vellum integrations API response. It inherits all fields from the base
+    VellumIntegrationToolDefinition class.
+    """
+
+    parameters: Optional[Dict[str, Any]] = None
+
+
 class MCPServer(UniversalBaseModel):
     type: Literal["MCP_SERVER"] = "MCP_SERVER"
     name: str

{vellum_ai-1.5.1 → vellum_ai-1.5.2}/src/vellum/workflows/utils/functions.py

@@ -335,13 +335,15 @@ def compile_vellum_integration_tool_definition(tool_def: VellumIntegrationToolDe
     try:
         service = VellumIntegrationService()
         tool_details = service.get_tool_definition(
-            integration=tool_def.integration, provider=tool_def.provider.value, tool_name=tool_def.name
+            integration=tool_def.integration,
+            provider=tool_def.provider.value,
+            tool_name=tool_def.name,
         )
 
         return FunctionDefinition(
             name=tool_def.name,
-            description=tool_details.get("description", tool_def.description),
-            parameters=tool_details.get("parameters", {}),
+            description=tool_details.description,
+            parameters=tool_details.parameters or {},
         )
     except Exception:
         # Fallback for service failures