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

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),
                 }
             )
 

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",