vellum-ai 1.7.1__tar.gz → 1.7.3__tar.gz

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/PKG-INFO

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

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/pyproject.toml

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

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/client/core/client_wrapper.py

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

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/errors/types.py

@@ -43,6 +43,7 @@ _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErr
     "INVALID_INPUTS": WorkflowErrorCode.INVALID_INPUTS,
     "PROVIDER_ERROR": WorkflowErrorCode.PROVIDER_ERROR,
     "PROVIDER_CREDENTIALS_UNAVAILABLE": WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+    "INTEGRATION_CREDENTIALS_UNAVAILABLE": WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE,
     "REQUEST_TIMEOUT": WorkflowErrorCode.PROVIDER_ERROR,
     "INTERNAL_SERVER_ERROR": WorkflowErrorCode.INTERNAL_ERROR,
     "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,
@@ -95,7 +96,7 @@ _WORKFLOW_ERROR_CODE_TO_VELLUM_ERROR_CODE: Dict[WorkflowErrorCode, VellumErrorCo
     WorkflowErrorCode.NODE_EXECUTION: "USER_DEFINED_ERROR",
     WorkflowErrorCode.PROVIDER_ERROR: "PROVIDER_ERROR",
     WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE: "PROVIDER_CREDENTIALS_UNAVAILABLE",
-    WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE: "PROVIDER_CREDENTIALS_UNAVAILABLE",
+    WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE: "INTEGRATION_CREDENTIALS_UNAVAILABLE",
     WorkflowErrorCode.USER_DEFINED_ERROR: "USER_DEFINED_ERROR",
     WorkflowErrorCode.WORKFLOW_CANCELLED: "REQUEST_TIMEOUT",
 }

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/integrations/tests/test_vellum_integration_service.py

@@ -12,6 +12,7 @@ from vellum.workflows.types.definition import VellumIntegrationToolDetails
 
 def test_vellum_integration_service_get_tool_definition_success(vellum_client):
     """Test that tool definitions are successfully retrieved from Vellum API"""
+    # GIVEN a mock client configured to return a tool definition
     mock_client = vellum_client
     tool_definition_response = ComponentsSchemasComposioToolDefinition(
         integration=ToolDefinitionIntegration(
@@ -33,7 +34,6 @@ def test_vellum_integration_service_get_tool_definition_success(vellum_client):
         },
         output_parameters={},
     )
-
     mock_client.integrations.retrieve_integration_tool_definition.return_value = tool_definition_response
 
     # WHEN we request a tool definition
@@ -66,6 +66,7 @@ def test_vellum_integration_service_get_tool_definition_success(vellum_client):
 
 def test_vellum_integration_service_get_tool_definition_api_error(vellum_client):
     """Test that API errors are properly handled when retrieving tool definitions"""
+    # GIVEN a mock client configured to raise an exception
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
     mock_client.integrations.retrieve_integration_tool_definition.side_effect = Exception("Tool not found")
@@ -87,6 +88,7 @@ def test_vellum_integration_service_get_tool_definition_api_error(vellum_client)
 
 def test_vellum_integration_service_execute_tool_success(vellum_client):
     """Test that tools are successfully executed via Vellum API"""
+    # GIVEN a mock client configured to return a successful response
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
 
@@ -96,7 +98,6 @@ def test_vellum_integration_service_execute_tool_success(vellum_client):
         "issue_id": 123,
         "issue_url": "https://github.com/user/repo/issues/123",
     }
-
     mock_client.integrations.execute_integration_tool.return_value = mock_response
 
     # WHEN we execute a tool with valid arguments
@@ -132,6 +133,7 @@ def test_vellum_integration_service_execute_tool_success(vellum_client):
 
 def test_vellum_integration_service_execute_tool_api_error(vellum_client):
     """Test that execution errors are properly handled"""
+    # GIVEN a mock client configured to raise an exception
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
     mock_client.integrations.execute_integration_tool.side_effect = Exception("Authentication failed")
@@ -154,12 +156,12 @@ def test_vellum_integration_service_execute_tool_api_error(vellum_client):
 
 def test_vellum_integration_service_execute_tool_empty_response(vellum_client):
     """Test that empty response data is handled gracefully"""
+    # GIVEN a mock client configured to return an empty response
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
 
     mock_response = mock.MagicMock()
     mock_response.data = {}
-
     mock_client.integrations.execute_integration_tool.return_value = mock_response
 
     # WHEN we execute a tool that returns empty data
@@ -180,6 +182,7 @@ def test_vellum_integration_service_execute_tool_empty_response(vellum_client):
 
 def test_vellum_integration_service_multiple_tool_executions(vellum_client):
     """Test that the service handles multiple sequential tool executions"""
