vellum-ai 1.0.7__py3-none-any.whl → 1.0.9__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.7",
+            "User-Agent": "vellum-ai/1.0.9",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.0.7",
+            "X-Fern-SDK-Version": "1.0.9",
         }
         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/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}")
 

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

@@ -15,10 +15,12 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_function_node,
     create_tool_router_node,
     get_function_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.core import EntityInputsInterface, Tool, ToolSource
+from vellum.workflows.types.definition import MCPServer
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
@@ -30,6 +32,7 @@ class ToolCallingNode(BaseNode):
         ml_model: str - The model to use for tool calling (e.g., "gpt-4o-mini")
         blocks: List[PromptBlock] - The prompt blocks to use (same format as InlinePromptNode)
         functions: List[Tool] - The functions that can be called
+        tool_sources: List[ToolSource] - The tool sources that can be called
         prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values
         parameters: PromptParameters - The parameters for the Prompt
         max_prompt_iterations: Optional[int] - Maximum number of prompt iterations before stopping
@@ -38,6 +41,7 @@ class ToolCallingNode(BaseNode):
     ml_model: ClassVar[str] = "gpt-4o-mini"
     blocks: ClassVar[List[Union[PromptBlock, Dict[str, Any]]]] = []
     functions: ClassVar[List[Tool]] = []
+    tool_sources: ClassVar[List[ToolSource]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
     max_prompt_iterations: ClassVar[Optional[int]] = 5
@@ -134,6 +138,7 @@ class ToolCallingNode(BaseNode):
             ml_model=self.ml_model,
             blocks=self.blocks,
             functions=self.functions,
+            tool_sources=self.tool_sources,
             prompt_inputs=self.prompt_inputs,
             parameters=self.parameters,
             max_prompt_iterations=self.max_prompt_iterations,
@@ -148,6 +153,17 @@ class ToolCallingNode(BaseNode):
                 tool_router_node=self.tool_router_node,
             )
 
+        for tool_source in self.tool_sources:
+            if isinstance(tool_source, MCPServer):
+                tool_definitions = hydrate_mcp_tool_definitions(tool_source)
+                for tool_definition in tool_definitions:
+                    function_name = get_function_name(tool_definition)
+
+                    self._function_nodes[function_name] = create_function_node(
+                        function=tool_definition,
+                        tool_router_node=self.tool_router_node,
+                    )
+
         graph_set = set()
 
         # Add connections from ports of router to function nodes and back to router

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

@@ -39,6 +39,7 @@ def test_port_condition_match_function_name():
         ml_model="test-model",
         blocks=[],
         functions=[first_function, second_function],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )
@@ -97,6 +98,7 @@ def test_tool_calling_node_inline_workflow_context():
         ml_model="test-model",
         blocks=[],
         functions=[MyWorkflow],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )

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

@@ -15,7 +15,7 @@ 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.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 
 
 def test_get_function_name_callable():
@@ -69,6 +69,19 @@ def test_get_function_name_subworkflow_deployment_uuid():
     assert result == "57f09bebb46340e0bf9ec972e664352f"
 
 
+def test_get_function_name_mcp_tool_definition():
+    """Test MCPToolDefinition function name generation."""
+    mcp_tool = MCPToolDefinition(
+        name="create_repository",
+        server=MCPServer(name="github", url="https://api.github.com"),
+        parameters={"repository_name": "string", "description": "string"},
+    )
+
+    result = get_function_name(mcp_tool)
+
+    assert result == "github__create_repository"
+
+
 @pytest.mark.parametrize(
     "toolkit,action,description,expected_result",
     [
@@ -93,6 +106,7 @@ def test_create_tool_router_node_max_prompt_iterations(vellum_adhoc_prompt_clien
         ml_model="gpt-4o-mini",
         blocks=[],
         functions=[],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
         max_prompt_iterations=None,
@@ -152,6 +166,7 @@ def test_create_tool_router_node_chat_history_block_dict(vellum_adhoc_prompt_cli
         ml_model="gpt-4o-mini",
         blocks=blocks,  # type: ignore
         functions=[],
+        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )

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
+from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolSource
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 from vellum.workflows.types.generics import is_workflow_class
 
 CHAT_HISTORY_VARIABLE = "chat_history"
@@ -196,6 +197,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.
 
@@ -233,19 +257,53 @@ 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]]],
     functions: List[Tool],
