vellum-ai 1.3.8__py3-none-any.whl → 1.3.10__py3-none-any.whl

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
@@ -50,7 +51,6 @@ from vellum.workflows.references.state_value import StateValueReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
-from vellum.workflows.types.definition import DeploymentDefinition
 from vellum.workflows.types.generics import is_workflow_class
 from vellum.workflows.utils.functions import compile_function_definition
 from vellum.workflows.utils.uuids import uuid4_from_hash
@@ -157,7 +157,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 +173,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 +216,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 +228,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 +250,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 +337,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 +368,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,
                     }
@@ -411,30 +424,10 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
             },
         }
 
-    if isinstance(value, DeploymentDefinition):
-        workflow_deployment_release = display_context.client.workflow_deployments.retrieve_workflow_deployment_release(
-            value.deployment, value.release_tag
-        )
-        name = workflow_deployment_release.deployment.name or value.deployment
-        description = workflow_deployment_release.description or f"Workflow Deployment for {name}"
-
-        return {
-            "type": "CONSTANT_VALUE",
-            "value": {
-                "type": "JSON",
-                "value": {
-                    "type": "WORKFLOW_DEPLOYMENT",
-                    "name": name,
-                    "description": description,
-                    "deployment": value.deployment,
-                    "release_tag": value.release_tag,
-                },
-            },
-        }
-
     if isinstance(value, BaseModel):
-        dict_value = value.model_dump()
-        return serialize_value(display_context, dict_value)
+        context = {"executable_id": executable_id, "client": display_context.client}
+        dict_value = value.model_dump(context=context)
+        return serialize_value(executable_id, display_context, dict_value)
 
     if callable(value):
         function_definition = compile_function_definition(value)
@@ -447,7 +440,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 +478,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),
                 }
             )
 

vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -706,12 +706,12 @@ def test_serialize_workflow__dict_reference():
         "type": "DICTIONARY_REFERENCE",
         "entries": [
             {
-                "id": "b528ce26-68ee-42ba-828d-199441810685",
+                "id": "7689f0df-e0bc-4e53-a63f-dbee027f58b9",
                 "key": "key1",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
             },
             {
-                "id": "a7acccfe-2f80-42ee-a307-c1eb0b137c2b",
+                "id": "89e01555-b0b5-42d5-a0a7-bce72716cf65",
                 "key": "key2",
                 "value": {
                     "type": "NODE_OUTPUT",
@@ -720,12 +720,12 @@ def test_serialize_workflow__dict_reference():
                 },
             },
             {
-                "id": "8f41013e-7a9f-4659-ac17-c25c6ec6fe99",
+                "id": "2dc84109-b85c-4732-aa60-8c10a1a377d2",
                 "key": "key3",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
             },
             {
-                "id": "609e84e8-573a-44ea-b3aa-82c3f3cc2c36",
+                "id": "d1b3ce75-1b1e-45e3-b798-beafe6c4826f",
                 "key": "key4",
                 "value": {
                     "type": "NODE_OUTPUT",
@@ -745,18 +745,18 @@ def test_serialize_workflow__dict_reference():
         "type": "DICTIONARY_REFERENCE",
         "entries": [
             {
-                "id": "02abe9d0-bf93-4eea-b34a-902dae7c2b90",
+                "id": "7689f0df-e0bc-4e53-a63f-dbee027f58b9",
                 "key": "key1",
                 "value": {
                     "type": "DICTIONARY_REFERENCE",
                     "entries": [
                         {
-                            "id": "b528ce26-68ee-42ba-828d-199441810685",
+                            "id": "7689f0df-e0bc-4e53-a63f-dbee027f58b9",
                             "key": "key1",
                             "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
                         },
                         {
-                            "id": "a7acccfe-2f80-42ee-a307-c1eb0b137c2b",
+                            "id": "89e01555-b0b5-42d5-a0a7-bce72716cf65",
                             "key": "key2",
                             "value": {
                                 "type": "NODE_OUTPUT",
@@ -768,18 +768,18 @@ def test_serialize_workflow__dict_reference():
                 },
             },
             {
-                "id": "c8640477-13cc-412e-82cc-35cbe9e78ff2",
+                "id": "89e01555-b0b5-42d5-a0a7-bce72716cf65",
                 "key": "key2",
                 "value": {
                     "type": "DICTIONARY_REFERENCE",
                     "entries": [
                         {
-                            "id": "86709f21-a811-4351-993e-a8e9f1c7774f",
+                            "id": "7689f0df-e0bc-4e53-a63f-dbee027f58b9",
                             "key": "key1",
                             "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
                         },
                         {
-                            "id": "a7acccfe-2f80-42ee-a307-c1eb0b137c2b",
+                            "id": "89e01555-b0b5-42d5-a0a7-bce72716cf65",
                             "key": "key2",
                             "value": {
                                 "type": "NODE_OUTPUT",