vellum-ai 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

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

@@ -114,6 +114,11 @@ def test_serialize_workflow():
                 "name": "FailNode",
                 "module": ["tests", "workflows", "basic_error_node", "workflow"],
             },
+            "trigger": {
+                "id": "70c19f1c-309c-4a5d-ba65-664c0bb2fedf",
+                "merge_behavior": "AWAIT_ATTRIBUTES",
+            },
+            "ports": [],
         },
         error_node,
         ignore_order=True,

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

@@ -117,6 +117,10 @@ def test_serialize_workflow():
             "module": ["tests", "workflows", "basic_guardrail_node", "workflow"],
             "name": "ExampleGuardrailNode",
         },
+        "trigger": {
+            "id": "ce5b85b1-eded-46dd-b4b7-020afcdc67ab",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "0ed87407-697e-4ae9-ab9b-6c5cc2e57cf7", "name": "default", "type": "DEFAULT"}],
     }
 

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

@@ -324,6 +324,10 @@ def test_serialize_workflow():
                 "name": "ExampleInlineSubworkflowNode",
                 "module": ["tests", "workflows", "basic_inline_subworkflow", "workflow"],
             },
+            "trigger": {
+                "id": "859a75a6-1bd2-4350-9509-4af66245e8e4",
+                "merge_behavior": "AWAIT_ATTRIBUTES",
+            },
             "ports": [{"id": "cfd831bc-ee7f-44d0-8d76-0ba0cd0277dc", "name": "default", "type": "DEFAULT"}],
         },
         subworkflow_node,

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

@@ -286,6 +286,10 @@ def test_serialize_workflow():
                 "name": "MapFruitsNode",
                 "module": ["tests", "workflows", "basic_map_node", "workflow"],
             },
+            "trigger": {
+                "id": "b5e8182e-20c5-482b-b4c5-4dde48c01472",
+                "merge_behavior": "AWAIT_ATTRIBUTES",
+            },
             "ports": [{"id": "a2171a61-0657-43ad-b6d9-cf93ce3270d0", "name": "default", "type": "DEFAULT"}],
         },
         map_node,

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

@@ -83,6 +83,10 @@ def test_serialize_workflow__await_all():
                 "module": ["tests", "workflows", "basic_merge_node", "await_all_workflow"],
                 "name": "AwaitAllMergeNode",
             },
+            "trigger": {
+                "id": "0efd256f-f5f6-45fe-9adb-651780f5e63d",
+                "merge_behavior": "AWAIT_ALL",
+            },
             "ports": [{"id": "3bbc469f-0fb0-4b3d-a28b-746fefec2818", "name": "default", "type": "DEFAULT"}],
         },
         merge_node,

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

@@ -150,6 +150,10 @@ def test_serialize_workflow(vellum_client):
             "name": "ExamplePromptDeploymentNode",
             "module": ["tests", "workflows", "basic_text_prompt_deployment", "workflow"],
         },
+        "trigger": {
+            "id": "b7605c48-0937-4ecc-914e-0d1058130e65",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "2f26c7e0-283d-4f04-b639-adebb56bc679", "name": "default", "type": "DEFAULT"}],
         "outputs": [
             {"id": "180355a8-e67c-4ce6-9ac3-e5dbb75a6629", "name": "json", "type": "JSON", "value": None},
@@ -384,6 +388,10 @@ def test_serialize_workflow_with_prompt_and_templating(vellum_client):
                 "workflow_with_prompt_deployment_json_reference",
             ],
         },
+        "trigger": {
+            "id": "b7605c48-0937-4ecc-914e-0d1058130e65",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "2f26c7e0-283d-4f04-b639-adebb56bc679", "name": "default", "type": "DEFAULT"}],
         "outputs": [
             {"id": "180355a8-e67c-4ce6-9ac3-e5dbb75a6629", "name": "json", "type": "JSON", "value": None},
@@ -479,6 +487,10 @@ def test_serialize_workflow_with_prompt_and_templating(vellum_client):
                 "workflow_with_prompt_deployment_json_reference",
             ],
         },
+        "trigger": {
+            "id": "58427684-3848-498a-8299-c6b0fc70265d",
+            "merge_behavior": "AWAIT_ATTRIBUTES",
+        },
         "ports": [{"id": "39317827-df43-4f5a-bfbc-20bffc839748", "name": "default", "type": "DEFAULT"}],
     }
 

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

@@ -238,6 +238,10 @@ def test_serialize_workflow():
             "name": "SimpleSearchNode",
             "module": ["tests", "workflows", "basic_search_node", "workflow"],
         },
