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

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/workflows/integrations/tests/test_vellum_integration_service.py

@@ -1,225 +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():
+def test_vellum_integration_service_get_tool_definition_success(vellum_client):
     """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",
-        )
+    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")
 
-        # 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"]
+    # WHEN we attempt to get a tool definition for an invalid tool
+    service = VellumIntegrationService(client=mock_client)
 
-        # AND the API should have been called with the correct parameters
-        mock_client.integrations.retrieve_integration_tool_definition.assert_called_once_with(
+    # 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="GITHUB_CREATE_AN_ISSUE",
+            tool_name="INVALID_TOOL",
         )
 
-
-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)
+    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():
+def test_vellum_integration_service_execute_tool_success(vellum_client):
     """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",
-            },
-        )
+    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")
 
-        # 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"
+    # WHEN we attempt to execute a tool that encounters an error
+    service = VellumIntegrationService(client=mock_client)
 
-        # AND the API should have been called with correct parameters
-        mock_client.integrations.execute_integration_tool.assert_called_once_with(
+    # 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",
-                "title": "Test Issue",
-                "body": "Test body",
-            },
+            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_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():
+def test_vellum_integration_service_execute_tool_empty_response(vellum_client):
     """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!",
-            },
-        )
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
 
-        # THEN an empty dictionary should be returned without errors
-        assert result == {}
+    mock_response = mock.MagicMock()
+    mock_response.data = {}
 
+    mock_client.integrations.execute_integration_tool.return_value = mock_response
 
-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"},
-        )
+    # 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!",
+        },
+    )
 
-        result2 = service.execute_tool(
-            integration="SLACK",
-            provider="COMPOSIO",
-            tool_name="TOOL_2",
-            arguments={"arg": "val2"},
-        )
+    # THEN an empty dictionary should be returned without errors
+    assert result == {}
 
-        # 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
+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/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/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/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

{vellum_ai-1.5.1.dist-info → vellum_ai-1.5.2.dist-info}/METADATA

@@ -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.dist-info → vellum_ai-1.5.2.dist-info}/RECORD

@@ -22,9 +22,9 @@ vellum_cli/tests/test_ping.py,sha256=b3aQLd-N59_8w2rRiWqwpB1rlHaKEYVbAj1Y3hi7A-g
 vellum_cli/tests/test_pull.py,sha256=e2XHzcHIx9k-FyuNAl7wMSNsSSebPGyP6U05JGcddFs,49447
 vellum_cli/tests/test_push.py,sha256=2MjkNKr_9Guv5Exjsm3L1BeVXmPkKUcCSiKnp90HgW4,41996
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum_ee/assets/node-definitions.json,sha256=Sn4fy0oUUCd_mj7vRNvQI5XR88A7-HKbe9pWaVnbz28,24293
+vellum_ee/assets/node-definitions.json,sha256=UDx8gBZ4Vj853aY7CSHR8JipVjZSQiKdkOKwKqwwVKw,25499
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum_ee/scripts/generate_node_definitions.py,sha256=1pVf2EA3LeX4kLKC2hSanyk2ZZDGVZ_lb83TE416XP8,3274
+vellum_ee/scripts/generate_node_definitions.py,sha256=FOYQsXIqU45I0OAcsyZUGODF9JK44yunf58rR6YaAdA,3303
 vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/base.py,sha256=R3f2T8FlZrXn2FawAmpVuLB3fKFWw11mCUulWAyIKA0,1912
@@ -48,7 +48,7 @@ vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=z4oeTgKnMGV
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=9_AslWjzj4RHH2sq3SIaq9FU0NCg7ex5TIWrNMybqXg,2173
 vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=muyLv3KMIsUnnXhiPbPhw5B0TO1Z8LUwytpVQKlz4tM,11906
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=m20_ZZ3Au0ZCpI3TNC9xh54ld1X13CNq-T51VOtP23k,6434
-vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=kwLqptup7bzYUDkGDbpcJPMMusMezsYrG5rSUYl5TlQ,3750
+vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=AW5JuHXtmtcJKeRiZKd7iB1re_D7G7jl_OlaZs8nUl0,4219
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=xMHaPfTSZWYprQenlHm2g47u0a5O9Me_dhAjfqo8nKQ,3116
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=6PcAFA_EJn7vEMdqgoRjYTLHwnXCrJv80B10zuUx4jE,1026
 vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=uo4YZRV48iX4peGAA1xkGniSPrepywvW_gS7codt-VQ,3378
@@ -158,7 +158,7 @@ vellum/client/README.md,sha256=flqu57ubZNTfpq60CdLtJC9gp4WEkyjb_n_eZ4OYf9w,6497
 vellum/client/__init__.py,sha256=-dZaD_0KtlkpQ-pULNNWcarC5xXlGMcGc2nBKLIyRlA,73661
 vellum/client/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 vellum/client/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-vellum/client/core/client_wrapper.py,sha256=HGgXu4osF39E2IYXXZKqZ_UBngm-WseBYRAmezfoveA,2840
+vellum/client/core/client_wrapper.py,sha256=dgP8KuamHuhB9q-zUV2SOGwlGkksYCbOSO1zmJRGB7A,2840
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/force_multipart.py,sha256=awxh5MtcRYe74ehY8U76jzv6fYM_w_D3Rur7KQQzSDk,429
@@ -1824,8 +1824,8 @@ vellum/workflows/integrations/composio_service.py,sha256=rSliaZtNiBcDSvDxz9k5i1K
 vellum/workflows/integrations/mcp_service.py,sha256=9DYb8dg2_kgc1UOu830kxhaFlt9yTbhKPhK3L6kb1t4,9831
 vellum/workflows/integrations/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/integrations/tests/test_mcp_service.py,sha256=q_DYrDkIqI4sQBNgID4YdbM4e9tneLVWY8YmI4R26d8,8859
-vellum/workflows/integrations/tests/test_vellum_integration_service.py,sha256=5Cw9fqw2DfIlD1h9xjso2WdocyhELVG8RMpMttUiqQ4,8903
-vellum/workflows/integrations/vellum_integration_service.py,sha256=0pD__eFjhKpmkF110tW2L6btr9CCUOKHMo5mBU7Ykrs,3405
+vellum/workflows/integrations/tests/test_vellum_integration_service.py,sha256=qGDV1Tx3cWoaazjfnkv8MutLYscwvSZazRqtnz3EPhY,7607
+vellum/workflows/integrations/vellum_integration_service.py,sha256=AzF2QkEcLspTV5rySA2GToirNpMmTiY07OZx-6Vq3IA,3625
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=zymtc3_iW2rFmMR-sayTLuN6ZsAw8VnJweWPsjQk2-Q,1197
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
@@ -1985,7 +1985,7 @@ vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83y
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
 vellum/workflows/types/code_execution_node_wrappers.py,sha256=fewX9bqF_4TZuK-gZYIn12s31-k03vHMGRpvFAPm11Y,3206
 vellum/workflows/types/core.py,sha256=yKm3sE02ult969q80DTmawiwYqodVjcAW-zlaUIgIv4,1495
-vellum/workflows/types/definition.py,sha256=rVoiXhj7xcQS793qjt2gdv64ywfQrRvujURjIWeC6gA,7240
+vellum/workflows/types/definition.py,sha256=_wzpa0CtS60IIEPfhrLXmj2y9datz5XqJZhLYpml-NI,7663
 vellum/workflows/types/generics.py,sha256=8jptbEx1fnJV0Lhj0MpCJOT6yNiEWeTOYOwrEAb5CRU,1576
 vellum/workflows/types/stack.py,sha256=h7NE0vXR7l9DevFBIzIAk1Zh59K-kECQtDTKOUunwMY,1314
 vellum/workflows/types/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1993,7 +1993,7 @@ vellum/workflows/types/tests/test_definition.py,sha256=rvDYjdJ1rvAv0qHBN7i7s-_WA
 vellum/workflows/types/tests/test_utils.py,sha256=UnZog59tR577mVwqZRqqWn2fScoOU1H6up0EzS8zYhw,2536
 vellum/workflows/types/utils.py,sha256=mTctHITBybpt4855x32oCKALBEcMNLn-9cCmfEKgJHQ,6498
 vellum/workflows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/functions.py,sha256=9KqkCOpuTEncjAxGHfcMGIsrD8-yFQp8NgzvU3w5Rd8,13066
+vellum/workflows/utils/functions.py,sha256=_esuDTYKEORjBoC0YGT3ANO--OswaKu6s-_42_kzlwU,13057
 vellum/workflows/utils/hmac.py,sha256=JJCczc6pyV6DuE1Oa0QVfYPUN_of3zEYmGFib3OZnrE,1135
 vellum/workflows/utils/names.py,sha256=QtHquoaGqRseu5gg2OcVGI2d_CMcEOvjb9KspwH4C-A,552
 vellum/workflows/utils/pydantic_schema.py,sha256=eR_bBtY-T0pttJP-ARwagSdCOnwPUtiT3cegm2lzDTQ,1310
@@ -2012,8 +2012,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=Boa-_m9ii2Qsa1RvVM-VYniF7zCpzGgEGy-OnPZkrHg,23941
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.5.1.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.5.1.dist-info/METADATA,sha256=Ptz4NIBFWJ5foDFhe-2vq_L8oNt9HKbtTxgf0qN_Ei4,5547
-vellum_ai-1.5.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.5.1.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
-vellum_ai-1.5.1.dist-info/RECORD,,
+vellum_ai-1.5.2.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.5.2.dist-info/METADATA,sha256=-qDjvOuDnllUtWah1AMWM9bItegRKH7bZAY9mDwyIQQ,5547
+vellum_ai-1.5.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.5.2.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
+vellum_ai-1.5.2.dist-info/RECORD,,

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_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_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