+    # GIVEN a mock client configured to return different responses for multiple calls
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
 
@@ -214,16 +217,18 @@ def test_vellum_integration_service_multiple_tool_executions(vellum_client):
     assert mock_client.integrations.execute_integration_tool.call_count == 2
 
 
-def test_vellum_integration_service_execute_tool_structured_403_error(vellum_client):
-    """Test that structured 403 responses with integration details are properly parsed"""
+def test_vellum_integration_service_execute_tool_structured_403_with_integration(vellum_client):
+    """Test structured 403 responses with integration field (current backend format)"""
     from vellum.client.core.api_error import ApiError
     from vellum.workflows.errors.types import WorkflowErrorCode
 
+    # GIVEN a mock client configured to raise a structured 403 error with integration
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
 
-    # Mock structured 403 response matching PR #14857 format
+    # Mock current backend structure with integration as direct field
     structured_error_body = {
+        "code": "INTEGRATION_CREDENTIALS_UNAVAILABLE",
         "message": "You must authenticate with this integration before you can execute this tool.",
         "integration": {
             "id": "550e8400-e29b-41d4-a716-446655440000",
@@ -231,15 +236,13 @@ def test_vellum_integration_service_execute_tool_structured_403_error(vellum_cli
             "name": "GITHUB",
         },
     }
-
     mock_client.integrations.execute_integration_tool.side_effect = ApiError(
         status_code=403,
         body=structured_error_body,
     )
 
-    service = VellumIntegrationService(client=mock_client)
-
     # WHEN we attempt to execute a tool without credentials
+    service = VellumIntegrationService(client=mock_client)
     with pytest.raises(NodeException) as exc_info:
         service.execute_tool(
             integration="GITHUB",
@@ -266,19 +269,18 @@ def test_vellum_integration_service_execute_tool_legacy_403_error(vellum_client)
     from vellum.client.core.api_error import ApiError
     from vellum.workflows.errors.types import WorkflowErrorCode
 
+    # GIVEN a mock client configured to raise a legacy 403 error
     mock_client = vellum_client
     mock_client.integrations = mock.MagicMock()
 
-    # Mock legacy 403 response format (just detail field)
     legacy_error_body = {"detail": "You do not have permission to execute this tool."}
-
     mock_client.integrations.execute_integration_tool.side_effect = ApiError(
         status_code=403,
         body=legacy_error_body,
     )
 
+    # WHEN we attempt to execute a tool that returns a legacy 403 error
     service = VellumIntegrationService(client=mock_client)
-
     with pytest.raises(NodeException) as exc_info:
         service.execute_tool(
             integration="GITHUB",

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/integrations/vellum_integration_service.py

@@ -95,15 +95,15 @@ class VellumIntegrationService:
         except ApiError as e:
             # Handle structured 403 credential error responses
             if e.status_code == 403 and isinstance(e.body, dict):
-                if "integration" in e.body and "message" in e.body:
-                    integration_details = e.body["integration"]
-                    error_message = e.body["message"]
-
-                    # Keep integration details nested under "integration" key to keep raw_data raw
-                    # and allow for future expansion
-                    raw_data = {
-                        "integration": integration_details,
-                    }
+                # Check for backend structure with integration as direct field
+                integration_from_backend = e.body.get("integration")
+                if integration_from_backend:
+                    error_message = e.body.get(
+                        "message", "You must authenticate with this integration before you can execute this tool."
+                    )
+
+                    # Wrap integration in raw_data for frontend consumption
+                    raw_data = {"integration": integration_from_backend}
 
                     raise NodeException(
                         message=error_message,

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -117,13 +117,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                     request_options=self.request_options,
                 )
             except ApiError as e:
-                if e.status_code == 400 and isinstance(e.body, dict) and "message" in e.body:
-                    raise NodeException(
-                        message=e.body["message"],
-                        code=WorkflowErrorCode.INVALID_INPUTS,
-                    )
-
-                raise
+                self._handle_api_error(e)
 
             if code_execution_result.output.type != expected_output_type:
                 actual_type = code_execution_result.output.type
@@ -134,6 +128,24 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
 
             return self.Outputs(result=code_execution_result.output.value, log=code_execution_result.log)
 
+    def _handle_api_error(self, e: ApiError) -> None:
+        if e.status_code and e.status_code == 403 and isinstance(e.body, dict):
+            raise NodeException(
+                message=e.body.get("detail", "Provider credentials is missing or unavailable"),
+                code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+            ) from e
+
+        if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
+            raise NodeException(
+                message=e.body.get("message", e.body.get("detail", "Failed to execute code")),
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            ) from e
+
+        raise NodeException(
+            message="Failed to execute code",
+            code=WorkflowErrorCode.INTERNAL_ERROR,
+        ) from e
+
     def _has_secrets_in_code_inputs(self) -> bool:
         """Check if any code_inputs contain VellumSecret instances that require API execution."""
         for input_value in self.code_inputs.values():

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py

@@ -6,7 +6,11 @@ from typing import Any, List, Union
 from pydantic import BaseModel
 
 from vellum import ArrayInput, CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum.client.core.api_error import ApiError
 from vellum.client.errors.bad_request_error import BadRequestError
+from vellum.client.errors.forbidden_error import ForbiddenError
+from vellum.client.errors.internal_server_error import InternalServerError
+from vellum.client.errors.not_found_error import NotFoundError
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
@@ -792,6 +796,103 @@ Node.js v21.7.3
     assert exc_info.value.message == message
 
 
+def test_run_node__execute_code_api_fails_403__provider_credentials_unavailable(vellum_client):
+    """
+    Tests that a 403 error from the API is handled with PROVIDER_CREDENTIALS_UNAVAILABLE error code.
+    """
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = "def main(): return 'test'"
+        runtime = "PYTHON_3_11_6"
+        packages = [CodeExecutionPackage(name="requests", version="2.28.0")]
+
+    vellum_client.execute_code.side_effect = ForbiddenError(
+        body={
+            "detail": "Provider credentials is missing or unavailable",
+        }
+    )
+
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE
+    assert "Provider credentials is missing or unavailable" in exc_info.value.message
+
+
+def test_run_node__execute_code_api_fails_404__invalid_inputs(vellum_client):
+    """
+    Tests that a 404 error from the API is handled with INVALID_INPUTS error code.
+    """
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = "def main(): return 'test'"
+        runtime = "PYTHON_3_11_6"
+        packages = [CodeExecutionPackage(name="requests", version="2.28.0")]
+
+    vellum_client.execute_code.side_effect = NotFoundError(
+        body={
+            "detail": "Resource not found",
+        }
+    )
+
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Resource not found" in exc_info.value.message
+
+
+def test_run_node__execute_code_api_fails_500__internal_error(vellum_client):
+    """
+    Tests that a 500 error from the API is handled with INTERNAL_ERROR error code.
+    """
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = "def main(): return 'test'"
+        runtime = "PYTHON_3_11_6"
+        packages = [CodeExecutionPackage(name="requests", version="2.28.0")]
+
+    vellum_client.execute_code.side_effect = InternalServerError(
+        body={
+            "detail": "Internal server error occurred",
+        }
+    )
+
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INTERNAL_ERROR
+    assert exc_info.value.message == "Failed to execute code"
+
+
+def test_run_node__execute_code_api_fails_4xx_no_message__uses_detail(vellum_client):
+    """
+    Tests that a 4xx error without a 'message' field falls back to 'detail' field.
+    """
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = "def main(): return 'test'"
+        runtime = "PYTHON_3_11_6"
+        packages = [CodeExecutionPackage(name="requests", version="2.28.0")]
+
+    vellum_client.execute_code.side_effect = ApiError(
+        status_code=422,
+        body={
+            "detail": "Invalid request parameters",
+        },
+    )
+
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Invalid request parameters" in exc_info.value.message
+
+
 def test_run_node__execute_code__list_extends():
     # GIVEN a node that will return a list with output type Json
     class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Json]):

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -22,8 +22,8 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
 )
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.core import EntityInputsInterface, Tool
-from vellum.workflows.types.definition import MCPServer
+from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.definition import MCPServer, Tool
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.utils.functions import compile_mcp_tool_definition, get_mcp_tool_name
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py