+        "trigger": {
+            "id": "6d50305f-588b-469f-a042-b0767d3f99b1",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "00ae06b3-f8d9-4ae6-9fbf-e4ff4d520e9b", "name": "default", "type": "DEFAULT"}],
     }
 

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

@@ -153,6 +153,10 @@ def test_serialize_workflow(vellum_client):
             "module": ["tests", "workflows", "basic_subworkflow_deployment", "workflow"],
             "name": "ExampleSubworkflowDeploymentNode",
         },
+        "trigger": {
+            "id": "e4d80502-9281-42c8-91e3-10817bcd7d9e",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "ab0db8a9-7b53-4d88-8667-273b31303273", "name": "default", "type": "DEFAULT"}],
     }
 

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

@@ -112,6 +112,10 @@ def test_serialize_workflow():
                 "name": "ExampleTemplatingNode",
                 "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
             },
+            "trigger": {
+                "id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "merge_behavior": "AWAIT_ATTRIBUTES",
+            },
             "ports": [{"id": "39317827-df43-4f5a-bfbc-20bffc839748", "name": "default", "type": "DEFAULT"}],
         },
         templating_node,

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

@@ -103,4 +103,9 @@ def test_serialize_workflow():
                 "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},
             }
         ],
+        "trigger": {
+            "id": "0173d3c6-11d1-44b7-b070-ca9ff5119046",
+            "merge_behavior": "AWAIT_ANY",
+        },
+        "ports": [],
     }

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

@@ -54,6 +54,7 @@ def test_serialize_workflow():
         "action": "GITHUB_CREATE_AN_ISSUE",
         "description": "Create a new issue in a GitHub repository",
         "user_id": None,
+        "name": "github_create_an_issue",
     }
 
     # AND the rest of the node structure should be correct

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

