vellum-ai 1.7.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -8,6 +8,7 @@ from typing import (
     Dict,
     ForwardRef,
     Generic,
+    List,
     Optional,
     Set,
     Tuple,
@@ -183,32 +184,13 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             existing_adornments = adornments if adornments is not None else []
             return display_class().serialize(display_context, adornments=existing_adornments + [adornment])
 
-        outputs: JsonArray = []
-        for output in node.Outputs:
-            type = primitive_type_to_vellum_variable_type(output)
-            value = (
-                serialize_value(node_id, display_context, output.instance)
-                if output.instance is not None and output.instance is not undefined
-                else None
-            )
-
-            outputs.append(
-                {
-                    "id": str(uuid4_from_hash(f"{node_id}|{output.name}")),
-                    "name": output.name,
-                    "type": type,
-                    "value": value,
-                }
-            )
-
         return {
             "id": str(node_id),
             "label": self.label,
             "type": "GENERIC",
-            **self.serialize_generic_fields(display_context),
             "adornments": adornments,
             "attributes": attributes,
-            "outputs": outputs,
+            **self.serialize_generic_fields(display_context),
         }
 
     def serialize_ports(self, display_context: "WorkflowDisplayContext") -> JsonArray:
@@ -275,14 +257,49 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         return attributes
 
-    def serialize_generic_fields(self, display_context: "WorkflowDisplayContext") -> JsonObject:
+    def _serialize_outputs(self, display_context: "WorkflowDisplayContext") -> JsonArray:
+        """Generate outputs array from node output displays or node.Outputs."""
+        outputs: JsonArray = []
+        node = self._node
+
+        for output in node.Outputs:
+            output_type = primitive_type_to_vellum_variable_type(output)
+            value = (
+                serialize_value(self.node_id, display_context, output.instance)
+                if output.instance is not None and output.instance != undefined
+                else None
+            )
+
+            output_id = (
+                str(self.output_display[output].id)
+                if output in self.output_display
+                else str(uuid4_from_hash(f"{self.node_id}|{output.name}"))
+            )
+
+            outputs.append(
+                {
+                    "id": output_id,
+                    "name": output.name,
+                    "type": output_type,
+                    "value": value,
+                }
+            )
+
+        return outputs
+
+    def serialize_generic_fields(
+        self, display_context: "WorkflowDisplayContext", exclude: Optional[List[str]] = None
+    ) -> JsonObject:
         """Serialize generic fields that are common to all nodes."""
+        exclude = exclude or []
+
         result: JsonObject = {
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "trigger": self.serialize_trigger(),
-            "ports": self.serialize_ports(display_context),
+            "display_data": self.get_display_data().dict() if "display_data" not in exclude else None,
+            "base": self.get_base().dict() if "base" not in exclude else None,
+            "definition": self.get_definition().dict() if "definition" not in exclude else None,
+            "trigger": self.serialize_trigger() if "trigger" not in exclude else None,
+            "ports": self.serialize_ports(display_context) if "ports" not in exclude else None,
+            "outputs": self._serialize_outputs(display_context) if "outputs" not in exclude else None,
         }
 
         # Only include should_file_merge if there are custom methods defined
@@ -299,6 +316,9 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         except Exception:
             pass
 
+        for key in exclude:
+            result.pop(key, None)
+
         return result
 
     def get_base(self) -> CodeResourceDefinition:

vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -119,5 +119,5 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
                 "output_id": str(self.output_id) if self.output_id else str(output_display.id),
                 "log_output_id": str(self.log_output_id) if self.log_output_id else str(log_output_display.id),
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }

vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -217,7 +217,7 @@ but the defined conditions have length {len(condition_ids)}"""
                 "conditions": conditions,  # type: ignore
                 "version": "2",
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }
 
     def get_nested_rule_details_by_path(

vellum_ee/workflows/display/nodes/vellum/error_node.py

@@ -47,7 +47,7 @@ class BaseErrorNodeDisplay(BaseNodeDisplay[_ErrorNodeType], Generic[_ErrorNodeTy
                 "target_handle_id": str(self.get_target_handle_id()),
                 "error_source_input_id": str(error_source_input_id),
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }
 
         if self.name:

vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -45,7 +45,7 @@ class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[
                 "node_input_id": str(node_input.id),
             },
             "inputs": [node_input.dict()],
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
             "outputs": [
                 {
                     "id": str(self._get_output_id()),

vellum_ee/workflows/display/nodes/vellum/guardrail_node.py

@@ -45,5 +45,5 @@ class BaseGuardrailNodeDisplay(BaseNodeDisplay[_GuardrailNodeType], Generic[_Gua
                 "metric_definition_id": str(raise_if_descriptor(node.metric_definition)),
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }

vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -110,7 +110,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 },
                 "ml_model_name": ml_model,
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
             "outputs": [
                 {"id": str(json_display.id), "name": "json", "type": "JSON", "value": None},
                 {"id": str(output_display.id), "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -68,7 +68,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 "input_variables": [workflow_input.dict() for workflow_input in workflow_inputs],
                 "output_variables": [workflow_output.dict() for workflow_output in workflow_outputs],
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }
 
     def _generate_node_and_workflow_inputs(

vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -88,7 +88,7 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
                 "item_input_id": item_workflow_input_id,
                 "index_input_id": index_workflow_input_id,
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }
 
     def _default_workflow_class(self) -> Type[BaseWorkflow]:

vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -47,7 +47,7 @@ class BaseMergeNodeDisplay(BaseNodeDisplay[_MergeNodeType], Generic[_MergeNodeTy
                 "target_handles": [{"id": str(target_handle_id)} for target_handle_id in target_handle_ids],
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }
 
     def get_target_handle_ids(self) -> Optional[List[UUID]]:

vellum_ee/workflows/display/nodes/vellum/note_node.py

@@ -25,5 +25,5 @@ class BaseNoteNodeDisplay(BaseNodeDisplay[_NoteNodeType], Generic[_NoteNodeType]
                 "text": self.text,
                 "style": self.style,
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }

vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -71,7 +71,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
                 "release_tag": raise_if_descriptor(node.release_tag),
                 "ml_model_fallbacks": list(ml_model_fallbacks) if ml_model_fallbacks else None,
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
             "outputs": [
                 {"id": str(json_display.id), "name": "json", "type": "JSON", "value": None},
                 {"id": str(output_display.id), "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -71,7 +71,7 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
                 "external_id_filters_node_input_id": str(node_inputs["external_id_filters"].id),
                 "metadata_filters_node_input_id": str(node_inputs["metadata_filters"].id),
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }
 
     def _generate_search_node_inputs(

vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py

@@ -68,5 +68,5 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 "workflow_deployment_id": deployment_id,
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }

vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -66,5 +66,5 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
                 "template_node_input_id": str(template_node_input.id),
                 "output_type": inferred_output_type,
             },
-            **self.serialize_generic_fields(display_context),
+            **self.serialize_generic_fields(display_context, exclude=["outputs"]),
         }

vellum_ee/workflows/display/nodes/vellum/tests/test_api_node.py

@@ -29,3 +29,37 @@ def test_serialize_node__api_node_with_timeout():
     assert timeout_attribute["value"]["type"] == "CONSTANT_VALUE"
     assert timeout_attribute["value"]["value"]["type"] == "NUMBER"
     assert timeout_attribute["value"]["value"]["value"] == 30.0
+
+
+def test_serialize_node__api_node_outputs():
+    """
+    Tests that API node serialization includes the outputs array.
+    """
+
+    class MyAPINode(APINode):
+        url = "https://api.example.com"
+        method = APIRequestMethod.GET
+
+    class Workflow(BaseWorkflow):
+        graph = MyAPINode
+
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    my_api_node = next(node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "API")
+
+    assert "outputs" in my_api_node
+    outputs = my_api_node["outputs"]
+    assert len(outputs) == 4
+
+    text_output = next(output for output in outputs if output["name"] == "text")
+    assert text_output["type"] == "STRING"
+    assert text_output["value"] is None
+
+    json_output = next(output for output in outputs if output["name"] == "json")
+    assert json_output["type"] == "JSON"
+    assert json_output["value"] is None
+
+    status_code_output = next(output for output in outputs if output["name"] == "status_code")
+    assert status_code_output["type"] == "NUMBER"
+    assert status_code_output["value"] is None

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

@@ -8,6 +8,8 @@ from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class imp
 
 from tests.workflows.basic_api_node.workflow import SimpleAPIWorkflow
 
+# 0d76e1e1-3a4b-4eb4-a606-f73d62c -> 12e4a99d-883d-4da5-aa51-35817d94013e
+
 
 def test_serialize_workflow(vellum_client):
     # GIVEN a Workflow that uses a vellum API node
@@ -208,6 +210,12 @@ def test_serialize_workflow(vellum_client):
                 "merge_behavior": "AWAIT_ANY",
             },
             "ports": [{"id": "7c33b4d3-9204-4bd5-9371-80ee34f83073", "name": "default", "type": "DEFAULT"}],
+            "outputs": [
+                {"id": "12e4a99d-883d-4da5-aa51-35817d94013e", "name": "json", "type": "JSON", "value": None},
+                {"id": "0d76e1e1-3a4b-4eb4-a606-f73d62cf1a7e", "name": "headers", "type": "JSON", "value": None},
+                {"id": "fecc16c3-400e-4fd3-8223-08366070e3b1", "name": "status_code", "type": "NUMBER", "value": None},
+                {"id": "17342c21-12bb-49ab-88ce-f144e0376b32", "name": "text", "type": "STRING", "value": None},
+            ],
         },
         api_node,
     )

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

@@ -1,7 +1,4 @@
-"""Tests for serialization of workflows with ManualTrigger."""
-
 import pytest
-from typing import cast
 
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
@@ -9,95 +6,55 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.triggers.base import BaseTrigger
 from vellum.workflows.triggers.manual import ManualTrigger
-from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
-class Inputs(BaseInputs):
-    input: str
-
-
-class SimpleNode(BaseNode):
-    class Outputs(BaseNode.Outputs):
-        output = Inputs.input
-
-
-def create_workflow(trigger=None):
-    """Factory for creating test workflows."""
-
-    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
-        graph = trigger >> SimpleNode if trigger else SimpleNode
-
-        class Outputs(BaseWorkflow.Outputs):
-            output = SimpleNode.Outputs.output
-
-    return TestWorkflow
-
-
-def serialize(workflow_class) -> JsonObject:
-    """Helper to serialize a workflow."""
-    return get_workflow_display(workflow_class=workflow_class).serialize()
-
-
 def test_manual_trigger_serialization():
     """Workflow with ManualTrigger serializes with triggers field."""
-    result = serialize(create_workflow(ManualTrigger))
-    triggers = cast(JsonArray, result["triggers"])
 
-    assert len(triggers) == 1
-    trigger = cast(JsonObject, triggers[0])
+    class SimpleNode(BaseNode):
+        pass
 
-    assert trigger["type"] == "MANUAL"
-    assert "id" in trigger
-    assert "attributes" in trigger
-    assert trigger["attributes"] == []
-    assert "definition" not in trigger
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = ManualTrigger >> SimpleNode
 
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
 
-def test_no_trigger_serialization():
-    """Workflow without trigger has no triggers field."""
-    result = serialize(create_workflow())
-    assert "triggers" not in result
+    assert len(triggers) == 1
+    assert triggers[0] == {"id": "b09c1902-3cca-4c79-b775-4c32e3e88466", "type": "MANUAL", "attributes": []}
 
 
 def test_manual_trigger_multiple_entrypoints():
     """ManualTrigger with multiple entrypoints."""
 
     class NodeA(BaseNode):
-        class Outputs(BaseNode.Outputs):
-            output = Inputs.input
+        pass
 
     class NodeB(BaseNode):
-        class Outputs(BaseNode.Outputs):
-            output = Inputs.input
+        pass
 
-    class MultiWorkflow(BaseWorkflow[Inputs, BaseState]):
+    class MultiWorkflow(BaseWorkflow[BaseInputs, BaseState]):
         graph = ManualTrigger >> {NodeA, NodeB}
 
-        class Outputs(BaseWorkflow.Outputs):
-            output_a = NodeA.Outputs.output
-            output_b = NodeB.Outputs.output
-
-    result = serialize(MultiWorkflow)
-    triggers = cast(JsonArray, result["triggers"])
-    workflow_data = cast(JsonObject, result["workflow_raw_data"])
-    nodes = cast(JsonArray, workflow_data["nodes"])
-
-    assert len(triggers) == 1
-    trigger = cast(JsonObject, triggers[0])
-    assert trigger["type"] == "MANUAL"
-    assert len([n for n in nodes if cast(JsonObject, n)["type"] == "GENERIC"]) >= 2
+    result = get_workflow_display(workflow_class=MultiWorkflow).serialize()
+    workflow_data = result["workflow_raw_data"]
+    assert isinstance(workflow_data, dict)
+    assert "nodes" in workflow_data
+    nodes = workflow_data["nodes"]
+    assert isinstance(nodes, list)
 
+    # entrypoint + 2 nodes
+    assert len(nodes) == 3
 
-def test_serialized_workflow_structure():
-    """Verify complete structure of serialized workflow."""
-    result = serialize(create_workflow(ManualTrigger))
-    workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
-    definition = cast(JsonObject, workflow_raw_data["definition"])
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
 
-    assert result.keys() == {"workflow_raw_data", "input_variables", "state_variables", "output_variables", "triggers"}
-    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition", "output_values"}
-    assert definition["name"] == "TestWorkflow"
+    assert len(triggers) == 1
+    assert triggers[0] == {"id": "b09c1902-3cca-4c79-b775-4c32e3e88466", "type": "MANUAL", "attributes": []}
 
 
 def test_unknown_trigger_type():
@@ -106,5 +63,11 @@ def test_unknown_trigger_type():
     class UnknownTrigger(BaseTrigger):
         pass
 
+    class SimpleNode(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = UnknownTrigger >> SimpleNode
+
     with pytest.raises(ValueError, match="Unknown trigger type: UnknownTrigger"):
-        serialize(create_workflow(UnknownTrigger))
+        get_workflow_display(workflow_class=TestWorkflow).serialize()

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

@@ -0,0 +1,167 @@
+"""Tests for serialization of workflows with SlackTrigger."""
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.slack import SlackTrigger
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class SimpleNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+def test_slack_trigger_serialization() -> None:
+    """Workflow with SlackTrigger serializes with triggers field."""
+
+    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = SlackTrigger >> SimpleNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            output = SimpleNode.Outputs.output
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Validate triggers structure
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "SLACK_MESSAGE"
+    assert "id" in trigger
+
+    # Validate attributes
+    assert "attributes" in trigger
+    attributes = trigger["attributes"]
+    assert isinstance(attributes, list)
+    assert len(attributes) == 6
+
+    attribute_names = set()
+    for attribute in attributes:
+        assert isinstance(attribute, dict)
+        assert "name" in attribute
+        assert isinstance(attribute["name"], str)
+        attribute_names.add(attribute["name"])
+    assert attribute_names == {
+        "message",
+        "channel",
+        "user",
+        "timestamp",
+        "thread_ts",
+        "event_type",
+    }
+
+    for attribute in attributes:
+        assert isinstance(attribute, dict)
+        assert attribute["value"] is None
+        assert isinstance(attribute["id"], str)
+        assert attribute["id"]
+
+
+def test_slack_trigger_multiple_entrypoints() -> None:
+    """SlackTrigger with multiple entrypoints."""
+
+    class NodeA(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.input
+
+    class NodeB(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.input
+
+    class MultiWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = SlackTrigger >> {NodeA, NodeB}
+
+        class Outputs(BaseWorkflow.Outputs):
+            output_a = NodeA.Outputs.output
+            output_b = NodeB.Outputs.output
+
+    result = get_workflow_display(workflow_class=MultiWorkflow).serialize()
+
+    # Validate triggers
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "SLACK_MESSAGE"
+
+    # Validate attributes
+    assert "attributes" in trigger
+    attributes = trigger["attributes"]
+    assert isinstance(attributes, list)
+    attribute_names = set()
+    for attribute in attributes:
+        assert isinstance(attribute, dict)
+        assert "name" in attribute
+        assert isinstance(attribute["name"], str)
+        attribute_names.add(attribute["name"])
+
+    assert attribute_names == {
+        "message",
+        "channel",
+        "user",
+        "timestamp",
+        "thread_ts",
+        "event_type",
+    }
+
+    # Validate nodes
+    assert "workflow_raw_data" in result
+    workflow_data = result["workflow_raw_data"]
+    assert isinstance(workflow_data, dict)
+    assert "nodes" in workflow_data
+    nodes = workflow_data["nodes"]
+    assert isinstance(nodes, list)
+
+    generic_nodes = [node for node in nodes if isinstance(node, dict) and node.get("type") == "GENERIC"]
+    assert len(generic_nodes) >= 2
+
+
+def test_serialized_slack_workflow_structure() -> None:
+    """Verify complete structure of serialized workflow with SlackTrigger."""
+
+    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = SlackTrigger >> SimpleNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            output = SimpleNode.Outputs.output
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Validate top-level structure
+    assert isinstance(result, dict)
+    assert set(result.keys()) == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+        "triggers",
+    }
+
+    # Validate workflow_raw_data structure
+    workflow_raw_data = result["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    assert set(workflow_raw_data.keys()) == {
+        "nodes",
+        "edges",
+        "display_data",
+        "definition",
+        "output_values",
+    }
+
+    # Validate definition
+    definition = workflow_raw_data["definition"]
+    assert isinstance(definition, dict)
+    assert definition["name"] == "TestWorkflow"

vellum_ee/workflows/display/utils/expressions.py

@@ -50,6 +50,7 @@ from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.references.state_value import StateValueReference
+from vellum.workflows.references.trigger import TriggerAttributeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
@@ -347,6 +348,17 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
             "node_id": str(node_class_display.node_id),
         }
 
+    if isinstance(value, TriggerAttributeReference):
+        # Generate trigger ID using the same hash formula as in base_workflow_display.py
+        trigger_class = value.trigger_class
+        trigger_id = uuid4_from_hash(trigger_class.__qualname__)
+
+        return {
+            "type": "TRIGGER_ATTRIBUTE",
+            "trigger_id": str(trigger_id),
+            "attribute_id": str(value.id),
+        }
+
     if isinstance(value, list):
         serialized_items = []
         for item in value: