vellum-ai 1.11.2__py3-none-any.whl → 1.13.5__py3-none-any.whl

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

@@ -183,8 +183,26 @@ def test_tool_calling_node_inline_workflow_context():
         tool_prompt_node=tool_prompt_node,
     )
 
+    # AND we create a state with a function call
+    state = ToolCallingState(
+        meta=StateMeta(
+            node_outputs={
+                tool_prompt_node.Outputs.results: [
+                    FunctionCallVellumValue(
+                        value=FunctionCall(
+                            arguments={},
+                            id="call_test",
+                            name="MyWorkflow",
+                            state="FULFILLED",
+                        ),
+                    )
+                ],
+            },
+        )
+    )
+
     # AND we create an instance with a context containing generated_files
-    function_node = function_node_class()
+    function_node = function_node_class(state=state)
 
     # Create a parent context with test data
     parent_context = WorkflowContext(
@@ -192,6 +210,12 @@ def test_tool_calling_node_inline_workflow_context():
     )
     function_node._context = parent_context
 
+    # AND the _inputs should be populated with resolved values from state
+    assert function_node._inputs == {
+        function_node_class.arguments: {},
+        function_node_class.function_call_id: "call_test",
+    }
+
     # WHEN the function node runs
     outputs = list(function_node.run())
 
@@ -558,11 +582,10 @@ def test_mcp_node_outputs_result():
         parameters={},
     )
 
-    # AND a tool prompt node
     tool_prompt_node = create_tool_prompt_node(
         ml_model="test-model",
         blocks=[],
-        functions=[mcp_server],
+        functions=[mcp_tool],
         prompt_inputs=None,
         parameters=DEFAULT_PROMPT_PARAMETERS,
     )
@@ -677,9 +700,93 @@ def test_vellum_integration_node_outputs_result(vellum_client):
     assert result_output.value == {"id": 123, "url": "https://github.com/test-owner/test-repo/issues/123"}
 
 
-def test_tool_calling_node_400_error_returns_internal_error(vellum_adhoc_prompt_client):
+def test_vellum_integration_node_error_outputs_result(vellum_client):
+    """Test that VellumIntegrationNode yields error payload as result output when NodeException occurs."""
+
+    # GIVEN a VellumIntegrationToolDefinition
+    github_tool = VellumIntegrationToolDefinition(
+        provider=VellumIntegrationProviderType.COMPOSIO,
+        integration_name="GITHUB",
+        name="create_issue",
+        description="Create a new issue in a GitHub repository",
+    )
+
+    # AND a tool prompt node
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="test-model",
+        blocks=[],
+        functions=[github_tool],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+    )
+
+    function_node_class = create_function_node(
+        function=github_tool,
+        tool_prompt_node=tool_prompt_node,
+    )
+
+    # AND a state with a function call
+    state = ToolCallingState(
+        meta=StateMeta(
+            node_outputs={
+                tool_prompt_node.Outputs.results: [
+                    FunctionCallVellumValue(
+                        value=FunctionCall(
+                            arguments={"owner": "test-owner", "repo": "test-repo", "title": "Test Issue"},
+                            id="call_vellum_error_test",
+                            name="create_issue",
+                            state="FULFILLED",
+                        ),
+                    )
+                ],
+            },
+        )
+    )
+
+    # AND mock the vellum client's integration service to raise a 500 error
+    vellum_client.integrations.execute_integration_tool.side_effect = ApiError(
+        status_code=500,
+        body={"detail": "Internal server error occurred while executing the tool."},
+    )
+
+    # AND create a context with the vellum client
+    context = WorkflowContext()
+    context.vellum_client = vellum_client
+
+    function_node = function_node_class(state=state)
+    function_node._context = context
+
+    # WHEN the VellumIntegration node runs
+    outputs = list(function_node.run())
+
+    # THEN there should be exactly one output with name "result"
+    assert len(outputs) == 1
+    result_output = outputs[0]
+    assert isinstance(result_output, BaseOutput)
+    assert result_output.name == "result"
+    assert result_output.is_fulfilled is True
+
+    # AND the result should contain the error payload
+    error_result = result_output.value
+    assert isinstance(error_result, dict)
+    assert "code" in error_result
+    assert "message" in error_result
+    assert error_result["code"] == "PROVIDER_ERROR"
+    assert "Internal server error occurred while executing the tool" in error_result["message"]
+
+    # AND the error should also be in chat history
+    assert len(state.chat_history) == 1
+    function_message = state.chat_history[0]
+    assert function_message.role == "FUNCTION"
+    assert isinstance(function_message.content, StringChatMessageContent)
+    error_data = json.loads(function_message.content.value)
+    assert "error" in error_data
+    assert error_data["error"]["code"] == "PROVIDER_ERROR"
+
+
+def test_tool_calling_node_400_error_preserves_invalid_inputs(vellum_adhoc_prompt_client):
     """
-    Test that ToolCallingNode returns INTERNAL_ERROR when the underlying prompt node returns a 400 error.
+    Test that ToolCallingNode preserves INVALID_INPUTS error code when the underlying prompt node returns a 400 error.
     """
 
     # GIVEN a ToolCallingNode with minimal configuration