@@ -81,6 +81,11 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
+                "trigger": {
+                    "id": "a0c2eb7a-398e-4f28-b63d-f3bae9b563ee",
+                    "merge_behavior": "AWAIT_ANY",
+                },
+                "ports": [],
             },
             {
                 "id": "bb88768d-472e-4997-b7ea-de09163d1b4c",

vellum_ee/workflows/display/utils/expressions.py

@@ -11,6 +11,7 @@ from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+from vellum.workflows.expressions.concat import ConcatExpression
 from vellum.workflows.expressions.contains import ContainsExpression
 from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
 from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
@@ -105,6 +106,8 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "+"
     elif isinstance(descriptor, MinusExpression):
         return "-"
+    elif isinstance(descriptor, ConcatExpression):
+        return "concat"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")
 
@@ -171,6 +174,7 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
             AndExpression,
             BeginsWithExpression,
             CoalesceExpression,
+            ConcatExpression,
             ContainsExpression,
             DoesNotBeginWithExpression,
             DoesNotContainExpression,

vellum_ee/workflows/display/utils/registry.py

@@ -1,10 +1,14 @@
+from uuid import UUID
 from typing import TYPE_CHECKING, Dict, Optional, Type
 
+from vellum.workflows.events.types import BaseEvent
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.workflows.base import BaseWorkflow
 
 if TYPE_CHECKING:
+    from vellum.workflows.events.types import ParentContext
     from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+    from vellum_ee.workflows.display.types import WorkflowDisplayContext
     from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
@@ -14,6 +18,9 @@ _workflow_display_registry: Dict[Type[BaseWorkflow], Type["BaseWorkflowDisplay"]
 # Used to store the mapping between node types and their display classes
 _node_display_registry: Dict[Type[BaseNode], Type["BaseNodeDisplay"]] = {}
 
+# Registry to store active workflow display contexts by span ID for nested workflow inheritance
+_active_workflow_display_contexts: Dict[UUID, "WorkflowDisplayContext"] = {}
+
 
 def get_from_workflow_display_registry(workflow_class: Type[BaseWorkflow]) -> Optional[Type["BaseWorkflowDisplay"]]:
     return _workflow_display_registry.get(workflow_class)
@@ -35,3 +42,42 @@ def get_from_node_display_registry(node_class: Type[BaseNode]) -> Optional[Type[
 
 def register_node_display_class(node_class: Type[BaseNode], node_display_class: Type["BaseNodeDisplay"]) -> None:
     _node_display_registry[node_class] = node_display_class
+
+
+def register_workflow_display_context(span_id: UUID, display_context: "WorkflowDisplayContext") -> None:
+    """Register a workflow display context by span ID for nested workflow inheritance."""
+    _active_workflow_display_contexts[span_id] = display_context
+
+
+def _get_parent_display_context_for_span(span_id: UUID) -> Optional["WorkflowDisplayContext"]:
+    """Get the parent display context for a given span ID."""
+    return _active_workflow_display_contexts.get(span_id)
+
+
+def get_parent_display_context_from_event(event: BaseEvent) -> Optional["WorkflowDisplayContext"]:
+    """Extract parent display context from an event by traversing the parent chain.
+
+    This function traverses up the parent chain starting from the event's parent,
+    looking for workflow parents and attempting to get their display context.
+
+    Args:
+        event: The event to extract parent display context from
+
+    Returns:
+        The parent workflow display context if found, None otherwise
+    """
+    if not event.parent:
+        return None
+
+    current_parent: Optional["ParentContext"] = event.parent
+    while current_parent:
+        if current_parent.type == "WORKFLOW":
+            # Found a parent workflow, try to get its display context
+            parent_span_id = current_parent.span_id
+            parent_display_context = _get_parent_display_context_for_span(parent_span_id)
+            if parent_display_context:
+                return parent_display_context
+        # Move up the parent chain
+        current_parent = current_parent.parent
+
+    return None

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -528,7 +528,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         workflow_input_displays: WorkflowInputsDisplays = {}
         # If we're dealing with a nested workflow, then it should have access to the inputs of its parents.
         global_workflow_input_displays = (
-            copy(self._parent_display_context.workflow_input_displays) if self._parent_display_context else {}
+            copy(self._parent_display_context.global_workflow_input_displays) if self._parent_display_context else {}
         )
         for workflow_input in self._workflow.get_inputs_class():
             workflow_input_display_overrides = self.inputs_display.get(workflow_input)

vellum_ee/workflows/tests/test_registry.py

@@ -0,0 +1,169 @@
+from datetime import datetime, timezone
+from uuid import uuid4
+
+from vellum.workflows.events.types import NodeParentContext, WorkflowParentContext
+from vellum.workflows.events.workflow import WorkflowExecutionInitiatedBody, WorkflowExecutionInitiatedEvent
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.utils.registry import (
+    get_parent_display_context_from_event,
+    register_workflow_display_context,
+)
+
+
+class MockInputs(BaseInputs):
+    pass
+
+
+class MockState(BaseState):
+    pass
+
+
+class MockNode(BaseNode):
+    pass
+
+
+class MockWorkflow(BaseWorkflow[MockInputs, MockState]):
+    pass
+
+
+class MockWorkflowDisplayContext:
+    pass
+
+
+def test_get_parent_display_context_from_event__no_parent():
+    """Test event with no parent returns None"""
+    # GIVEN a workflow execution initiated event with no parent
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        id=uuid4(),
+        timestamp=datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=MockWorkflow,
+            inputs=MockInputs(),
+        ),
+        parent=None,  # No parent
+    )
+
+    # WHEN getting parent display context
+    result = get_parent_display_context_from_event(event)
+
+    # THEN it should return None
+    assert result is None
+
+
+def test_get_parent_display_context_from_event__non_workflow_parent():
+    """Test event with non-workflow parent continues traversal"""
+    # GIVEN an event with a non-workflow parent (NodeParentContext)
+    non_workflow_parent = NodeParentContext(node_definition=MockNode, span_id=uuid4(), parent=None)
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        id=uuid4(),
+        timestamp=datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=MockWorkflow,
+            inputs=MockInputs(),
+        ),
+        parent=non_workflow_parent,
+    )
+
+    # WHEN getting parent display context
+    result = get_parent_display_context_from_event(event)
+
+    # THEN it should return None (no workflow parent found)
+    assert result is None
+
+
+def test_get_parent_display_context_from_event__nested_workflow_parents():
+    """Test event with nested workflow parents traverses correctly"""
+    # GIVEN a chain of nested contexts:
+    # Event -> WorkflowParent -> NodeParent -> MiddleWorkflowParent -> NodeParent
+
+    # Top level workflow parent
+    top_workflow_span_id = uuid4()
+    top_context = MockWorkflowDisplayContext()
+    register_workflow_display_context(top_workflow_span_id, top_context)  # type: ignore[arg-type]
+
+    top_workflow_parent = WorkflowParentContext(
+        workflow_definition=MockWorkflow, span_id=top_workflow_span_id, parent=None
+    )
+
+    top_node_parent = NodeParentContext(node_definition=MockNode, span_id=uuid4(), parent=top_workflow_parent)
+
+    # AND middle workflow parent (no display context)
+    middle_workflow_span_id = uuid4()
+    middle_workflow_parent = WorkflowParentContext(
+        workflow_definition=MockWorkflow, span_id=middle_workflow_span_id, parent=top_node_parent
+    )
+
+    # AND node parent between middle workflow and event
+    node_parent = NodeParentContext(node_definition=MockNode, span_id=uuid4(), parent=middle_workflow_parent)
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        id=uuid4(),
+        timestamp=datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=MockWorkflow,
+            inputs=MockInputs(),
+        ),
+        parent=node_parent,
+    )
+
+    # WHEN getting parent display context
+    result = get_parent_display_context_from_event(event)
+
+    # THEN it should find the top-level workflow context
+    assert result == top_context
+
+
+def test_get_parent_display_context_from_event__middle_workflow_has_context():
+    """Test event returns middle workflow context when it's the first one with registered context"""
+    # GIVEN a chain of nested contexts:
+    # Event -> WorkflowParent -> NodeParent -> MiddleWorkflowParent -> NodeParent
+
+    top_workflow_span_id = uuid4()
+    top_context = MockWorkflowDisplayContext()
+    register_workflow_display_context(top_workflow_span_id, top_context)  # type: ignore[arg-type]
+
+    top_workflow_parent = WorkflowParentContext(
+        workflow_definition=MockWorkflow, span_id=top_workflow_span_id, parent=None
+    )
+
+    # AND node parent between top workflow and middle workflow
+    top_node_parent = NodeParentContext(node_definition=MockNode, span_id=uuid4(), parent=top_workflow_parent)
+
+    # AND middle workflow parent
+    middle_workflow_span_id = uuid4()
+    middle_context = MockWorkflowDisplayContext()
+    register_workflow_display_context(middle_workflow_span_id, middle_context)  # type: ignore[arg-type]
+
+    middle_workflow_parent = WorkflowParentContext(
+        workflow_definition=MockWorkflow, span_id=middle_workflow_span_id, parent=top_node_parent
+    )
+
+    node_parent = NodeParentContext(node_definition=MockNode, span_id=uuid4(), parent=middle_workflow_parent)
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        id=uuid4(),
+        timestamp=datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=MockWorkflow,
+            inputs=MockInputs(),
+        ),
+        parent=node_parent,
+    )
+
+    # WHEN getting parent display context
+    result = get_parent_display_context_from_event(event)
+
+    # THEN it should find the MIDDLE workflow context
+    assert result == middle_context

