vellum-ai 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

vellum/client/core/client_wrapper.py

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

vellum/client/resources/workflows/client.py

@@ -27,6 +27,7 @@ class WorkflowsClient:
         id: str,
         *,
         exclude_code: typing.Optional[bool] = None,
+        exclude_display: typing.Optional[bool] = None,
         include_json: typing.Optional[bool] = None,
         include_sandbox: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
@@ -40,6 +41,8 @@ class WorkflowsClient:
 
         exclude_code : typing.Optional[bool]
 
+        exclude_display : typing.Optional[bool]
+
         include_json : typing.Optional[bool]
 
         include_sandbox : typing.Optional[bool]
@@ -60,6 +63,7 @@ class WorkflowsClient:
             method="GET",
             params={
                 "exclude_code": exclude_code,
+                "exclude_display": exclude_display,
                 "include_json": include_json,
                 "include_sandbox": include_sandbox,
                 "strict": strict,
@@ -165,6 +169,7 @@ class AsyncWorkflowsClient:
         id: str,
         *,
         exclude_code: typing.Optional[bool] = None,
+        exclude_display: typing.Optional[bool] = None,
         include_json: typing.Optional[bool] = None,
         include_sandbox: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
@@ -178,6 +183,8 @@ class AsyncWorkflowsClient:
 
         exclude_code : typing.Optional[bool]
 
+        exclude_display : typing.Optional[bool]
+
         include_json : typing.Optional[bool]
 
         include_sandbox : typing.Optional[bool]
@@ -198,6 +205,7 @@ class AsyncWorkflowsClient:
             method="GET",
             params={
                 "exclude_code": exclude_code,
+                "exclude_display": exclude_display,
                 "include_json": include_json,
                 "include_sandbox": include_sandbox,
                 "strict": strict,

vellum/client/types/document_document_to_document_index.py

@@ -22,7 +22,7 @@ class DocumentDocumentToDocumentIndex(UniversalBaseModel):
     Vellum-generated ID that uniquely identifies the environment index this document is included in.
     """
 
-    document_index_id: str = pydantic.Field()
+    document_index_id: typing.Optional[str] = pydantic.Field(default=None)
     """
     Vellum-generated ID that uniquely identifies the index this document is included in.
     """

vellum/client/types/organization_read.py

@@ -2,6 +2,7 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing
+import datetime as dt
 from .new_member_join_behavior_enum import NewMemberJoinBehaviorEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
@@ -10,6 +11,7 @@ import pydantic
 class OrganizationRead(UniversalBaseModel):
     id: str
     name: str
+    created: typing.Optional[dt.datetime] = None
     allow_staff_access: typing.Optional[bool] = None
     new_member_join_behavior: NewMemberJoinBehaviorEnum
     limit_config: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None

vellum/client/types/slim_document_document_to_document_index.py

@@ -22,7 +22,7 @@ class SlimDocumentDocumentToDocumentIndex(UniversalBaseModel):
     Vellum-generated ID that uniquely identifies the environment index this document is included in.
     """
 
-    document_index_id: str = pydantic.Field()
+    document_index_id: typing.Optional[str] = pydantic.Field(default=None)
     """
     Vellum-generated ID that uniquely identifies the index this document is included in.
     """

vellum/plugins/pydantic.py

@@ -28,9 +28,12 @@ def import_base_descriptor():
     """
     We have to avoid importing from vellum.* in this file because it will cause a circular import.
     """
-    from vellum.workflows.descriptors.base import BaseDescriptor
+    try:
+        from vellum.workflows.descriptors.base import BaseDescriptor
 
-    return BaseDescriptor
+        return BaseDescriptor
+    except Exception:
+        return None
 
 
 # https://docs.pydantic.dev/2.8/concepts/plugins/#build-a-plugin
@@ -60,6 +63,10 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
         self.tracked_descriptors = {}
         BaseDescriptor = import_base_descriptor()
 
+        # If BaseDescriptor import failed, skip descriptor processing
+        if BaseDescriptor is None:
+            return
+
         for key, value in input.items():
             field_info = model_fields.get(key)
             if isinstance(value, BaseDescriptor) and (

vellum/workflows/emitters/__init__.py

@@ -1,5 +1,7 @@
 from .base import BaseWorkflowEmitter
+from .vellum_emitter import VellumEmitter
 
 __all__ = [
     "BaseWorkflowEmitter",
+    "VellumEmitter",
 ]

vellum/workflows/emitters/base.py

@@ -1,10 +1,27 @@
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional
 
 from vellum.workflows.events.workflow import WorkflowEvent
 from vellum.workflows.state.base import BaseState
 
+# To protect against circular imports
+if TYPE_CHECKING:
+    from vellum.workflows.state.context import WorkflowContext
+
 
 class BaseWorkflowEmitter(ABC):
+    def __init__(self):
+        self._context: Optional["WorkflowContext"] = None
+
+    def register_context(self, context: "WorkflowContext") -> None:
+        """
+        Register the workflow context with this emitter.
+
+        Args:
+            context: The workflow context containing shared resources like vellum_client.
+        """
+        self._context = context
+
     @abstractmethod
     def emit_event(self, event: WorkflowEvent) -> None:
         pass

vellum/workflows/emitters/vellum_emitter.py

@@ -0,0 +1,138 @@
+import logging
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+
+from vellum.workflows.emitters.base import BaseWorkflowEmitter
+from vellum.workflows.events.types import default_serializer
+from vellum.workflows.events.workflow import WorkflowEvent
+from vellum.workflows.state.base import BaseState
+
+logger = logging.getLogger(__name__)
+
+
+class VellumEmitter(BaseWorkflowEmitter):
+    """
+    Emitter that sends workflow events to Vellum's infrastructure for monitoring
+    externally hosted SDK-powered workflows.
+
+    Usage:
+        class MyWorkflow(BaseWorkflow):
+            emitters = [VellumEmitter]
+
+    The emitter will automatically use the same Vellum client configuration
+    as the workflow it's attached to.
+    """
+
+    def __init__(
+        self,
+        *,
+        timeout: Optional[float] = 30.0,
+        max_retries: int = 3,
+    ):
+        """
+        Initialize the VellumEmitter.
+
+        Args:
+            timeout: Request timeout in seconds.
+            max_retries: Maximum number of retry attempts for failed requests.
+        """
+        super().__init__()
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._events_endpoint = "events"  # TODO: make this configurable with the correct url
+
+    def emit_event(self, event: WorkflowEvent) -> None:
+        """
+        Emit a workflow event to Vellum's infrastructure.
+
+        Args:
+            event: The workflow event to emit.
+        """
+        if not self._context:
+            return
+
+        try:
+            event_data = default_serializer(event)
+
+            self._send_event(event_data)
+
+        except Exception as e:
+            logger.exception(f"Failed to emit event {event.name}: {e}")
+
+    def snapshot_state(self, state: BaseState) -> None:
+        """
+        Send a state snapshot to Vellum's infrastructure.
+
+        Args:
+            state: The workflow state to snapshot.
+        """
+        pass
+
+    def _send_event(self, event_data: Dict[str, Any]) -> None:
+        """
+        Send event data to Vellum's events endpoint with retry logic.
+
+        Args:
+            event_data: The serialized event data to send.
+        """
+        if not self._context:
+            logger.warning("Cannot send event: No workflow context registered")
+            return
+
+        client = self._context.vellum_client
+
+        for attempt in range(self._max_retries + 1):
+            try:
+                # Use the Vellum client's underlying HTTP client to make the request
+                # For proper authentication headers and configuration
+                base_url = client._client_wrapper.get_environment().default
+                response = client._client_wrapper.httpx_client.request(
+                    method="POST",
+                    path=f"{base_url}/{self._events_endpoint}",  # TODO: will be replaced with the correct url
+                    json=event_data,
+                    headers=client._client_wrapper.get_headers(),
+                    request_options={"timeout_in_seconds": self._timeout},
+                )
+
+                response.raise_for_status()
+
+                if attempt > 0:
+                    logger.info(f"Event sent successfully after {attempt + 1} attempts")
+                return
+
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code >= 500:
+                    # Server errors might be transient, retry
+                    if attempt < self._max_retries:
+                        wait_time = min(2**attempt, 60)  # Exponential backoff, max 60s
+                        logger.warning(
+                            f"Server error emitting event (attempt {attempt + 1}/{self._max_retries + 1}): "
+                            f"{e.response.status_code}. Retrying in {wait_time}s..."
+                        )
+                        time.sleep(wait_time)
+                        continue
+                    else:
+                        logger.exception(
+                            f"Server error emitting event after {self._max_retries + 1} attempts: "
+                            f"{e.response.status_code} {e.response.text}"
+                        )
+                        return
+                else:
+                    # Client errors (4xx) are not retriable
+                    logger.exception(f"Client error emitting event: {e.response.status_code} {e.response.text}")
+                    return
+
+            except httpx.RequestError as e:
+                if attempt < self._max_retries:
+                    wait_time = min(2**attempt, 60)  # Exponential backoff, max 60s
+                    logger.warning(
+                        f"Network error emitting event (attempt {attempt + 1}/{self._max_retries + 1}): "
+                        f"{e}. Retrying in {wait_time}s..."
+                    )
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    logger.exception(f"Network error emitting event after {self._max_retries + 1} attempts: {e}")
+                    return

vellum/workflows/integrations/composio_service.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional
 
 import requests
 
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 
 logger = logging.getLogger(__name__)
@@ -72,6 +73,17 @@ class ComposioService:
 
             response.raise_for_status()
             return response.json()
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 401:
+                raise NodeException(
+                    message="Failed to authorize Composio request. Make sure to define a COMPOSIO_API_KEY",
+                    code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+                )
+            else:
+                response_text = e.response.text if e.response else "No response"
+                raise NodeException(
+                    f"Composio API request failed with status {e.response.status_code}: {response_text}"
+                )
         except Exception as e:
             raise NodeException(f"Composio API request failed: {e}")
 
@@ -123,16 +135,20 @@ class ComposioService:
             else:
                 raise NodeException(f"Failed to retrieve tool details for '{tool_slug}': {error_message}")
 
-    def execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+    def execute_tool(self, tool_name: str, arguments: Dict[str, Any], user_id: Optional[str] = None) -> Any:
         """Execute a tool using direct API request
 
         Args:
             tool_name: The name of the tool to execute (e.g., "HACKERNEWS_GET_USER")
             arguments: Dictionary of arguments to pass to the tool
+            user_id: Optional user ID to identify which user's Composio connection to use
 
         Returns:
             The result of the tool execution
         """
         endpoint = f"/tools/execute/{tool_name}"
-        response = self._make_request(endpoint, method="POST", json_data={"arguments": arguments})
+        json_data: Dict[str, Any] = {"arguments": arguments}
+        if user_id is not None:
+            json_data["user_id"] = user_id
+        response = self._make_request(endpoint, method="POST", json_data=json_data)
         return response.get("data", response)

vellum/workflows/integrations/mcp_service.py

@@ -0,0 +1,245 @@
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.types.core import VellumSecret
+from vellum.workflows.types.definition import MCPServer, MCPToolDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class MCPHttpClient:
+    """
+    Direct HTTP implementation for MCP (Model Context Protocol) client
+    without using the official Python SDK.
+
+    Supports Streamable HTTP transport using httpx.
+    """
+
+    def __init__(self, server_url: str, headers: Dict[str, str], session_timeout: int = 30):
+        """
+        Initialize MCP HTTP client.
+
+        Args:
+            server_url: The MCP server endpoint URL (e.g., "https://example.com/mcp")
+            headers: Authentication headers
+            session_timeout: Timeout for HTTP requests in seconds
+        """
+        self.server_url = server_url.rstrip("/")
+        self.headers = headers
+        self.session_timeout = session_timeout
+        self.session_id: Optional[str] = None
+        self.request_id = 0
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        self._client = httpx.AsyncClient(timeout=httpx.Timeout(self.session_timeout), headers=self.headers)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        if self._client:
+            await self._client.aclose()
+
+    def _next_request_id(self) -> int:
+        """Generate next request ID."""
+        self.request_id += 1
+        return self.request_id
+
+    async def _send_request(self, method: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Send a JSON-RPC request to the MCP server.
+
+        Args:
+            method: The JSON-RPC method name
+            params: Optional parameters for the method
+
+        Returns:
+            The JSON-RPC response
+        """
+        if not self._client:
+            raise RuntimeError("Client session not initialized. Use 'async with' context manager.")
+
+        # Prepare JSON-RPC request
+        request_data = {"jsonrpc": "2.0", "id": self._next_request_id(), "method": method, "params": params or {}}
+
+        # Prepare headers
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        # Include session ID if we have one
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+
+        logger.debug(f"Sending request: {json.dumps(request_data, indent=2)}")
+
+        # Send POST request
+        response = await self._client.post(self.server_url, json=request_data, headers=headers)
+
+        # Check for session ID in response headers
+        if "Mcp-Session-Id" in response.headers:
+            self.session_id = response.headers["Mcp-Session-Id"]
+            logger.debug(f"Received session ID: {self.session_id}")
+
+        # Handle JSON response
+        response_data = response.json()
+        logger.debug(f"Received response: {json.dumps(response_data, indent=2)}")
+
+        if "error" in response_data:
+            raise Exception(f"MCP Error: {response_data['error']}")
+
+        return response_data
+
+    async def initialize(self, client_info: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Initialize the MCP connection.
+
+        Args:
+            client_info: Optional client information
+
+        Returns:
+            Server capabilities and information
+        """
+        params = {
+            "protocolVersion": "2025-06-18",
+            "capabilities": {},
+            "clientInfo": client_info or {"name": "vellum-mcp-client", "version": "1.0.0"},
+        }
+
+        response = await self._send_request("initialize", params)
+        return response.get("result", {})
+
+    async def list_tools(self) -> List[Dict[str, Any]]:
+        """
+        Get list of available tools from the server.
+
+        Returns:
+            List of tool definitions
+        """
+        response = await self._send_request("tools/list")
+        return response.get("result", {}).get("tools", [])
+
+    async def call_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Call a tool on the server.
+
+        Args:
+            name: Tool name
+            arguments: Tool arguments
+
+        Returns:
+            Tool execution result
+        """
+        params = {"name": name, "arguments": arguments}
+
+        response = await self._send_request("tools/call", params)
+        return response.get("result", {})
+
+
+class MCPService:
+    def _get_auth_headers(self, server: MCPServer) -> Dict[str, str]:
+        headers = {}
+        if server.authorization_type == AuthorizationType.BEARER_TOKEN:
+            token = server.bearer_token_value
+            if not token:
+                raise NodeException(
+                    "Bearer token is required for BEARER_TOKEN authorization type",
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
+            headers["Authorization"] = f"Bearer {token}"
+
+        elif server.authorization_type == AuthorizationType.API_KEY:
+            key = server.api_key_header_key
+            value = server.api_key_header_value
+            if not key or not value:
+                raise NodeException(
+                    "API key header key and value are required for API_KEY authorization type",
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+            if isinstance(value, VellumSecret):
+                headers[key] = value.name
+            elif isinstance(value, str):
+                headers[key] = value
+
+        return headers
+
+    async def _execute_mcp_call(self, server: MCPServer, operation: str, **kwargs) -> Any:
+        """Execute an MCP operation using direct HTTP calls."""
+        headers = self._get_auth_headers(server)
+
+        try:
+            async with MCPHttpClient(server.url, headers) as client:
+                await client.initialize()
+
+                if operation == "list_tools":
+                    return await client.list_tools()
+                elif operation == "call_tool":
+                    return await client.call_tool(
+                        name=kwargs["name"],
+                        arguments=kwargs["arguments"],
+                    )
+                else:
+                    raise ValueError(f"Unknown MCP operation: {operation}")
+
+        except Exception as e:
+            logger.error(f"Error executing MCP operation {operation}: {e}")
+            raise NodeException(
+                message=f"Error executing MCP operation '{operation}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+    def list_tools(self, server: MCPServer) -> List[Dict[str, Any]]:
+        """List available tools from an MCP server."""
+        try:
+            tools = asyncio.run(self._execute_mcp_call(server, "list_tools"))
+            return tools
+        except Exception as e:
+            logger.warning(f"Failed to list tools from MCP server '{server.name}': {e}")
+            return []
+
+    def execute_tool(self, tool_def: MCPToolDefinition, arguments: Dict[str, Any]) -> Any:
+        """Execute a tool on an MCP server."""
+        try:
+            result = asyncio.run(
+                self._execute_mcp_call(
+                    tool_def.server,
+                    "call_tool",
+                    name=tool_def.name,
+                    arguments=arguments,
+                )
+            )
+            return result
+        except Exception as e:
+            logger.error(f"Error executing MCP tool '{tool_def.name}': {e}")
+            raise NodeException(
+                message=f"Error executing MCP tool '{tool_def.name}': {str(e)}",
+                code=WorkflowErrorCode.NODE_EXECUTION,
+            )
+
+    def hydrate_tool_definitions(self, server_def: MCPServer) -> List[MCPToolDefinition]:
+        """Hydrate an MCPToolDefinition with detailed information from the MCP server."""
+        try:
+            tools = self.list_tools(server_def)
+
+            return [
+                MCPToolDefinition(
+                    name=tool["name"],
+                    server=server_def,
+                    description=tool["description"],
+                    parameters=tool["inputSchema"],
+                )
+                for tool in tools
+            ]
+        except Exception as e:
+            logger.warning(f"Failed to hydrate MCP server '{server_def.name}': {e}")
+            return []

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

@@ -1,4 +1,4 @@
-from typing import Any, ClassVar, Dict, Iterator, List, Optional, Set, Union
+from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union
 
 from vellum import ChatMessage, PromptBlock
 from vellum.client.types.prompt_parameters import PromptParameters
@@ -13,16 +13,21 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_function_node,
+    create_mcp_tool_node,
     create_tool_router_node,
     get_function_name,
+    get_mcp_tool_name,
+    hydrate_mcp_tool_definitions,
 )
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface, Tool
+from vellum.workflows.types.definition import MCPServer
+from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
-class ToolCallingNode(BaseNode):
+class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
     """
     A Node that dynamically invokes the provided functions to the underlying Prompt
 
@@ -141,12 +146,22 @@ class ToolCallingNode(BaseNode):
 
         self._function_nodes = {}
         for function in self.functions:
-            function_name = get_function_name(function)
-
-            self._function_nodes[function_name] = create_function_node(
-                function=function,
-                tool_router_node=self.tool_router_node,
-            )
+            if isinstance(function, MCPServer):
+                tool_definitions = hydrate_mcp_tool_definitions(function)
+                for tool_definition in tool_definitions:
+                    function_name = get_mcp_tool_name(tool_definition)
+
+                    self._function_nodes[function_name] = create_mcp_tool_node(
+                        tool_def=tool_definition,
+                        tool_router_node=self.tool_router_node,
+                    )
+            else:
+                function_name = get_function_name(function)
+
+                self._function_nodes[function_name] = create_function_node(
+                    function=function,
+                    tool_router_node=self.tool_router_node,
+                )
 
         graph_set = set()
 

vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py

@@ -125,3 +125,46 @@ class TestComposioCoreService:
             timeout=30,
         )
         assert result == {"items": [], "total": 0}
+
+    def test_execute_tool_with_user_id(self, composio_service, mock_requests, mock_tool_execution_response):
+        """Test executing a tool with user_id parameter"""
+        # GIVEN a user_id and tool arguments
+        user_id = "test_user_123"
+        tool_args = {"param1": "value1"}
+        mock_response = Mock()
+        mock_response.json.return_value = mock_tool_execution_response
+        mock_response.raise_for_status.return_value = None
+        mock_requests.post.return_value = mock_response
+
+        # WHEN we execute a tool with user_id
+        result = composio_service.execute_tool("TEST_TOOL", tool_args, user_id=user_id)
+
+        # THEN the user_id should be included in the request payload
+        mock_requests.post.assert_called_once_with(
+            "https://backend.composio.dev/api/v3/tools/execute/TEST_TOOL",
+            headers={"x-api-key": "test-key", "Content-Type": "application/json"},
+            json={"arguments": tool_args, "user_id": user_id},
+            timeout=30,
+        )
+        assert result == {"items": [], "total": 0}
+
+    def test_execute_tool_without_user_id(self, composio_service, mock_requests, mock_tool_execution_response):
+        """Test executing a tool without user_id parameter maintains backward compatibility"""
+        # GIVEN tool arguments without user_id
+        tool_args = {"param1": "value1"}
+        mock_response = Mock()
+        mock_response.json.return_value = mock_tool_execution_response
+        mock_response.raise_for_status.return_value = None
+        mock_requests.post.return_value = mock_response
+
+        # WHEN we execute a tool without user_id
+        result = composio_service.execute_tool("TEST_TOOL", tool_args)
+
+        # THEN the user_id should NOT be included in the request payload
+        mock_requests.post.assert_called_once_with(
+            "https://backend.composio.dev/api/v3/tools/execute/TEST_TOOL",
+            headers={"x-api-key": "test-key", "Content-Type": "application/json"},
+            json={"arguments": tool_args},
+            timeout=30,
+        )
+        assert result == {"items": [], "total": 0}

vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py

@@ -211,3 +211,25 @@ def test_tool_calling_node_with_user_provided_chat_history_block(vellum_adhoc_pr
     ]
     assert len(chat_history_inputs) == 1
     assert chat_history_inputs[0].value == [ChatMessage(role="USER", text="Hello from user")]
+
+
+def test_tool_calling_node_with_generic_type_parameter():
+    # GIVEN a custom state class
+    class State(BaseState):
+        pass
+
+    # AND a ToolCallingNode that uses the generic type parameter
+    class TestToolCallingNode(ToolCallingNode[State]):
+        ml_model = "gpt-4o-mini"
+        blocks = []
+        functions = [first_function]
+        max_prompt_iterations = 1
+
+    # WHEN we create an instance of the node
+    state = State()
+    node = TestToolCallingNode(state=state)
+
+    # THEN the node should be created successfully
+    assert node is not None
+    assert isinstance(node, TestToolCallingNode)
+    assert node.state == state

vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py

@@ -12,7 +12,11 @@ from vellum.prompts.constants import DEFAULT_PROMPT_PARAMETERS
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.displayable.tool_calling_node.utils import create_tool_router_node, get_function_name
+from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
+    create_tool_router_node,
+    get_function_name,
+    get_mcp_tool_name,
+)
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
@@ -77,9 +81,9 @@ def test_get_function_name_mcp_tool_definition():
         parameters={"repository_name": "string", "description": "string"},
     )
 
-    result = get_function_name(mcp_tool)
+    result = get_mcp_tool_name(mcp_tool)
 
-    assert result == "create_repository"
+    assert result == "github__create_repository"
 
 
 @pytest.mark.parametrize(
@@ -93,7 +97,7 @@ def test_get_function_name_composio_tool_definition_various_toolkits(
     toolkit: str, action: str, description: str, expected_result: str
 ):
     """Test ComposioToolDefinition function name generation with various toolkits."""
-    composio_tool = ComposioToolDefinition(toolkit=toolkit, action=action, description=description)
+    composio_tool = ComposioToolDefinition(toolkit=toolkit, action=action, description=description, user_id=None)
 
     result = get_function_name(composio_tool)
 

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

@@ -17,6 +17,7 @@ from vellum.workflows.exceptions import NodeException
 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.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
@@ -27,8 +28,8 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
-from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool
-from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPToolDefinition
+from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolBase
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 from vellum.workflows.types.generics import is_workflow_class
 
 CHAT_HISTORY_VARIABLE = "chat_history"
@@ -183,7 +184,12 @@ class ComposioNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         try:
             # Execute using ComposioService
             composio_service = ComposioService()
-            result = composio_service.execute_tool(tool_name=self.composio_tool.action, arguments=arguments)
+            if self.composio_tool.user_id is not None:
+                result = composio_service.execute_tool(
+                    tool_name=self.composio_tool.action, arguments=arguments, user_id=self.composio_tool.user_id
+                )
+            else:
+                result = composio_service.execute_tool(tool_name=self.composio_tool.action, arguments=arguments)
         except Exception as e:
             raise NodeException(
                 message=f"Error executing Composio tool '{self.composio_tool.action}': {str(e)}",
@@ -196,6 +202,29 @@ class ComposioNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         yield from []
 
 
+class MCPNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
+    """Node that executes an MCP tool with function call output."""
+
+    mcp_tool: MCPToolDefinition
+
+    def run(self) -> Iterator[BaseOutput]:
+        arguments = self._extract_function_arguments()
+
+        try:
+            mcp_service = MCPService()
+            result = mcp_service.execute_tool(tool_def=self.mcp_tool, arguments=arguments)
+        except Exception as e:
+            raise NodeException(
+                message=f"Error executing MCP tool '{self.mcp_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 []
+
+
 def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> ComposioToolDefinition:
     """Hydrate a ComposioToolDefinition with detailed information from the Composio API.
 
@@ -225,6 +254,7 @@ def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> Compo
             parameters=tool_details.get("input_parameters", tool_def.parameters),
             version=tool_details.get("version", tool_def.version),
             tags=tool_details.get("tags", tool_def.tags),
+            user_id=tool_def.user_id,
         )
 
     except Exception as e:
@@ -233,6 +263,26 @@ def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> Compo
         return tool_def
 
 
+def hydrate_mcp_tool_definitions(server_def: MCPServer) -> List[MCPToolDefinition]:
+    """Hydrate an MCPToolDefinition with detailed information from the MCP server.
+
+    We do tool discovery on the MCP server to get the tool definitions.
+
+    Args:
+        tool_def: The basic MCPToolDefinition to enhance
+
+    Returns:
+        MCPToolDefinition with detailed parameters and description
+    """
+    try:
+        mcp_service = MCPService()
+        return mcp_service.hydrate_tool_definitions(server_def)
+    except Exception as e:
+        # If hydration fails, log and return original
+        logger.warning(f"Failed to enhance MCP server '{server_def.name}': {e}")
+        return []
+
+
 def create_tool_router_node(
     ml_model: str,
     blocks: List[Union[PromptBlock, Dict[str, Any]]],
@@ -246,6 +296,19 @@ def create_tool_router_node(
         Ports = type("Ports", (), {})
         prompt_functions: List[Union[Tool, FunctionDefinition]] = []
 
+        # Avoid using lambda to capture function_name
+        # lambda will capture the function_name by reference,
+        # and if the function_name is changed, the port_condition will also change.
+        def create_port_condition(fn_name):
+            return Port.on_if(
+                LazyReference(
+                    lambda: (
+                        node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
+                        & node.Outputs.results[0]["value"]["name"].equals(fn_name)
+                    )
+                )
+            )
+
         for function in functions:
             if isinstance(function, ComposioToolDefinition):
                 # Get Composio tool details and hydrate the function definition
@@ -257,26 +320,28 @@ def create_tool_router_node(
                         parameters=enhanced_function.parameters,
                     )
                 )
+                # Create port for this function (using original function for get_function_name)
+                function_name = get_function_name(function)
+                port = create_port_condition(function_name)
+                setattr(Ports, function_name, port)
+            elif isinstance(function, MCPServer):
+                tool_functions: List[MCPToolDefinition] = hydrate_mcp_tool_definitions(function)
+                for tool_function in tool_functions:
+                    name = get_mcp_tool_name(tool_function)
+                    prompt_functions.append(
+                        FunctionDefinition(
+                            name=name,
+                            description=tool_function.description,
+                            parameters=tool_function.parameters,
+                        )
+                    )
+                    port = create_port_condition(name)
+                    setattr(Ports, name, port)
             else:
                 prompt_functions.append(function)
-
-            # Create port for this function (using original function for get_function_name)
-            function_name = get_function_name(function)
-
-            # Avoid using lambda to capture function_name
-            # lambda will capture the function_name by reference,
-            # and if the function_name is changed, the port_condition will also change.
-            def create_port_condition(fn_name):
-                return LazyReference(
-                    lambda: (
-                        node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
-                        & node.Outputs.results[0]["value"]["name"].equals(fn_name)
-                    )
-                )
-
-            port_condition = create_port_condition(function_name)
-            port = Port.on_if(port_condition)
-            setattr(Ports, function_name, port)
+                function_name = get_function_name(function)
+                port = create_port_condition(function_name)
+                setattr(Ports, function_name, port)
 
         # Add the else port for when no function conditions match
         setattr(Ports, "default", Port.on_else())
@@ -338,7 +403,7 @@ def create_tool_router_node(
 
 
 def create_function_node(
-    function: Tool,
+    function: ToolBase,
     tool_router_node: Type[ToolRouterNode],
 ) -> Type[BaseNode]:
     """
@@ -379,8 +444,6 @@ def create_function_node(
             },
         )
         return node
-    elif isinstance(function, MCPToolDefinition):
-        pass
     elif is_workflow_class(function):
         node = type(
             f"DynamicInlineSubworkflowNode_{function.__name__}",
@@ -406,13 +469,31 @@ def create_function_node(
     return node
 
 
-def get_function_name(function: Tool) -> str:
+def create_mcp_tool_node(
+    tool_def: MCPToolDefinition,
+    tool_router_node: Type[ToolRouterNode],
+) -> Type[BaseNode]:
+    node = type(
+        f"MCPNode_{tool_def.name}",
+        (MCPNode,),
+        {
+            "mcp_tool": tool_def,
+            "function_call_output": tool_router_node.Outputs.results,
+            "__module__": __name__,
+        },
+    )
+    return node
+
+
+def get_function_name(function: ToolBase) -> str:
     if isinstance(function, DeploymentDefinition):
         name = str(function.deployment_id or function.deployment_name)
         return name.replace("-", "")
     elif isinstance(function, ComposioToolDefinition):
         return function.name
-    elif isinstance(function, MCPToolDefinition):
-        return function.name
     else:
         return snake_case(function.__name__)
+
+
+def get_mcp_tool_name(tool_def: MCPToolDefinition) -> str:
+    return f"{tool_def.server.name}__{tool_def.name}"

vellum/workflows/types/core.py

@@ -13,7 +13,7 @@ from typing import (  # type: ignore[attr-defined]
 )
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
-from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPToolDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -41,6 +41,7 @@ class MergeBehavior(Enum):
     AWAIT_ALL = "AWAIT_ALL"
     AWAIT_ANY = "AWAIT_ANY"
     AWAIT_ATTRIBUTES = "AWAIT_ATTRIBUTES"
+    CUSTOM = "CUSTOM"
 
 
 class ConditionType(Enum):
@@ -50,4 +51,5 @@ class ConditionType(Enum):
 
 
 # Type alias for functions that can be called in tool calling nodes
-Tool = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition, MCPToolDefinition]
+ToolBase = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition]
+Tool = Union[ToolBase, MCPServer]

vellum/workflows/types/definition.py

@@ -116,6 +116,7 @@ class ComposioToolDefinition(UniversalBaseModel):
     parameters: Optional[Dict[str, Any]] = None
     version: Optional[str] = None
     tags: Optional[List[str]] = None
+    user_id: Optional[str] = None
 
     @property
     def name(self) -> str:

vellum/workflows/types/tests/test_definition.py

@@ -39,7 +39,10 @@ def test_deployment_definition(deployment_value, expected_deployment_id, expecte
 def test_composio_tool_definition_creation():
     """Test that ComposioToolDefinition can be created with required fields."""
     composio_tool = ComposioToolDefinition(
-        toolkit="GITHUB", action="GITHUB_CREATE_AN_ISSUE", description="Create a new issue in a GitHub repository"
+        toolkit="GITHUB",
+        action="GITHUB_CREATE_AN_ISSUE",
+        description="Create a new issue in a GitHub repository",
+        user_id=None,
     )
 
     assert composio_tool.toolkit == "GITHUB"

{vellum_ai-1.0.8.dist-info → vellum_ai-1.0.10.dist-info}/METADATA

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

{vellum_ai-1.0.8.dist-info → vellum_ai-1.0.10.dist-info}/RECORD

@@ -8,7 +8,7 @@ vellum_cli/init.py,sha256=WpnMXPItPmh0f0bBGIer3p-e5gu8DUGwSArT_FuoMEw,5093
 vellum_cli/logger.py,sha256=dcM_OmgqXLo93vDYswO5ylyUQQcTfnA5GTd5tbIt3wM,1446
 vellum_cli/ping.py,sha256=p_BCCRjgPhng6JktuECtkDQLbhopt6JpmrtGoLnLJT8,1161
 vellum_cli/pull.py,sha256=udYyPlJ6VKDdh78rApNJOZgxHl82fcV6iGnRPSdX1LY,14750
-vellum_cli/push.py,sha256=hzBBD7Rc-11Dyu6_JfHeLI03c4XKAYQZZoq1SCNyXpM,11547
+vellum_cli/push.py,sha256=5sGkWmwnuPI9mYlBFZO4Wc0WcErZAnFNXZYJByiAJGw,11620
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=wx3PlJjVB0HRf5dr2b_idOIw27WPPl0J0FNbhIJJaVk,1689
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
@@ -18,7 +18,7 @@ vellum_cli/tests/test_init.py,sha256=8UOc_ThfouR4ja5cCl_URuLk7ohr9JXfCnG4yka1OUQ
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_ping.py,sha256=b3aQLd-N59_8w2rRiWqwpB1rlHaKEYVbAj1Y3hi7A-g,2605
 vellum_cli/tests/test_pull.py,sha256=hxMbW_j0weDDrkzVGpvLpFcwNQdn-fxTv4wBHeYizzc,49904
-vellum_cli/tests/test_push.py,sha256=H9ZU0_E-I1F98SBvj-I_1ooe3RzOlhMTTmEFg6CRrYY,40384
+vellum_cli/tests/test_push.py,sha256=9whdm-i4d3scJeJ7snGrkCVKcDlZsq8WqH_Nnv9KAYk,40395
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -94,7 +94,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=XWrhHg_acLsRHwjstBAii9Pmes9oXFtAUWSAVF1oSBc,11225
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=V8b6gKghLlO7PJI8xeNdnfn8aII0W_IFQvSQBQM62UQ,7721
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=hDWtKXmGI1CKhTwTNqpu_d5RkE5n7SolMLtgd87KqTI,3856
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py,sha256=gonapBCyDDt3qc7U02PCuKyPS8f3YiSAZ7QD86CH1Fw,3794
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py,sha256=sWKSqw1B4iAEamIzbRJBfjtMCy_D54gxEu3aPSDrS_o,3819
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py,sha256=4t1lkN2nsZF6lFqP6QnskUQWJlhasF8C2_f6atzk8ZY,26298
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=B0rDsCvO24qPp0gkmj8SdTDY5CxZYkvKwknsKBuAPyA,10017
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py,sha256=mova0sPD3evHiHIN1O0VynxlCp-uOcEIKve5Pd_oCDg,4069
@@ -145,7 +145,7 @@ vellum/client/README.md,sha256=Dle5iytCXxP1pNeNd7uZyhFo0rl7tp7vU7s8gmi10OQ,4863
 vellum/client/__init__.py,sha256=KmkyOgReuTsjmXF3WC_dPQ9QqJgYrB3Sr8_LcSUIQyI,125258
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=-AFplaIvuzgdfFXfodBM9oR_i0p48jofC_DkscIsYRE,2383
+vellum/client/core/client_wrapper.py,sha256=PYKT4GSWVfnUCdamESx8hYo2KF9SVuaYQAHwwHxyYSI,2385
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/http_client.py,sha256=cKs2w0ybDBk1wHQf-fTALm_MmvaMe3cZKcYJxqmCxkE,19539
@@ -210,7 +210,7 @@ vellum/client/resources/workflow_sandboxes/client.py,sha256=tpIjyuvVAnghmUu_gI9l
 vellum/client/resources/workflow_sandboxes/types/__init__.py,sha256=EaGVRU1w6kJiiHrbZOeEa0c3ggjfgv_jBqsyOkCRWOI,212
 vellum/client/resources/workflow_sandboxes/types/list_workflow_sandbox_examples_request_tag.py,sha256=TEwWit20W3X-zWPPLAhmUG05UudG9gaBSJ4Q4-rNJws,188
 vellum/client/resources/workflows/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
-vellum/client/resources/workflows/client.py,sha256=a3DwkUn8FBve-Wr139MSms18EPZPdnTkDsMqyTUQEYc,10725
+vellum/client/resources/workflows/client.py,sha256=rU5fJmVebWO6SoK5S9RzJHM0-hucRKnDt24tvG-DwEM,11037
 vellum/client/resources/workspace_secrets/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 vellum/client/resources/workspace_secrets/client.py,sha256=l1FOj0f-IB5_oQ7iWiHopFK3lDXBqiaIc9g10W9PHFU,8381
 vellum/client/resources/workspaces/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
@@ -295,7 +295,7 @@ vellum/client/types/deployment_release_tag_read.py,sha256=dUrTOz9LH1gAvC_ktMB_7N
 vellum/client/types/docker_service_token.py,sha256=T0icNHBKsIs6TrEiDRjckM_f37hcF1DMwEE8161tTvY,614
 vellum/client/types/document_chat_message_content.py,sha256=MiVYuMKtRUaT6_ve1MzihChb10SrOt_0VhpCB0x7hFQ,745
 vellum/client/types/document_chat_message_content_request.py,sha256=wMzj1SREQUeiSqZhOoLOOQzn6hmO_GDOMICDQ4fEXzs,774
-vellum/client/types/document_document_to_document_index.py,sha256=IDfBoch4lYL-J1XlUNSAtV7elJ6l5jX5peboYsriGjQ,1580
+vellum/client/types/document_document_to_document_index.py,sha256=Yeb84grNv-T9nI2oFjMwioPHUEH2TLREaqhldWMYwhs,1609
 vellum/client/types/document_index_chunking.py,sha256=TU0Y7z0Xacm3dhzEDuDIG3ZKJCu3vNURRh3PqEd17mY,356
 vellum/client/types/document_index_chunking_request.py,sha256=g9BKCsHKg5kzjG7YYeMNQ_5R8TXLeSgumJlMXoSfBcs,435
 vellum/client/types/document_index_indexing_config.py,sha256=xL1pCzUOkw5sSie1OrBpasE3bVnv0UyZBn7uZztbhbs,781
@@ -500,7 +500,7 @@ vellum/client/types/open_ai_vectorizer_text_embedding_3_small.py,sha256=T_-P7qGj
 vellum/client/types/open_ai_vectorizer_text_embedding_3_small_request.py,sha256=-lwNeWj7ExP-JLncUp1Uyd20FxweVIDu-aEnenPB98A,841
 vellum/client/types/open_ai_vectorizer_text_embedding_ada_002.py,sha256=c4vNlR6lRvUjq-67M06sroDMNMG_qC4JUBqwmKEJQ2I,812
 vellum/client/types/open_ai_vectorizer_text_embedding_ada_002_request.py,sha256=FdpkkNBGgRwfqFjBwpfH4t2zKIM0pIYminX2iZQUzvY,841
-vellum/client/types/organization_read.py,sha256=QDFpX4pZCjGSRXZ6FF65SDzRxFqkI87DEEUXtaVoTAs,837
+vellum/client/types/organization_read.py,sha256=AMTjqWH6CWXzbPpjoOE9Usb0lsqepC_vBfqKjLxHcik,908
 vellum/client/types/paginated_container_image_read_list.py,sha256=7lwIgs1q7Z0xDYPGWPnjSNC1kU_peu79CotzaaQfRdA,801
 vellum/client/types/paginated_deployment_release_tag_read_list.py,sha256=hp7D74CxPY14dEPRZ-fnTCwp63upxkYquL1e74oYXh4,826
 vellum/client/types/paginated_document_index_read_list.py,sha256=bO7pm3KCZi5LDO17YXgr_lUF9SRdAfMu6wOutX91ANw,797
@@ -589,7 +589,7 @@ vellum/client/types/sentence_chunking.py,sha256=guqU3072X4h8Laf6LhTWQ5lpjBpTgoXR
 vellum/client/types/sentence_chunking_request.py,sha256=77gv1fVc9IaTuGGx3O1HB0LF9sXM5pSTWksl8BEmvLU,812
 vellum/client/types/slim_deployment_read.py,sha256=Gr3wWT1eJKe33MVsW0O0pSIgUF_LE6WFbvFbf5_CVb8,1654
 vellum/client/types/slim_document.py,sha256=HJiymYPvRxfxhBUkD8epW0hQ2Vt9PQtv398QsRb4DsI,2395
-vellum/client/types/slim_document_document_to_document_index.py,sha256=IG8gzxWO32fzjd6bQn5ZyBoIlAGpkx1RNgjsFaWUXSY,1522
+vellum/client/types/slim_document_document_to_document_index.py,sha256=0LThZhOgIE2kSmIWH9s59_6pEzGRWpx5qS5BBuWXdLk,1551
 vellum/client/types/slim_release_review.py,sha256=7DXmD1AVa_Wj7e0qiR7GUN9cSqwkk1JloYmp_3oluQQ,783
 vellum/client/types/slim_workflow_deployment.py,sha256=Js-ycMFZ8-kNFPsd4bZew9nI_eN2M_58LzDHeCjkfTg,2009
 vellum/client/types/slim_workflow_execution_read.py,sha256=Opm1HTYVMz_D2USQCB-5ZoJ4EjKKfrDhoXc0hETldVM,1936
@@ -844,7 +844,7 @@ vellum/evaluations/utils/env.py,sha256=Xj_nxsoU5ox06EOTjRopR4lrigQI6Le6qbWGltYoE
 vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3qOsoOJUxfg,49
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/plugins/pydantic.py,sha256=GmNsxupKskbqpe4N5NBmSnLo680EATqhXJHABgf1NO0,3727
+vellum/plugins/pydantic.py,sha256=SamPlRZ8V9kuxEfMkOPKjhMMLa5Q3wYJ3Z-F_IfKtvA,3911
 vellum/plugins/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/tests/test_pydantic.py,sha256=S6bLqs3Y5DGA012QV_7f6hk4e6Bz-iJ9py9DEKuo4fM,746
 vellum/plugins/utils.py,sha256=cPmxE9R2CK1bki2jKE8rB-G9zMf2pzHjSPDHFPXwd3Q,878
@@ -1536,8 +1536,9 @@ vellum/workflows/descriptors/tests/test_utils.py,sha256=HJ5DoRz0sJvViGxyZ_FtytZj
 vellum/workflows/descriptors/utils.py,sha256=1siECBf6AI54gwwUwkF6mP9rYsRryUGaOYBbMpQaceM,3848
 vellum/workflows/edges/__init__.py,sha256=wSkmAnz9xyi4vZwtDbKxwlplt2skD7n3NsxkvR_pUus,50
 vellum/workflows/edges/edge.py,sha256=N0SnY3gKVuxImPAdCbPMPlHJIXbkQ3fwq_LbJRvVMFc,677
-vellum/workflows/emitters/__init__.py,sha256=YyOgaoLtVW8eFNEWODzCYb0HzL0PoSeNRf4diJ1Y0dk,80
-vellum/workflows/emitters/base.py,sha256=D5SADKIvnbgKwIBgYm77jaqvpo1o0rz4MmuX_muRqQU,359
+vellum/workflows/emitters/__init__.py,sha256=d9QFOI3eVg6rzpSFLvrjkDYXWikf1tcp3ruTRa2Boyc,143
+vellum/workflows/emitters/base.py,sha256=Tcp13VMB-GMwEJdl-6XTPckspdOdwpMgBx22-PcQxds,892
+vellum/workflows/emitters/vellum_emitter.py,sha256=VRJgyEs6RnikwlPBUu1s7BD8flVeuM3QgTeQLUnaDuE,5051
 vellum/workflows/environment/__init__.py,sha256=TJz0m9dwIs6YOwCTeuN0HHsU-ecyjc1OJXx4AFy83EQ,121
 vellum/workflows/environment/environment.py,sha256=Ck3RPKXJvtMGx_toqYQQQF-ZwXm5ijVwJpEPTeIJ4_Q,471
 vellum/workflows/errors/__init__.py,sha256=tWGPu5xyAU8gRb8_bl0fL7OfU3wxQ9UH6qVwy4X4P_Q,113
@@ -1597,7 +1598,8 @@ vellum/workflows/inputs/base.py,sha256=w3owT5B3rLBmIj-v-jL2l-HD4yd3hXK9RmHVd557B
 vellum/workflows/inputs/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/inputs/tests/test_inputs.py,sha256=lioA8917mFLYq7Ml69UNkqUjcWbbxkxnpIEJ4FBaYBk,2206
 vellum/workflows/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/integrations/composio_service.py,sha256=p3V9l7OlOV1zZK9aIgvfhLiDsxbxeSVZJ3MBSedo7Pw,5008
+vellum/workflows/integrations/composio_service.py,sha256=v1rVQXTh1rnupguj8oIM20V7bSKaJiAoJ5yjz2NeKA8,5906
+vellum/workflows/integrations/mcp_service.py,sha256=SaOLg76JBAiBDAMUn04mxVWmf2Btobd1kDjc8B1atng,8712
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
@@ -1695,13 +1697,13 @@ vellum/workflows/nodes/displayable/tests/test_search_node_error_handling.py,sha2
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
 vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=dc3EEn1sOICpr3GdS8eyeFtExaGwWWcw9eHSdkRhQJU,2584
 vellum/workflows/nodes/displayable/tool_calling_node/__init__.py,sha256=3n0-ysmFKsr40CVxPthc0rfJgqVJeZuUEsCmYudLVRg,117
-vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=KRI1NMgXZTUgQqq9uOA9W_D8k8sy7ZAq6v53-YVno1k,6545
+vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=ftPf7hmPvk_rJeIoxnJGkTLex-kDW1CRuvVDUwUdMxg,7283
 vellum/workflows/nodes/displayable/tool_calling_node/state.py,sha256=oQg_GAtc349nPB5BL_oeDYYD7q1qSDPAqjj8iA8OoAw,215
 vellum/workflows/nodes/displayable/tool_calling_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=UV0vZpU7-_tHcwnIq36WKwHrJXNurU4bdC3rfaw8eoU,4804
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=raY_E5-EgtYNXEPbO2I-Ythe4YeuFdGsXGZ_BAN98uI,7979
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=prl8GRwSBOgIorjBJkaYrp6XJjXNuaoedg3Lxt269j0,8303
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=rj9UTNDOi3sx_Rbc4DfBOtBpMTHut9piwlALN9n0zE0,16706
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=y7KAqbiJHoya6N5EWv1qgz0htM_Yzz7zjAHVp78IMFo,6919
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=TPafJhCAV6oLg5kTttQw0hL56ct3a2Xatvnld6dK8CY,8628
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=om4FztVQ33jFZK_lbusi6khOM7zgzNCHlUcEb5-r6pU,8361
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=fvy0O3YpibWUpw4aLKnk8PdwlRCJC7Z2acjryOTiuxY,19728
 vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
 vellum/workflows/nodes/experimental/__init__.py,sha256=jCQgvZEknXKfuNhGSOou4XPfrPqZ1_XBj5F0n0fgiWM,106
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
@@ -1748,12 +1750,12 @@ vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVi
 vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83yc5FIM33zuo8,353
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
 vellum/workflows/types/code_execution_node_wrappers.py,sha256=3MNIoFZKzVzNS5qFLVuDwMV17QJw72zo7NRf52yMq5A,3074
-vellum/workflows/types/core.py,sha256=Vykj9o6fEnS13M1LwJDh9FVgua03acqigBqyYOiJiq8,1352
-vellum/workflows/types/definition.py,sha256=pK0fAXHw7C0AFpCoM4WGe1_MD-usupF4-m6ldo5AQXY,4568
+vellum/workflows/types/core.py,sha256=TggDVs2lVya33xvu374EDhMC1b7RRlAAs0zWLaF46BA,1385
+vellum/workflows/types/definition.py,sha256=fzWfsfbXLS4sZvjOQMSDoiuSaFo4Ii2kC8AOiPade9o,4602
 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
-vellum/workflows/types/tests/test_definition.py,sha256=RsDoicu8A1dqJOGa-Ok866K8lnzn5L0Hez3lQijYD4c,5011
+vellum/workflows/types/tests/test_definition.py,sha256=4Qqlf7GpoG9MrLuMCkcRzEZMgwrr7du4DROcB1xfv0E,5050
 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
@@ -1774,8 +1776,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=ptMntHzVyy8ZuzNgeTuk7hREgKQ5UBdgq8VJFSGaW4Y,20832
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.0.8.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.0.8.dist-info/METADATA,sha256=qMK12xNOQpaw7B4-wciOlrjn7mmS4zzPS9ALMXFIb_c,5554
-vellum_ai-1.0.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.0.8.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.0.8.dist-info/RECORD,,
+vellum_ai-1.0.10.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.0.10.dist-info/METADATA,sha256=j-b34bQSbPMhl5YG7dLuwC4_EZYCtRrdhoTxjXYJ3-U,5555
+vellum_ai-1.0.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.0.10.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.0.10.dist-info/RECORD,,

vellum_cli/push.py

@@ -67,7 +67,10 @@ def push_command(
             raise ValueError(f"No workflow config for '{module}' found in project to push.")
 
     if len(workflow_configs) > 1:
-        raise ValueError("Multiple workflows found in project to push. Pushing only a single workflow is supported.")
+        raise ValueError(
+            "Multiple workflows found. Please specify a single workflow to push. "
+            f"Found: {', '.join([w.module for w in workflow_configs])}"
+        )
 
     workflow_config = workflow_configs[0]
 

vellum_cli/tests/test_push.py

@@ -77,9 +77,8 @@ def test_push__multiple_workflows_configured__no_module_specified(mock_module):
     # THEN it should fail
     assert result.exit_code == 1
     assert result.exception
-    assert (
-        str(result.exception)
-        == "Multiple workflows found in project to push. Pushing only a single workflow is supported."
+    assert str(result.exception) == (
+        "Multiple workflows found. Please specify a single workflow to push. Found: examples.mock, examples.mock2"
     )
 
 
@@ -349,9 +348,8 @@ def test_push__workflow_sandbox_option__existing_id_different_module(mock_module
     # THEN it should fail
     assert result.exit_code == 1
     assert result.exception
-    assert (
-        str(result.exception)
-        == "Multiple workflows found in project to push. Pushing only a single workflow is supported."
+    assert str(result.exception) == (
+        f"Multiple workflows found. Please specify a single workflow to push. Found: {module}, {second_module}"
     )
 
 

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py

@@ -57,6 +57,7 @@ def test_serialize_workflow():
         "parameters": None,
         "version": None,
         "tags": None,
+        "user_id": None,
     }
 
     # AND the rest of the node structure should be correct