@@ -705,10 +812,10 @@ def test_tool_calling_node_400_error_returns_internal_error(vellum_adhoc_prompt_
     with pytest.raises(NodeException) as exc_info:
         list(node.run())
 
-    # AND the error code should be INTERNAL_ERROR (not INVALID_INPUTS)
+    # THEN the error code should be INVALID_INPUTS (preserved from the underlying prompt node)
     e = exc_info.value
-    assert e.code == WorkflowErrorCode.INTERNAL_ERROR
-    assert e.message == "Internal server error"
+    assert e.code == WorkflowErrorCode.INVALID_INPUTS
+    assert e.message == "Invalid request parameters"
 
 
 def test_vellum_integration_node_500_error_feeds_back_to_model(vellum_adhoc_prompt_client, vellum_client):
@@ -800,3 +907,92 @@ def test_vellum_integration_node_500_error_feeds_back_to_model(vellum_adhoc_prom
 
     # AND the third message should be the assistant's response to the error
     assert chat_history[2].role == "ASSISTANT"
+
+
+def test_tool_calling_node_json_output(vellum_adhoc_prompt_client):
+    """
+    Tests that ToolCallingNode exposes a json output when the LLM returns valid JSON.
+    """
+
+    # GIVEN a ToolCallingNode with a simple function
+    class TestToolCallingNode(ToolCallingNode):
+        ml_model = "gpt-4o-mini"
+        blocks = []
+        functions = [first_function]
+        max_prompt_iterations = 1
+
+    # AND the LLM returns a JSON response
+    expected_json = {"items": ["apple", "banana", "cherry"], "count": 3}
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[StringVellumValue(value=json.dumps(expected_json))],
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the ToolCallingNode runs
+    state = BaseState()
+    node = TestToolCallingNode(state=state)
+    node_outputs = {}
+    for output in node.run():
+        if output.is_fulfilled:
+            node_outputs[output.name] = output.value
+
+    # THEN the json output should contain the parsed JSON
+    assert "json" in node_outputs
+    assert node_outputs["json"] == expected_json
+
+    # AND the text output should contain the raw JSON string
+    assert "text" in node_outputs
+    assert node_outputs["text"] == json.dumps(expected_json)
+
+
+def test_tool_calling_node_json_output_not_present_for_non_json(vellum_adhoc_prompt_client):
+    """
+    Tests that ToolCallingNode does not expose a json output when the LLM returns non-JSON text.
+    """
+
+    # GIVEN a ToolCallingNode with a simple function
+    class TestToolCallingNode(ToolCallingNode):
+        ml_model = "gpt-4o-mini"
+        blocks = []
+        functions = [first_function]
+        max_prompt_iterations = 1
+
+    # AND the LLM returns a plain text response (not JSON)
+    plain_text_response = "Hello! I can help you with that."
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[StringVellumValue(value=plain_text_response)],
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the ToolCallingNode runs
+    state = BaseState()
+    node = TestToolCallingNode(state=state)
+    node_outputs = {}
+    for output in node.run():
+        if output.is_fulfilled:
+            node_outputs[output.name] = output.value
+
+    # THEN the json output should not be present
+    assert "json" not in node_outputs
+
+    # AND the text output should contain the plain text
+    assert "text" in node_outputs
+    assert node_outputs["text"] == plain_text_response

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

@@ -35,14 +35,12 @@ from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.definition import (
     ComposioToolDefinition,
     DeploymentDefinition,
-    MCPServer,
     MCPToolDefinition,
-    Tool,
     ToolBase,
     VellumIntegrationToolDefinition,
 )
 from vellum.workflows.types.generics import is_workflow_class
-from vellum.workflows.utils.functions import compile_mcp_tool_definition, get_mcp_tool_name
+from vellum.workflows.utils.functions import get_mcp_tool_name
 
 CHAT_HISTORY_VARIABLE = "chat_history"
 
@@ -53,7 +51,8 @@ logger = logging.getLogger(__name__)
 class FunctionCallNodeMixin:
     """Mixin providing common functionality for nodes that handle function calls."""
 
-    function_call_output: List[PromptOutput]
+    arguments: dict
+    function_call_id: Optional[str]
 
     def _handle_tool_exception(self, e: Exception, tool_type: str, tool_name: str) -> None:
         """
@@ -77,27 +76,9 @@ class FunctionCallNodeMixin:
                 code=WorkflowErrorCode.NODE_EXECUTION,
             ) from e
 
-    def _extract_function_arguments(self) -> dict:
-        """Extract arguments from function call output."""
-        current_index = getattr(self, "state").current_prompt_output_index
-        if self.function_call_output and len(self.function_call_output) > current_index:
-            function_call = self.function_call_output[current_index]
-            if function_call.type == "FUNCTION_CALL" and function_call.value is not None:
-                return function_call.value.arguments or {}
-        return {}
-
-    def _extract_function_call_id(self) -> Optional[str]:
-        """Extract function call ID from function call output."""
-        current_index = getattr(self, "state").current_prompt_output_index
-        if self.function_call_output and len(self.function_call_output) > current_index:
-            function_call = self.function_call_output[current_index]
-            if function_call.type == "FUNCTION_CALL" and function_call.value is not None:
-                return function_call.value.id
-        return None
-
     def _add_function_result_to_chat_history(self, result: Any, state: ToolCallingState) -> None:
         """Add function execution result to chat history."""
-        function_call_id = self._extract_function_call_id()
+        function_call_id = self.function_call_id
         state.chat_history.append(
             ChatMessage(
                 role="FUNCTION",
@@ -119,7 +100,14 @@ class ToolPromptNode(InlinePromptNode[ToolCallingState]):
     def run(self) -> Iterator[BaseOutput]:
         if self.max_prompt_iterations is not None and self.state.prompt_iterations >= self.max_prompt_iterations:
             max_iterations_message = f"Maximum number of prompt iterations `{self.max_prompt_iterations}` reached."
-            raise NodeException(message=max_iterations_message, code=WorkflowErrorCode.NODE_EXECUTION)
+            raise NodeException(
+                message=max_iterations_message,
+                code=WorkflowErrorCode.NODE_EXECUTION,
+                raw_data={
+                    "max_iterations": self.max_prompt_iterations,
+                    "iterations_reached": self.state.prompt_iterations,
+                },
+            )
 
         generator = super().run()
         with self.state.__quiet__():
@@ -166,18 +154,9 @@ class DynamicSubworkflowDeploymentNode(SubworkflowDeploymentNode[ToolCallingStat
     """Node that executes a deployment definition with function call output."""
 
     def run(self) -> Iterator[BaseOutput]:
-        arguments = self._extract_function_arguments()
-
         # Mypy doesn't like instance assignments of class attributes. It's safe in our case tho bc it's what
-        # we do in the `__init__` method. Long term, instead of the function_call_output attribute above, we
-        # want to do:
-        # ```python
-        # subworkflow_inputs = tool_prompt_node.Outputs.results[0]['value']['arguments'].if_(
-        #     tool_prompt_node.Outputs.results[0]['type'].equals('FUNCTION_CALL'),
-        #     {},
-        # )
-        # ```
-        self.subworkflow_inputs = arguments  # type:ignore[misc]
+        # we do in the `__init__` method.
+        self.subworkflow_inputs = self.arguments  # type:ignore[misc]
 
         # Call the parent run method to execute the subworkflow
         outputs = {}
@@ -196,9 +175,18 @@ class DynamicInlineSubworkflowNode(
     """Node that executes an inline subworkflow with function call output."""
 
     def run(self) -> Iterator[BaseOutput]:
-        arguments = self._extract_function_arguments()
+        # Merge arguments with resolved inputs from __vellum_inputs__
+        merged_inputs = self.arguments.copy()
+        vellum_inputs = getattr(self.subworkflow, "__vellum_inputs__", {})
+        if vellum_inputs:
+            for param_name, param_ref in vellum_inputs.items():
+                if isinstance(param_ref, BaseDescriptor):
+                    resolved_value = param_ref.resolve(self.state)
+                else:
+                    resolved_value = param_ref
+                merged_inputs[param_name] = resolved_value
 
-        self.subworkflow_inputs = arguments  # type: ignore[misc]
+        self.subworkflow_inputs = merged_inputs  # type: ignore[misc]
 
         # Call the parent run method to execute the subworkflow with proper streaming
         outputs = {}
@@ -221,10 +209,8 @@ class FunctionNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         result: Any
 
     def run(self) -> Iterator[BaseOutput]:
-        arguments = self._extract_function_arguments()
-
         try:
-            result = self.function_definition(**arguments)
+            result = self.function_definition(**self.arguments)
         except Exception as e:
             self._handle_tool_exception(e, "function", self.function_definition.__name__)
 
@@ -240,18 +226,15 @@ class ComposioNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
     composio_tool: ComposioToolDefinition
 
     def run(self) -> Iterator[BaseOutput]:
-        # Extract arguments from function call
-        arguments = self._extract_function_arguments()
-
         try:
             # Execute using ComposioService
             composio_service = ComposioService()
             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
+                    tool_name=self.composio_tool.action, arguments=self.arguments, user_id=self.composio_tool.user_id
                 )
             else:
-                result = composio_service.execute_tool(tool_name=self.composio_tool.action, arguments=arguments)
+                result = composio_service.execute_tool(tool_name=self.composio_tool.action, arguments=self.arguments)
         except Exception as e:
             self._handle_tool_exception(e, "Composio tool", self.composio_tool.action)
 
@@ -270,11 +253,9 @@ class MCPNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         result: Any
 
     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)
+            result = mcp_service.execute_tool(tool_def=self.mcp_tool, arguments=self.arguments)
         except Exception as e:
             self._handle_tool_exception(e, "MCP tool", self.mcp_tool.name)
 
@@ -293,7 +274,6 @@ class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
         result: Any
 
     def run(self) -> Iterator[BaseOutput]:
-        arguments = self._extract_function_arguments()
         vellum_client = self._context.vellum_client
 
         try:
@@ -302,7 +282,8 @@ class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
                 integration=self.vellum_integration_tool.integration_name,
                 provider=self.vellum_integration_tool.provider.value,
                 tool_name=self.vellum_integration_tool.name,
-                arguments=arguments,
+                arguments=self.arguments,
+                toolkit_version=self.vellum_integration_tool.toolkit_version,
             )
         except NodeException as e:
             error_payload = {
@@ -315,7 +296,7 @@ class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
                 error_payload["error"]["raw_data"] = e.raw_data
 
             self._add_function_result_to_chat_history(error_payload, self.state)
-            yield from []
+            yield BaseOutput(name="result", value=error_payload["error"])
             return
         except Exception as e:
             self._handle_tool_exception(e, "Vellum Integration tool", self.vellum_integration_tool.name)
@@ -348,7 +329,7 @@ class ElseNode(BaseNode[ToolCallingState]):
 def create_tool_prompt_node(
     ml_model: str,
     blocks: List[Union[PromptBlock, Dict[str, Any]]],
-    functions: List[Tool],
+    functions: List[Union[ToolBase, MCPToolDefinition]],
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
     max_prompt_iterations: Optional[int] = None,
@@ -357,7 +338,7 @@ def create_tool_prompt_node(
     settings: Optional[Union[PromptSettings, Dict[str, Any]]] = None,
 ) -> Type[ToolPromptNode]:
     if functions and len(functions) > 0:
-        prompt_functions: List[Tool] = functions
+        prompt_functions: List[Union[ToolBase, MCPToolDefinition]] = functions
     else:
         prompt_functions = []
 
@@ -422,8 +403,28 @@ def create_tool_prompt_node(
     return node
 
 
+def _create_function_call_expressions(
+    tool_prompt_node: Type[ToolPromptNode],
+) -> tuple[BaseDescriptor[dict], BaseDescriptor[Optional[str]]]:
+    """
+    Create expressions to extract arguments and function_call_id from tool_prompt_node outputs.
+
+    Returns:
+        A tuple of (arguments_expression, function_call_id_expression)
+
+    Note: These expressions assume the output at current_prompt_output_index is a valid FUNCTION_CALL.
+    The router node ensures this before routing to function nodes.
+    """
+    current_output = tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]
+    # Extract arguments and function_call_id directly from the function call value
+    # Using coalesce to provide safe fallbacks if the structure is unexpected
+    arguments_expr: BaseDescriptor[dict] = current_output["value"]["arguments"].coalesce({})
+    function_call_id_expr: BaseDescriptor[Optional[str]] = current_output["value"]["id"].coalesce(None)
+    return arguments_expr, function_call_id_expr
+
+
 def create_router_node(
-    functions: List[Tool],
+    functions: List[Union[ToolBase, MCPToolDefinition]],
     tool_prompt_node: Type[InlinePromptNode[ToolCallingState]],
 ) -> Type[RouterNode]:
     """Create a RouterNode with dynamic ports that route based on tool_prompt_node outputs."""
@@ -433,14 +434,7 @@ def create_router_node(
         Ports = type("Ports", (), {})
 
         # Collect all tool names
-        tool_names: List[str] = []
-        for function in functions:
-            if isinstance(function, MCPServer):
-                tool_functions: List[MCPToolDefinition] = compile_mcp_tool_definition(function)
-                for tool_function in tool_functions:
-                    tool_names.append(get_mcp_tool_name(tool_function))
-            else:
-                tool_names.append(get_function_name(function))
+        tool_names: List[str] = [get_function_name(function) for function in functions]
 
         # Build conditions for each tool name
         conditions = [
@@ -484,7 +478,7 @@ def create_router_node(
 
 
 def create_function_node(
-    function: ToolBase,
+    function: Union[ToolBase, MCPToolDefinition],
     tool_prompt_node: Type[ToolPromptNode],
 ) -> Type[BaseNode]:
     """
@@ -492,11 +486,17 @@ def create_function_node(
 
     For workflow functions: BaseNode
     For regular functions: BaseNode with direct function call
+    For MCP tools: MCPNode
 
     Args:
         function: The function to create a node for
         tool_prompt_node: The tool prompt node class
     """
+    if isinstance(function, MCPToolDefinition):
+        return create_mcp_tool_node(function, tool_prompt_node)
+
+    arguments_expr, function_call_id_expr = _create_function_call_expressions(tool_prompt_node)
+
     if isinstance(function, DeploymentDefinition):
         deployment = function.deployment_id or function.deployment_name
         release_tag = function.release_tag
@@ -507,7 +507,8 @@ def create_function_node(
             {
                 "deployment": deployment,
                 "release_tag": release_tag,
-                "function_call_output": tool_prompt_node.Outputs.results,
+                "arguments": arguments_expr,
+                "function_call_id": function_call_id_expr,
                 "__module__": __name__,
             },
         )
@@ -520,18 +521,26 @@ def create_function_node(
             (ComposioNode,),
             {
                 "composio_tool": function,
-                "function_call_output": tool_prompt_node.Outputs.results,
+                "arguments": arguments_expr,
+                "function_call_id": function_call_id_expr,
                 "__module__": __name__,
             },
         )
         return node
     elif isinstance(function, VellumIntegrationToolDefinition):
+        display_class = type(
+            f"VellumIntegrationNodeDisplay_{function.name}",
+            (VellumIntegrationNode.Display,),
+            {"icon": "vellum:icon:plug", "color": "navy"},
+        )
         node = type(
             f"VellumIntegrationNode_{function.name}",
             (VellumIntegrationNode,),
             {
                 "vellum_integration_tool": function,
-                "function_call_output": tool_prompt_node.Outputs.results,
+                "arguments": arguments_expr,
+                "function_call_id": function_call_id_expr,
+                "Display": display_class,
                 "__module__": __name__,
             },
         )
@@ -543,7 +552,8 @@ def create_function_node(
             (DynamicInlineSubworkflowNode,),
             {
                 "subworkflow": function,
-                "function_call_output": tool_prompt_node.Outputs.results,
+                "arguments": arguments_expr,
+                "function_call_id": function_call_id_expr,
                 "__module__": __name__,
             },
         )
@@ -567,12 +577,19 @@ def create_function_node(
             wrapper.__name__ = func.__name__
             return wrapper
 
+        display_class = type(
+            f"FunctionNodeDisplay_{function.__name__}",
+            (FunctionNode.Display,),
+            {"icon": "vellum:icon:rectangle-code", "color": "purple"},
+        )
         node = type(
             f"FunctionNode_{function.__name__}",
             (FunctionNode,),
             {
                 "function_definition": create_function_wrapper(function),
-                "function_call_output": tool_prompt_node.Outputs.results,
+                "arguments": arguments_expr,
+                "function_call_id": function_call_id_expr,
+                "Display": display_class,
                 "__module__": __name__,
             },
         )
@@ -584,12 +601,14 @@ def create_mcp_tool_node(
     tool_def: MCPToolDefinition,
     tool_prompt_node: Type[ToolPromptNode],
 ) -> Type[BaseNode]:
+    arguments_expr, function_call_id_expr = _create_function_call_expressions(tool_prompt_node)
     node = type(
         f"MCPNode_{tool_def.name}",
         (MCPNode,),
         {
             "mcp_tool": tool_def,
-            "function_call_output": tool_prompt_node.Outputs.results,
+            "arguments": arguments_expr,
+            "function_call_id": function_call_id_expr,
             "__module__": __name__,
         },
     )
@@ -620,8 +639,10 @@ def create_else_node(
     return node
 
 
-def get_function_name(function: ToolBase) -> str:
-    if isinstance(function, DeploymentDefinition):
+def get_function_name(function: Union[ToolBase, MCPToolDefinition]) -> str:
+    if isinstance(function, MCPToolDefinition):
+        return get_mcp_tool_name(function)
+    elif isinstance(function, DeploymentDefinition):
         name = str(function.deployment_id or function.deployment_name)
         return name.replace("-", "")
     elif isinstance(function, ComposioToolDefinition):