vellum_ee/workflows/tests/test_server.py

@@ -8,6 +8,7 @@ from vellum.client.types.number_vellum_value import NumberVellumValue
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.state.context import WorkflowContext
+from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
 
@@ -494,3 +495,74 @@ class MapNodeWorkflow(BaseWorkflow):
 
     # AND we get the map node results as a list
     assert event.body.outputs == {"results": [1.0, 1.0, 1.0]}
+
+
+def test_serialize_module__tool_calling_node_with_single_tool():
+    """Test that serialize_module works with a tool calling node that has a single tool."""
+
+    # GIVEN a simple tool function
+    tool_function_code = '''def get_weather(location: str) -> str:
+    """Get the current weather for a location."""
+    return f"The weather in {location} is sunny."
+'''
+
+    # AND a workflow module with a tool calling node using that single tool
+    files = {
+        "__init__.py": "",
+        "workflow.py": """
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.displayable.tool_calling_node import ToolCallingNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseInputs
+from vellum.client.types.chat_message_prompt_block import ChatMessagePromptBlock
+from vellum.client.types.plain_text_prompt_block import PlainTextPromptBlock
+from vellum.client.types.rich_text_prompt_block import RichTextPromptBlock
+from vellum.client.types.variable_prompt_block import VariablePromptBlock
+
+from .get_weather import get_weather
+
+
+class Inputs(BaseInputs):
+    location: str
+
+
+class WeatherNode(ToolCallingNode):
+    ml_model = "gpt-4o-mini"
+    blocks = [
+        ChatMessagePromptBlock(
+            chat_role="USER",
+            blocks=[
+                RichTextPromptBlock(
+                    blocks=[
+                        VariablePromptBlock(
+                            input_variable="location",
+                        ),
+                    ],
+                ),
+            ],
+        ),
+    ]
+    functions = [get_weather]
+    prompt_inputs = {
+        "location": Inputs.location,
+    }
+
+
+class Workflow(BaseWorkflow[Inputs, BaseState]):
+    graph = WeatherNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        result = WeatherNode.Outputs.text
+""",
+        "get_weather.py": tool_function_code,
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    result = BaseWorkflowDisplay.serialize_module(namespace)
+
+    # THEN the serialization should complete successfully
+    assert result is not None