vellum-ai 1.0.9__tar.gz → 1.0.10__tar.gz

{vellum_ai-1.0.9 → vellum_ai-1.0.10}/PKG-INFO

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

{vellum_ai-1.0.9 → vellum_ai-1.0.10}/ee/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

{vellum_ai-1.0.9 → vellum_ai-1.0.10}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -407,11 +407,6 @@ 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_ai-1.0.9 → vellum_ai-1.0.10}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -175,11 +175,6 @@ 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_ai-1.0.9 → vellum_ai-1.0.10}/pyproject.toml

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

{vellum_ai-1.0.9 → vellum_ai-1.0.10}/src/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.9",
+            "User-Agent": "vellum-ai/1.0.10",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.0.9",
+            "X-Fern-SDK-Version": "1.0.10",
         }
         if self._api_version is not None:
             headers["X-API-Version"] = self._api_version

{vellum_ai-1.0.9 → vellum_ai-1.0.10}/src/vellum/workflows/emitters/__init__.py

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

vellum_ai-1.0.10/src/vellum/workflows/emitters/base.py

@@ -0,0 +1,31 @@
+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
+
+    @abstractmethod
+    def snapshot_state(self, state: BaseState) -> None:
+        pass

vellum_ai-1.0.10/src/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_ai-1.0.9 → vellum_ai-1.0.10}/src/vellum/workflows/integrations/composio_service.py

@@ -135,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_ai-1.0.9 → vellum_ai-1.0.10}/src/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,18 +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, ToolSource
+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
 
@@ -32,7 +35,6 @@ 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
@@ -41,7 +43,6 @@ 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
@@ -138,7 +139,6 @@ 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,
@@ -146,23 +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,
-            )
-
-        for tool_source in self.tool_sources:
-            if isinstance(tool_source, MCPServer):
-                tool_definitions = hydrate_mcp_tool_definitions(tool_source)
+            if isinstance(function, MCPServer):
+                tool_definitions = hydrate_mcp_tool_definitions(function)
                 for tool_definition in tool_definitions:
-                    function_name = get_function_name(tool_definition)
+                    function_name = get_mcp_tool_name(tool_definition)
 
-                    self._function_nodes[function_name] = create_function_node(
-                        function=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_ai-1.0.9 → vellum_ai-1.0.10}/src/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_ai-1.0.9 → vellum_ai-1.0.10}/src/vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py

@@ -39,7 +39,6 @@ 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,
     )
@@ -98,7 +97,6 @@ def test_tool_calling_node_inline_workflow_context():
         ml_model="test-model",
         blocks=[],
         functions=[MyWorkflow],
-        tool_sources=[],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )
@@ -213,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_ai-1.0.9 → vellum_ai-1.0.10}/src/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,7 +81,7 @@ 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 == "github__create_repository"
 
@@ -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)
 
@@ -106,7 +110,6 @@ 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,
@@ -166,7 +169,6 @@ 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_ai-1.0.9 → vellum_ai-1.0.10}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -28,7 +28,7 @@ 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, ToolSource
+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
 
@@ -184,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)}",
@@ -249,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:
@@ -281,12 +287,11 @@ 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 or tool_sources and len(tool_sources) > 0:
+    if functions and len(functions) > 0:
         # Create dynamic ports and convert functions in a single loop
         Ports = type("Ports", (), {})
         prompt_functions: List[Union[Tool, FunctionDefinition]] = []
@@ -315,27 +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)
-            port = create_port_condition(function_name)
-            setattr(Ports, function_name, port)
-
-        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 = create_port_condition(name)
-                setattr(Ports, 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())
@@ -397,7 +403,7 @@ def create_tool_router_node(
 
 
 def create_function_node(
-    function: Tool,
+    function: ToolBase,
     tool_router_node: Type[ToolRouterNode],
 ) -> Type[BaseNode]:
     """
@@ -438,17 +444,6 @@ 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__}",
@@ -474,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 f"{function.server.name}__{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_ai-1.0.9 → vellum_ai-1.0.10}/src/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, MCPServer, MCPToolDefinition
+from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -51,7 +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]
-
-# Type alias for sources that provide tools to tool calling nodes
-ToolSource = Union[MCPServer]
+ToolBase = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition]
+Tool = Union[ToolBase, MCPServer]