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

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

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

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

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

{vellum_ai-1.7.2 → 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.2",
+            "User-Agent": "vellum-ai/1.7.3",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.2",
+            "X-Fern-SDK-Version": "1.7.3",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.7.2 → 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.2 → 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.2 → vellum_ai-1.7.3}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -409,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"
@@ -419,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.2 → 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.2 → 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(

vellum_ai-1.7.3/src/vellum/workflows/types/__init__.py

@@ -0,0 +1,6 @@
+from .core import CancelSignal, MergeBehavior
+
+__all__ = [
+    "CancelSignal",
+    "MergeBehavior",
+]

{vellum_ai-1.7.2 → vellum_ai-1.7.3}/src/vellum/workflows/types/core.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from threading import Event as ThreadingEvent
 from typing import (  # type: ignore[attr-defined]
     Any,
     Dict,
@@ -15,6 +16,8 @@ JsonArray = List["Json"]
 JsonObject = Dict[str, "Json"]
 Json = Union[None, bool, int, float, str, JsonArray, JsonObject]
 
+CancelSignal = ThreadingEvent
+
 # Unions and Generics inherit from `_GenericAlias` instead of `type`
 # In future versions of python, we'll see `_UnionGenericAlias`
 UnderGenericAlias = _GenericAlias

vellum_ai-1.7.2/src/vellum/workflows/types/__init__.py

@@ -1,5 +0,0 @@
-from .core import MergeBehavior
-
-__all__ = [
-    "MergeBehavior",
-]