vellum-ai 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

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

@@ -3,6 +3,20 @@ from datetime import datetime
 from uuid import UUID, uuid4
 from typing import Type
 
+from vellum import (
+    AudioInputRequest,
+    DocumentInputRequest,
+    ImageInputRequest,
+    VellumAudio,
+    VellumAudioRequest,
+    VellumDocument,
+    VellumDocumentRequest,
+    VellumImage,
+    VellumImageRequest,
+    VellumVideo,
+    VellumVideoRequest,
+    VideoInputRequest,
+)
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import PromptDeploymentNode
 from vellum_ee.workflows.display.nodes.vellum.prompt_deployment_node import BasePromptDeploymentNodeDisplay
@@ -105,3 +119,59 @@ def test_serialize_node__prompt_inputs(GetDisplayClass, expected_input_id, mock_
             },
         }
     ]
+
+
+@pytest.mark.parametrize(
+    [
+        "raw_input",
+        "expected_compiled_inputs",
+    ],
+    [
+        # Cast VellumX -> VellumXRequest
+        (
+            VellumAudio(src="data:audio/wav;base64,mockaudio"),
+            [AudioInputRequest(name="file_input", value=VellumAudioRequest(src="data:audio/wav;base64,mockaudio"))],
+        ),
+        (
+            VellumImage(src="data:image/png;base64,mockimage"),
+            [ImageInputRequest(name="file_input", value=VellumImageRequest(src="data:image/png;base64,mockimage"))],
+        ),
+        (
+            VellumVideo(src="data:video/mp4;base64,mockvideo"),
+            [VideoInputRequest(name="file_input", value=VellumVideoRequest(src="data:video/mp4;base64,mockvideo"))],
+        ),
+        (
+            VellumDocument(src="mockdocument"),
+            [DocumentInputRequest(name="file_input", value=VellumDocumentRequest(src="mockdocument"))],
+        ),
+        # No casting required
+        (
+            VellumAudioRequest(src="data:audio/wav;base64,mockaudio"),
+            [AudioInputRequest(name="file_input", value=VellumAudioRequest(src="data:audio/wav;base64,mockaudio"))],
+        ),
+        (
+            VellumImageRequest(src="data:image/png;base64,mockimage"),
+            [ImageInputRequest(name="file_input", value=VellumImageRequest(src="data:image/png;base64,mockimage"))],
+        ),
+        (
+            VellumVideoRequest(src="data:video/mp4;base64,mockvideo"),
+            [VideoInputRequest(name="file_input", value=VellumVideoRequest(src="data:video/mp4;base64,mockvideo"))],
+        ),
+        (
+            VellumDocumentRequest(src="mockdocument"),
+            [DocumentInputRequest(name="file_input", value=VellumDocumentRequest(src="mockdocument"))],
+        ),
+    ],
+)
+def test_file_input_compilation(raw_input, expected_compiled_inputs):
+    # GIVEN a prompt node with file input
+    class MyPromptDeploymentNode(PromptDeploymentNode):
+        deployment = "DEPLOYMENT"
+        prompt_inputs = {"file_input": raw_input}
+        ml_model_fallbacks = None
+
+    # WHEN we compile the inputs
+    compiled_inputs = MyPromptDeploymentNode()._compile_prompt_inputs()
+
+    # THEN we should get the correct input type
+    assert compiled_inputs == expected_compiled_inputs

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

@@ -197,7 +197,7 @@ def test_serialize_node__prompt_inputs__state_reference():
             "type": "DICTIONARY_REFERENCE",
             "entries": [
                 {
-                    "id": "feadab18-07c6-4790-adf0-28be20a5447a",
+                    "id": "52559b9e-4e8e-438a-8246-cfa30c98d5d1",
                     "key": "foo",
                     "value": {
                         "type": "WORKFLOW_STATE",
@@ -205,7 +205,7 @@ def test_serialize_node__prompt_inputs__state_reference():
                     },
                 },
                 {
-                    "id": "4f252277-d0a5-48ad-8cc5-be03bf0dbd19",
+                    "id": "3750feb9-5d5c-4150-b62d-a9924f466888",
                     "key": "bar",
                     "value": {
                         "type": "CONSTANT_VALUE",
@@ -325,52 +325,52 @@ def test_serialize_node__prompt_parameters__dynamic_references():
     assert parameters_attribute["value"]["type"] == "DICTIONARY_REFERENCE"
     assert parameters_attribute["value"]["entries"] == [
         {
-            "id": "6b63ff96-a2eb-4c6e-bad1-bde01605fa86",
+            "id": "24703d3a-ee6c-4b1b-80f8-6c19ef16723a",
             "key": "stop",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "265a1c17-2089-4ac1-b2ce-361b6b9a3335",
+            "id": "88a3bf5d-f42b-4895-850e-ad843945a003",
             "key": "temperature",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "699976ec-8ec2-476a-a011-7cf810a8a307",
+            "id": "ede3e0c2-3033-4d0a-bd72-e52595bdc916",
             "key": "max_tokens",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "a87e23da-9794-41ff-ba80-c3a77e976e75",
+            "id": "0013cd8f-7658-4908-80fc-b8995d8ca4cc",
             "key": "top_p",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "18eb53c2-ec1a-4115-9f21-083af430df67",
+            "id": "98eb2e57-d4ec-4c27-b39b-0b8086918a0f",
             "key": "top_k",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "295509a2-5837-452c-893d-f47b67c63c8a",
+            "id": "04accc66-888c-4145-8b4f-d8ff99e38172",
             "key": "frequency_penalty",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "5fc64379-5566-426a-a909-dd56c3305aa5",
+            "id": "9236d564-0637-48de-8423-cdf3617dd6b4",
             "key": "presence_penalty",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "5d326da0-c096-4425-8bf1-3a18764e96e3",
+            "id": "74f3e80a-3935-45af-a9b3-d49e310a4c03",
             "key": "logit_bias",
             "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
         },
         {
-            "id": "cd1a0e1b-6667-48a0-9964-257e1ec8851d",
+            "id": "69a7ebf7-d21a-44e9-a0fa-43eb9b2815df",
             "key": "custom_parameters",
             "value": {
                 "entries": [
                     {
-                        "id": "a9a3092e-dd18-4533-b6b5-24588ebd8f7f",
+                        "id": "e709dc4d-f2db-4dc9-b912-401b52fbb7b4",
                         "key": "json_schema",
                         "value": {
                             "input_variable_id": "c02d1201-86d1-4364-b3b3-4fc6824db8a4",

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

@@ -92,7 +92,7 @@ def test_serialize_node__prompt_inputs__input_reference():
             "type": "DICTIONARY_REFERENCE",
             "entries": [
                 {
-                    "id": "ab7902ef-de14-4edc-835c-366d3ef6a70e",
+                    "id": "845009c8-03f8-4de4-b956-841309457d37",
                     "key": "foo",
                     "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "e3657390-fd3c-4fea-8cdd-fc5ea79f3278"},
                 }
@@ -134,12 +134,12 @@ def test_serialize_node__prompt_inputs__mixed_values():
             "type": "DICTIONARY_REFERENCE",
             "entries": [
                 {
-                    "id": "0fc7e25e-075c-4849-b89b-9729d1aeada1",
+                    "id": "a4016385-3cab-4c01-b9d2-7865cd54bdb0",
                     "key": "foo",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "bar"}},
                 },
                 {
-                    "id": "bba42c89-fa7b-4cb7-bc16-0d21ce060a4b",
+                    "id": "828928b1-24e3-4457-9d6f-4f0692dfa355",
                     "key": "baz",
                     "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "8d57cf1d-147c-427b-9a5e-e5f6ab76e2eb"},
                 },
@@ -540,7 +540,7 @@ def test_serialize_tool_prompt_node_with_inline_workflow():
             "type": "DICTIONARY_REFERENCE",
             "entries": [
                 {
-                    "id": "76ceec7b-ec37-474f-ba38-2bfd27cecc5d",
+                    "id": "b1dfaf2b-b9fb-4fea-ad04-a988e5223d06",
                     "key": "chat_history",
                     "value": {
                         "type": "BINARY_EXPRESSION",

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

@@ -37,7 +37,7 @@ class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNod
                 {
                     "id": id,
                     "name": attribute.name,
-                    "value": serialize_value(display_context, attribute.instance),
+                    "value": serialize_value(node_id, display_context, attribute.instance),
                 }
             )
 

vellum_ee/workflows/display/tests/test_base_workflow_display.py

@@ -476,3 +476,49 @@ def test_serialize_workflow_with_node_display_data():
 
     assert test_node is not None, "TestNode not found in serialized nodes"
     assert test_node["display_data"] == {"position": {"x": 100, "y": 200}, "z_index": 10, "width": 300, "height": 150}
+
+
+def test_serialize_workflow_with_node_icon_and_color():
+    """
+    Tests that nodes with icon and color serialize correctly in workflow context.
+    """
+
+    # GIVEN a workflow with a node that has icon and color
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class TestWorkflow(BaseWorkflow):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = TestNode.Outputs.result
+
+    class TestNodeDisplay(BaseNodeDisplay[TestNode]):
+        display_data = NodeDisplayData(position=NodeDisplayPosition(x=100, y=200), icon="vellum:icon:cog", color="navy")
+
+    class TestWorkflowDisplay(BaseWorkflowDisplay[TestWorkflow]):
+        pass
+
+    # WHEN we serialize the workflow
+    display = get_workflow_display(
+        base_display_class=TestWorkflowDisplay,
+        workflow_class=TestWorkflow,
+    )
+    serialized_workflow = display.serialize()
+
+    # THEN the node should include icon and color in display_data
+    workflow_raw_data = cast(Dict[str, Any], serialized_workflow["workflow_raw_data"])
+    nodes = cast(List[Dict[str, Any]], workflow_raw_data["nodes"])
+
+    test_node = None
+    for node in nodes:
+        if node.get("type") == "GENERIC":
+            definition = node.get("definition")
+            if isinstance(definition, dict) and definition.get("name") == "TestNode":
+                test_node = node
+                break
+
+    assert test_node is not None, "TestNode not found in serialized nodes"
+    assert test_node["display_data"]["icon"] == "vellum:icon:cog"
+    assert test_node["display_data"]["color"] == "navy"

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -293,7 +293,7 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
                         "type": "DICTIONARY_REFERENCE",
                         "entries": [
                             {
-                                "id": "52d98e78-5c2a-488e-be3e-f3b487d94ad3",
+                                "id": "07513ab1-cf47-490e-8b43-5da226332a00",
                                 "key": "hello",
                                 "value": {
                                     "type": "WORKFLOW_INPUT",

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

@@ -219,7 +219,7 @@ def test_serialize_workflow():
                         "type": "DICTIONARY_REFERENCE",
                         "entries": [
                             {
-                                "id": "0bfa70a2-164f-460c-9e9a-4d62221eadf4",
+                                "id": "6eb6687c-f894-4398-8e62-7dc89e96a0a4",
                                 "key": "noun",
                                 "value": {
                                     "type": "WORKFLOW_INPUT",
@@ -521,37 +521,37 @@ def test_serialize_workflow_with_nested_descriptor_blocks():
         {
             "entries": [
                 {
-                    "id": "24a203be-3cba-4b20-bc84-9993a476c120",
+                    "id": "4e61fbcf-13b3-4d5f-b5fb-2bf919a92045",
                     "key": "block_type",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "CHAT_MESSAGE"}},
                 },
                 {
-                    "id": "c06269e6-f74c-4860-8fa5-22dcbdc89399",
+                    "id": "79dd757e-46db-4c36-9ffc-ddb763d14f27",
                     "key": "state",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
                 },
                 {
-                    "id": "dd9c0d43-b931-4dc8-8b3a-a7507ddff0c1",
+                    "id": "2f8164e8-5495-4b9c-8268-d75618cd0842",
                     "key": "cache_config",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
                 },
                 {
-                    "id": "bef22f2b-0b6e-4910-88cc-6df736d2e20e",
+                    "id": "0e8dc132-de9a-40dc-9845-336bc957df5a",
                     "key": "chat_role",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "SYSTEM"}},
                 },
                 {
-                    "id": "c0beec30-f85e-4a78-a3fb-baee54a692f8",
+                    "id": "755a45d2-2420-4414-b318-5790880f84ec",
                     "key": "chat_source",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
                 },
                 {
-                    "id": "f601f4f2-62fe-4697-9fe0-99ca8aa64500",
+                    "id": "3a563cdb-d130-497f-bac6-c324a4349a3c",
                     "key": "chat_message_unterminated",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
                 },
                 {
-                    "id": "ad550008-64e3-44a3-a32a-84ec226db31c",
+                    "id": "2d0c084e-c54f-48f5-9444-a17f8aeb8f76",
                     "key": "blocks",
                     "value": {
                         "items": [

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

@@ -131,6 +131,7 @@ def test_serialize_workflow():
                             "id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
                             "label": "Start Node",
                             "type": "GENERIC",
+                            "should_file_merge": True,
                             "display_data": {"position": {"x": 200.0, "y": -50.0}},
                             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
                             "definition": {

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

@@ -118,6 +118,7 @@ def test_serialize_workflow():
                             "id": "baf6d316-dc75-41e8-96c0-015aede96309",
                             "label": "Iteration",
                             "type": "GENERIC",
+                            "should_file_merge": True,
                             "display_data": {"position": {"x": 200.0, "y": -50.0}},
                             "base": {
                                 "name": "BaseNode",

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

@@ -155,6 +155,7 @@ def test_serialize_workflow():
                                                 "id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
                                                 "label": "Start Node",
                                                 "type": "GENERIC",
+                                                "should_file_merge": True,
                                                 "display_data": {"position": {"x": 200.0, "y": -50.0}},
                                                 "base": {
                                                     "name": "BaseNode",
@@ -400,7 +401,7 @@ def test_serialize_workflow():
                     "type": "DICTIONARY_REFERENCE",
                     "entries": [
                         {
-                            "id": "d5c4d578-6ef1-4786-88f6-1ab0892d0798",
+                            "id": "8eb8b551-9b48-43b3-861f-52adb5c585a8",
                             "key": "question",
                             "value": {
                                 "type": "WORKFLOW_INPUT",

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

@@ -42,6 +42,7 @@ def test_serialize_workflow():
         "id": "21f29cac-da87-495f-bba1-093d423f4e46",
         "label": "Get Current Weather Node",
         "type": "GENERIC",
+        "should_file_merge": True,
         "display_data": {
             "position": {"x": 200.0, "y": -50.0},
             "comment": {
@@ -169,7 +170,7 @@ def test_serialize_workflow():
                     "type": "DICTIONARY_REFERENCE",
                     "entries": [
                         {
-                            "id": "b6d4427d-16dd-478a-9780-f88d60d2263d",
+                            "id": "8eb8b551-9b48-43b3-861f-52adb5c585a8",
                             "key": "question",
                             "value": {
                                 "type": "WORKFLOW_INPUT",

vellum_ee/workflows/display/utils/events.py

@@ -1,3 +1,6 @@
+from typing import Optional
+
+from vellum import Vellum
 from vellum.workflows.events.workflow import WorkflowExecutionInitiatedEvent
 from vellum_ee.workflows.display.utils.registry import (
     get_parent_display_context_from_event,
@@ -25,7 +28,9 @@ def _should_mark_workflow_dynamic(event: WorkflowExecutionInitiatedEvent) -> boo
     return True
 
 
-def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionInitiatedEvent:
+def event_enricher(
+    event: WorkflowExecutionInitiatedEvent, client: Optional[Vellum] = None
+) -> WorkflowExecutionInitiatedEvent:
     if event.name != "workflow.execution.initiated":
         return event
 
@@ -33,6 +38,7 @@ def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionI
     workflow_display = get_workflow_display(
         workflow_class=workflow_definition,
         parent_display_context=get_parent_display_context_from_event(event),
+        client=client,
         dry_run=True,
     )
     register_workflow_display_context(event.span_id, workflow_display.display_context)

vellum_ee/workflows/display/utils/expressions.py

@@ -2,6 +2,7 @@ from dataclasses import asdict, is_dataclass
 import inspect
 from io import StringIO
 import sys
+from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, List, cast
 
 from pydantic import BaseModel
@@ -157,7 +158,9 @@ def get_child_descriptor(value: LazyReference, display_context: "WorkflowDisplay
     return value._get()
 
 
-def _serialize_condition(display_context: "WorkflowDisplayContext", condition: BaseDescriptor) -> JsonObject:
+def _serialize_condition(
+    executable_id: UUID, display_context: "WorkflowDisplayContext", condition: BaseDescriptor
+) -> JsonObject:
     if isinstance(
         condition,
         (
@@ -171,16 +174,16 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
             ParseJsonExpression,
         ),
     ):
-        lhs = serialize_value(display_context, condition._expression)
+        lhs = serialize_value(executable_id, display_context, condition._expression)
         return {
             "type": "UNARY_EXPRESSION",
             "lhs": lhs,
             "operator": convert_descriptor_to_operator(condition),
         }
     elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
-        base = serialize_value(display_context, condition._value)
-        lhs = serialize_value(display_context, condition._start)
-        rhs = serialize_value(display_context, condition._end)
+        base = serialize_value(executable_id, display_context, condition._value)
+        lhs = serialize_value(executable_id, display_context, condition._start)
+        rhs = serialize_value(executable_id, display_context, condition._end)
 
         return {
             "type": "TERNARY_EXPRESSION",
@@ -214,8 +217,8 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
             OrExpression,
         ),
     ):
-        lhs = serialize_value(display_context, condition._lhs)
-        rhs = serialize_value(display_context, condition._rhs)
+        lhs = serialize_value(executable_id, display_context, condition._lhs)
+        rhs = serialize_value(executable_id, display_context, condition._rhs)
 
         return {
             "type": "BINARY_EXPRESSION",
@@ -226,9 +229,9 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
     elif isinstance(condition, AccessorExpression):
         return {
             "type": "BINARY_EXPRESSION",
-            "lhs": serialize_value(display_context, condition._base),
+            "lhs": serialize_value(executable_id, display_context, condition._base),
             "operator": "accessField",
-            "rhs": serialize_value(display_context, condition._field),
+            "rhs": serialize_value(executable_id, display_context, condition._field),
         }
 
     raise UnsupportedSerializationException(f"Unsupported condition type: {condition.__class__.__name__}")
@@ -248,16 +251,27 @@ def serialize_key(key: Any) -> str:
 _UNDEFINED_SENTINEL: JsonObject = {"__undefined__": True}
 
 
-def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+    """
+    Serialize a value to a JSON object.
+
+    Args:
+        executable_id: node id or workflow id
+        display_context: workflow display context
+        value: value to serialize
+
+    Returns:
+        serialized value
+    """
     if value is undefined:
         return _UNDEFINED_SENTINEL
 
     if isinstance(value, ConstantValueReference):
-        return serialize_value(display_context, value._value)
+        return serialize_value(executable_id, display_context, value._value)
 
     if isinstance(value, LazyReference):
         child_descriptor = get_child_descriptor(value, display_context)
-        return serialize_value(display_context, child_descriptor)
+        return serialize_value(executable_id, display_context, child_descriptor)
 
     if isinstance(value, WorkflowInputReference):
         try:
@@ -324,7 +338,7 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
     if isinstance(value, list):
         serialized_items = []
         for item in value:
-            serialized_item = serialize_value(display_context, item)
+            serialized_item = serialize_value(executable_id, display_context, item)
             if serialized_item != _UNDEFINED_SENTINEL:
                 serialized_items.append(serialized_item)
 
@@ -355,16 +369,16 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
     if is_dataclass(value) and not isinstance(value, type):
         dict_value = asdict(value)
-        return serialize_value(display_context, dict_value)
+        return serialize_value(executable_id, display_context, dict_value)
 
     if isinstance(value, dict):
         serialized_entries: List[Dict[str, Any]] = []
         for key, val in value.items():
-            serialized_val = serialize_value(display_context, val)
+            serialized_val = serialize_value(executable_id, display_context, val)
             if serialized_val != _UNDEFINED_SENTINEL:
                 serialized_entries.append(
                     {
-                        "id": str(uuid4_from_hash(f"{key}|{val}")),
+                        "id": str(uuid4_from_hash(f"{executable_id}|{key}")),
                         "key": serialize_key(key),
                         "value": serialized_val,
                     }
@@ -434,7 +448,7 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
     if isinstance(value, BaseModel):
         dict_value = value.model_dump()
-        return serialize_value(display_context, dict_value)
+        return serialize_value(executable_id, display_context, dict_value)
 
     if callable(value):
         function_definition = compile_function_definition(value)
@@ -447,7 +461,7 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         if inputs:
             serialized_inputs = {}
             for param_name, input_ref in inputs.items():
-                serialized_inputs[param_name] = serialize_value(display_context, input_ref)
+                serialized_inputs[param_name] = serialize_value(executable_id, display_context, input_ref)
 
             model_data = function_definition.model_dump()
             model_data["inputs"] = serialized_inputs
@@ -485,4 +499,4 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
     # If it's not any of the references we know about,
     # then try to serialize it as a nested value
-    return _serialize_condition(display_context, value)
+    return _serialize_condition(executable_id, display_context, value)

vellum_ee/workflows/display/utils/tests/test_events.py

@@ -47,7 +47,7 @@ from vellum_ee.workflows.display.utils.events import event_enricher
         ),
     ],
 )
-def test_event_enricher_static_workflow(is_dynamic: bool, expected_config: Optional[dict]):
+def test_event_enricher_static_workflow(vellum_client, is_dynamic: bool, expected_config: Optional[dict]):
     """Test event_enricher with a static workflow (is_dynamic=False)."""
     # GIVEN a workflow class with the specified is_dynamic value
     _is_dynamic = is_dynamic
@@ -65,7 +65,7 @@ def test_event_enricher_static_workflow(is_dynamic: bool, expected_config: Optio
     )
 
     # WHEN the event_enricher is called with mocked dependencies
-    event_enricher(event)
+    event_enricher(event, vellum_client)
 
     # THEN workflow_version_exec_config is set to the expected config
     assert event.body.workflow_version_exec_config == expected_config
@@ -76,7 +76,7 @@ def test_event_enricher_static_workflow(is_dynamic: bool, expected_config: Optio
     assert hasattr(event.body.display_context, "workflow_outputs")
 
 
-def test_event_enricher_marks_subworkflow_deployment_as_dynamic():
+def test_event_enricher_marks_subworkflow_deployment_as_dynamic(vellum_client):
     """Test that event_enricher treats subworkflow deployments as dynamic."""
 
     class TestWorkflow(BaseWorkflow):
@@ -110,7 +110,7 @@ def test_event_enricher_marks_subworkflow_deployment_as_dynamic():
         ),
     )
 
-    enriched_event = event_enricher(event)
+    enriched_event = event_enricher(event, vellum_client)
 
     assert hasattr(enriched_event.body, "workflow_version_exec_config")
     assert enriched_event.body.workflow_version_exec_config is not None

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -302,7 +302,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             output_values.append(
                 {
                     "output_variable_id": str(workflow_output_display.id),
-                    "value": serialize_value(self.display_context, workflow_output.instance),
+                    "value": serialize_value(self.workflow_id, self.display_context, workflow_output.instance),
                 }
             )