+    tool_sources: List[ToolSource],
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
     max_prompt_iterations: Optional[int] = None,
 ) -> Type[ToolRouterNode]:
-    if functions and len(functions) > 0:
+    if functions and len(functions) > 0 or tool_sources and len(tool_sources) > 0:
         # Create dynamic ports and convert functions in a single loop
         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
@@ -262,21 +320,22 @@ def create_tool_router_node(
 
             # 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)
 
-            # 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)
+        for server in tool_sources:
+            tool_functions = hydrate_mcp_tool_definitions(server)
+            for tool_function in tool_functions:
+                name = get_function_name(tool_function)
+                prompt_functions.append(
+                    FunctionDefinition(
+                        name=name,
+                        description=tool_function.description,
+                        parameters=tool_function.parameters,
                     )
                 )
-
-            port_condition = create_port_condition(function_name)
-            port = Port.on_if(port_condition)
-            setattr(Ports, function_name, port)
+                port = create_port_condition(name)
+                setattr(Ports, name, port)
 
         # Add the else port for when no function conditions match
         setattr(Ports, "default", Port.on_else())
@@ -379,6 +438,17 @@ def create_function_node(
             },
         )
         return node
+    elif isinstance(function, MCPToolDefinition):
+        node = type(
+            f"MCPNode_{function.name}",
+            (MCPNode,),
+            {
+                "mcp_tool": function,
+                "function_call_output": tool_router_node.Outputs.results,
+                "__module__": __name__,
+            },
+        )
+        return node
     elif is_workflow_class(function):
         node = type(
             f"DynamicInlineSubworkflowNode_{function.__name__}",
@@ -410,5 +480,7 @@ def get_function_name(function: Tool) -> str:
         return name.replace("-", "")
     elif isinstance(function, ComposioToolDefinition):
         return function.name
+    elif isinstance(function, MCPToolDefinition):
+        return f"{function.server.name}__{function.name}"
     else:
         return snake_case(function.__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
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 
 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,7 @@ class ConditionType(Enum):
 
 
 # Type alias for functions that can be called in tool calling nodes
-Tool = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition]
+Tool = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition, MCPToolDefinition]
+
+# Type alias for sources that provide tools to tool calling nodes
+ToolSource = Union[MCPServer]

vellum/workflows/types/definition.py

@@ -8,6 +8,9 @@ from pydantic import BeforeValidator
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_resource_definition import CodeResourceDefinition as ClientCodeResourceDefinition
+from vellum.client.types.vellum_secret import VellumSecret
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 
 
 def serialize_type_encoder(obj: type) -> Dict[str, Any]:
@@ -118,3 +121,21 @@ class ComposioToolDefinition(UniversalBaseModel):
     def name(self) -> str:
         """Generate a function name for this tool"""
         return self.action.lower()
+
+
+class MCPServer(UniversalBaseModel):
+    name: str
+    url: str
+    authorization_type: AuthorizationType = AuthorizationType.BEARER_TOKEN
+    bearer_token_value: Optional[Union[str, EnvironmentVariableReference]] = None
+    api_key_header_key: Optional[str] = None
+    api_key_header_value: Optional[Union[str, VellumSecret]] = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class MCPToolDefinition(UniversalBaseModel):
+    name: str
+    server: MCPServer
+    description: Optional[str] = None
+    parameters: Dict[str, Any] = {}

vellum/workflows/types/tests/test_definition.py

@@ -1,7 +1,10 @@
 import pytest
 from uuid import UUID
 
-from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition
+from vellum.client.types.vellum_secret import VellumSecret
+from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.references.environment_variable import EnvironmentVariableReference
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 
 
 @pytest.mark.parametrize(
@@ -44,3 +47,78 @@ def test_composio_tool_definition_creation():
     assert composio_tool.description == "Create a new issue in a GitHub repository"
     assert composio_tool.display_name is None
     assert composio_tool.name == "github_create_an_issue"
+
+
+def test_mcp_tool_definition_creation_bearer_token():
+    """Test that MCPToolDefinition can be created with required fields."""
+    mcp_tool = MCPToolDefinition(
+        name="create_repository",
+        server=MCPServer(
+            name="github",
+            url="https://api.githubcopilot.com/mcp/",
+            authorization_type=AuthorizationType.BEARER_TOKEN,
+            bearer_token_value=EnvironmentVariableReference(name="GITHUB_PERSONAL_ACCESS_TOKEN"),
+        ),
+        parameters={
+            "type": "object",
+            "properties": {
+                "repository_name": {"type": "string", "description": "Repository name"},
+                "description": {"type": "string", "description": "Repository description"},
+            },
+            "required": ["repository_name"],
+        },
+    )
+
+    assert mcp_tool.name == "create_repository"
+    assert mcp_tool.server.name == "github"
+    assert mcp_tool.server.url == "https://api.githubcopilot.com/mcp/"
+    assert mcp_tool.server.authorization_type == AuthorizationType.BEARER_TOKEN
+    assert mcp_tool.parameters == {
+        "type": "object",
+        "properties": {
+            "repository_name": {"type": "string", "description": "Repository name"},
+            "description": {"type": "string", "description": "Repository description"},
+        },
+        "required": ["repository_name"],
+    }
+
+    assert isinstance(mcp_tool.server.bearer_token_value, EnvironmentVariableReference)
+    assert mcp_tool.server.bearer_token_value.name == "GITHUB_PERSONAL_ACCESS_TOKEN"
+
+
+def test_mcp_tool_definition_creation_api_key():
+    """Test that MCPToolDefinition can be created with required fields."""
+    mcp_tool = MCPToolDefinition(
+        name="create_repository",
+        server=MCPServer(
+            name="github",
+            url="https://api.githubcopilot.com/mcp/",
+            authorization_type=AuthorizationType.API_KEY,
+            api_key_header_key="Authorization",
+            api_key_header_value=VellumSecret(name="GITHUB_PERSONAL_ACCESS_TOKEN"),
+        ),
+        parameters={
+            "type": "object",
+            "properties": {
+                "repository_name": {"type": "string", "description": "Repository name"},
+                "description": {"type": "string", "description": "Repository description"},
+            },
+            "required": ["repository_name"],
+        },
+    )
+
+    assert mcp_tool.name == "create_repository"
+    assert mcp_tool.server.name == "github"
+    assert mcp_tool.server.url == "https://api.githubcopilot.com/mcp/"
+    assert mcp_tool.server.authorization_type == AuthorizationType.API_KEY
+    assert mcp_tool.server.api_key_header_key == "Authorization"
+    assert isinstance(mcp_tool.server.api_key_header_value, VellumSecret)
+    assert mcp_tool.server.api_key_header_value.name == "GITHUB_PERSONAL_ACCESS_TOKEN"
+    assert mcp_tool.parameters == {
+        "type": "object",
+        "properties": {
+            "repository_name": {"type": "string", "description": "Repository name"},
+            "description": {"type": "string", "description": "Repository description"},
+        },
+        "required": ["repository_name"],
+    }

{vellum_ai-1.0.7.dist-info → vellum_ai-1.0.9.dist-info}/METADATA

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

{vellum_ai-1.0.7.dist-info → vellum_ai-1.0.9.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=d1947A_QwFKSZyDimK6dEK1abf_o8e1uzjpI_A_SCwM,11459
+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
@@ -95,8 +95,8 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_
 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_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_inline_workflow_serialization.py,sha256=pZJVn7oXyTuKvyLOM6pj00ulSJR2QtVd9h2VwBv4_mg,26522
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=wKJlecy8kxlOslTlPHRFUb-zFBGpNq6S7eeOrswB9-I,10241
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py,sha256=mova0sPD3evHiHIN1O0VynxlCp-uOcEIKve5Pd_oCDg,4069
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=pLCyMScV88DTBXRH7jXaXOEA1GBq8NIipCUFwIAWnwI,2771
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=J4ouI8KxbMfxQP2Zq_9cWMGYgbjCWmKzjCJEtnSJb0I,5829
@@ -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=4HIoFVgVHLgCMAKnGSlXru4ZVIHjc4LSqpYHg9GPlAI,2383
+vellum/client/core/client_wrapper.py,sha256=K6kF1J_NBmrtjJs0H4OqVoVsJgY3ivrRe4FzhceFTis,2383
 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
@@ -1597,7 +1597,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=Wo1IKHr_CzrHFQHR_hjVcKap3JLwlV_TEbKsZcuR6Sw,5664
+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 +1696,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=6uFt-_woayqyvbVGNJeWoiBQs2_VBtgTTdMX-Ztwx1I,7338
 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=Ku_fUUoqQFeKLZ6o1DPCi7ax9PdkbaxkEEj6rAwjytM,7858
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=uRZGCJA3FBRt1ZPQWOF2R8D49aajrW4Yjxvn3kIcrAQ,16545
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=U14GS6YwJGpIA13nq4Qvo1YBEku5ZRL627ZWnybp4hg,8029
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=3TQeLD-HlB0OHEtUcADe4jl0XGi9YTv5FL4ZupDaSJA,8361
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=shFC4Vm0vyqAILWsUTDOo_Ggn0_7GHKQlgZ0TPHohWQ,19180
 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 +1749,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=6MW_BRLcx4oEJpItQWQa64xfCrsk76suZSsMKKEsJLg,1314
-vellum/workflows/types/definition.py,sha256=K1evpjoxHpZysx8HBcA-IY0fS_p1afS4QcvG2HZ-r0o,3815
+vellum/workflows/types/core.py,sha256=ybQj70QjlVNSEXsdIO8Mug9EBIDEkyFPxYv4cnn_hM0,1482
+vellum/workflows/types/definition.py,sha256=pK0fAXHw7C0AFpCoM4WGe1_MD-usupF4-m6ldo5AQXY,4568
 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=c3GczPtWxuH3BOULwZacxYTQlP2ryqH7rvT_anDORVo,1604
+vellum/workflows/types/tests/test_definition.py,sha256=RsDoicu8A1dqJOGa-Ok866K8lnzn5L0Hez3lQijYD4c,5011
 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 +1775,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.7.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.0.7.dist-info/METADATA,sha256=-x_ul0guh3O6FHWJQn5INiN0RWn4W4IBRFk_JZgcUGQ,5554
-vellum_ai-1.0.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.0.7.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.0.7.dist-info/RECORD,,
+vellum_ai-1.0.9.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.0.9.dist-info/METADATA,sha256=b1ciqHMubElgtkn0rm_nW7vFBfZ2KqdOVuogZ9ICOcE,5554
+vellum_ai-1.0.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.0.9.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.0.9.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]
 
@@ -95,8 +98,9 @@ def push_command(
         and workflow_config.workflow_sandbox_id
         and workflow_config.workflow_sandbox_id != workflow_sandbox_id
     ):
-        raise ValueError(
-            f"Workflow sandbox id '{workflow_sandbox_id}' is already associated with '{workflow_config.module}'."
+        logger.warning(
+            f"Workflow sandbox id '{workflow_sandbox_id}' is already associated with '{workflow_config.module}'. "
+            f"Continuing with the provided workflow sandbox id '{workflow_sandbox_id}'."
         )
 
     client = create_vellum_client(

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_inline_workflow_serialization.py

@@ -407,6 +407,11 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "89084be2-0853-4483-9031-c24bdf872c32",
+                "name": "tool_sources",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+            },
             {
                 "id": "229cd1ca-dc2f-4586-b933-c4d4966f7bd1",
                 "name": "parameters",

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

@@ -175,6 +175,11 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "89084be2-0853-4483-9031-c24bdf872c32",
+                "name": "tool_sources",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+            },
             {
                 "id": "229cd1ca-dc2f-4586-b933-c4d4966f7bd1",
                 "name": "parameters",