@@ -24,6 +24,7 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_tool_prompt_node,
 )
 from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.ports.utils import validate_ports
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.definition import DeploymentDefinition
@@ -38,6 +39,55 @@ def second_function() -> str:
     return "second_function"
 
 
+def test_router_node_port_ordering_with_multiple_tools():
+    """
+    Test that router node ports are created in the correct order: on_if, on_elif, ..., on_else.
+
+    This test validates the fix for the bug where multiple tools would create multiple on_if
+    ports instead of on_if followed by on_elif ports, which violates port validation rules.
+    """
+
+    # GIVEN three functions to ensure we test multiple elif cases
+    def third_function() -> str:
+        return "third_function"
+
+    # AND a tool prompt node
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="test-model",
+        blocks=[],
+        functions=[first_function, second_function, third_function],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+    )
+
+    # WHEN a router node is created with multiple functions
+    router_node = create_router_node(
+        functions=[first_function, second_function, third_function],
+        tool_prompt_node=tool_prompt_node,
+    )
+
+    # THEN the first function port should be an on_if port
+    first_function_port = getattr(router_node.Ports, "first_function")
+    assert first_function_port._condition_type.value == "IF"
+
+    # AND the second function port should be an on_elif port
+    second_function_port = getattr(router_node.Ports, "second_function")
+    assert second_function_port._condition_type.value == "ELIF"
+
+    # AND the third function port should also be an on_elif port
+    third_function_port = getattr(router_node.Ports, "third_function")
+    assert third_function_port._condition_type.value == "ELIF"
+
+    # AND the default port should be an on_else port
+    default_port = getattr(router_node.Ports, "default")
+    assert default_port._condition_type.value == "ELSE"
+
+    # AND the ports should pass validation
+    ports = [first_function_port, second_function_port, third_function_port, default_port]
+    # This should not raise an exception
+    validate_ports(ports)
+
+
 def test_port_condition_match_function_name():
     """
     Test that the port condition correctly matches the function name.

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -31,12 +31,14 @@ from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
-from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolBase
+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
@@ -203,7 +205,7 @@ class FunctionNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
             raise NodeException(
                 message=f"Error executing function '{function_name}': {str(e)}",
                 code=WorkflowErrorCode.NODE_EXECUTION,
-            )
+            ) from e
 
         # Add the result to the chat history
         self._add_function_result_to_chat_history(result, self.state)
@@ -233,7 +235,7 @@ class ComposioNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
             raise NodeException(
                 message=f"Error executing Composio tool '{self.composio_tool.action}': {str(e)}",
                 code=WorkflowErrorCode.NODE_EXECUTION,
-            )
+            ) from e
 
         # Add result to chat history
         self._add_function_result_to_chat_history(result, self.state)
@@ -256,7 +258,7 @@ class MCPNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
             raise NodeException(
                 message=f"Error executing MCP tool '{self.mcp_tool.name}': {str(e)}",
                 code=WorkflowErrorCode.NODE_EXECUTION,
-            )
+            ) from e
 
         # Add result to chat history
         self._add_function_result_to_chat_history(result, self.state)
@@ -281,11 +283,18 @@ class VellumIntegrationNode(BaseNode[ToolCallingState], FunctionCallNodeMixin):
                 tool_name=self.vellum_integration_tool.name,
                 arguments=arguments,
             )
+        except NodeException as e:
+            # Preserve original error code and raw_data while adding context
+            raise NodeException(
+                message=f"Error executing Vellum Integration tool '{self.vellum_integration_tool.name}': {e.message}",
+                code=e.code,
+                raw_data=e.raw_data,
+            ) from e
         except Exception as e:
             raise NodeException(
                 message=f"Error executing Vellum Integration tool '{self.vellum_integration_tool.name}': {str(e)}",
                 code=WorkflowErrorCode.NODE_EXECUTION,
-            )
+            ) from e
 
         # Add result to chat history
         self._add_function_result_to_chat_history(result, self.state)
@@ -400,8 +409,8 @@ def create_router_node(
         # 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(
+        def create_port_condition(fn_name, is_first):
+            condition = (
                 ToolCallingState.current_prompt_output_index.less_than(tool_prompt_node.Outputs.results.length())
                 & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
                     "FUNCTION_CALL"
@@ -410,26 +419,33 @@ def create_router_node(
                     "name"
                 ].equals(fn_name)
             )
+            # First port should be on_if, subsequent ports should be on_elif
+            return Port.on_if(condition) if is_first else Port.on_elif(condition)
 
+        is_first_port = True
         for function in functions:
             if isinstance(function, ComposioToolDefinition):
                 function_name = get_function_name(function)
-                port = create_port_condition(function_name)
+                port = create_port_condition(function_name, is_first_port)
                 setattr(Ports, function_name, port)
+                is_first_port = False
             elif isinstance(function, VellumIntegrationToolDefinition):
                 function_name = get_function_name(function)
-                port = create_port_condition(function_name)
+                port = create_port_condition(function_name, is_first_port)
                 setattr(Ports, function_name, port)
+                is_first_port = False
             elif isinstance(function, MCPServer):
                 tool_functions: List[MCPToolDefinition] = compile_mcp_tool_definition(function)
                 for tool_function in tool_functions:
                     name = get_mcp_tool_name(tool_function)
-                    port = create_port_condition(name)
+                    port = create_port_condition(name, is_first_port)
                     setattr(Ports, name, port)
+                    is_first_port = False
             else:
                 function_name = get_function_name(function)
-                port = create_port_condition(function_name)
+                port = create_port_condition(function_name, is_first_port)
                 setattr(Ports, function_name, port)
+                is_first_port = False
 
         # Add the else port for when no function conditions match
         setattr(Ports, "default", Port.on_else())

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/resolvers/resolver.py

@@ -52,15 +52,6 @@ class VellumResolver(BaseWorkflowResolver):
         if response.state is None:
             return None
 
-        if (
-            response.previous_trace_id is None
-            or response.root_trace_id is None
-            or response.previous_span_id is None
-            or response.root_span_id is None
-        ):
-            logger.warning("Could not find required execution events for state loading")
-            return None
-
         if "meta" in response.state:
             response.state.pop("meta")
 
@@ -71,6 +62,20 @@ class VellumResolver(BaseWorkflowResolver):
             logger.warning("No workflow class registered, falling back to BaseState")
             state = BaseState(**response.state)
 
+        if (
+            response.previous_trace_id is None
+            or response.root_trace_id is None
+            or response.previous_span_id is None
+            or response.root_span_id is None
+        ):
+            return LoadStateResult(
+                state=state,
+                previous_trace_id=response.trace_id,
+                previous_span_id=response.span_id,
+                root_trace_id=response.trace_id,
+                root_span_id=response.span_id,
+            )
+
         return LoadStateResult(
             state=state,
             previous_trace_id=response.previous_trace_id,

{vellum_ai-1.7.1 → vellum_ai-1.7.3}/src/vellum/workflows/runner/runner.py

@@ -695,6 +695,34 @@ class WorkflowRunner(Generic[StateType]):
 
         return None
 
+    def _emit_node_cancellation_events(
+        self,
+        error_message: str,
+        parent_context: Optional[ParentContext],
+    ) -> None:
+        """
+        Emit node cancellation events for all active nodes.
+
+        Args:
+            error_message: The error message to include in the cancellation events
+            parent_context: The parent context for the cancellation events
+        """
+        for span_id, active_node in list(self._active_nodes_by_execution_id.items()):
+            rejection_event = NodeExecutionRejectedEvent(
+                trace_id=self._execution_context.trace_id,
+                span_id=span_id,
+                body=NodeExecutionRejectedBody(
+                    node_definition=active_node.node.__class__,
+                    error=WorkflowError(
+                        code=WorkflowErrorCode.NODE_CANCELLED,
+                        message=error_message,
+                    ),
+                ),
+                parent=parent_context,
+            )
+            self._workflow_event_outer_queue.put(rejection_event)
+            self._active_nodes_by_execution_id.pop(span_id)
+
     def _initiate_workflow_event(self) -> WorkflowExecutionInitiatedEvent:
         links: Optional[List[SpanLink]] = None
 
@@ -848,21 +876,10 @@ class WorkflowRunner(Generic[StateType]):
 
             if rejection_event:
                 failed_node_name = rejection_event.body.node_definition.__name__
-                for active_span_id, active_node_data in list(self._active_nodes_by_execution_id.items()):
-                    cancellation_event = NodeExecutionRejectedEvent(
-                        trace_id=self._execution_context.trace_id,
-                        span_id=active_span_id,
-                        body=NodeExecutionRejectedBody(
-                            node_definition=active_node_data.node.__class__,
-                            error=WorkflowError(
-                                message=f"Node execution cancelled due to {failed_node_name} failure",
-                                code=WorkflowErrorCode.NODE_CANCELLED,
-                            ),
-                        ),
-                        parent=self._execution_context.parent_context,
-                    )
-                    self._workflow_event_outer_queue.put(cancellation_event)
-                    self._active_nodes_by_execution_id.pop(active_span_id)
+                self._emit_node_cancellation_events(
+                    error_message=f"Node execution cancelled due to {failed_node_name} failure",
+                    parent_context=self._execution_context.parent_context,
+                )
                 break
 
         # Handle any remaining events
@@ -932,6 +949,17 @@ class WorkflowRunner(Generic[StateType]):
 
         while not kill_switch.wait(timeout=0.1):
             if self._cancel_signal.is_set():
+                parent_context = WorkflowParentContext(
+                    span_id=self._initial_state.meta.span_id,
+                    workflow_definition=self.workflow.__class__,
+                    parent=self._execution_context.parent_context,
+                )
+
+                self._emit_node_cancellation_events(
+                    error_message="Workflow run cancelled",
+                    parent_context=parent_context,
+                )
+
                 self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
                         WorkflowError(