vellum-ai 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

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

@@ -0,0 +1,88 @@
+from typing import List
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import MapNode
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable import FinalOutputNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.state import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class TestInputs(BaseInputs):
+    items: List[str]
+
+
+class TestIteration(BaseNode):
+    item = MapNode.SubworkflowInputs.item
+    index = MapNode.SubworkflowInputs.index
+
+    class Outputs(BaseOutputs):
+        processed: str
+
+    def run(self) -> Outputs:
+        return self.Outputs(processed=f"processed_{self.item}_{self.index}")
+
+
+class TestIterationSubworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+    graph = TestIteration
+
+    class Outputs(BaseOutputs):
+        processed = TestIteration.Outputs.processed
+
+
+class TestMapNode(MapNode):
+    items = TestInputs.items
+    subworkflow = TestIterationSubworkflow
+
+
+class TestFinalOutputNode(FinalOutputNode[BaseState, List[str]]):
+    class Outputs(FinalOutputNode.Outputs):
+        value = TestMapNode.Outputs.processed
+
+
+class TestWorkflowWithFinalOutputReferencingMap(BaseWorkflow[TestInputs, BaseState]):
+    graph = TestMapNode >> TestFinalOutputNode
+
+    class Outputs(BaseOutputs):
+        final_result = TestFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow__final_output_node_referencing_map_node():
+    """
+    Test that final output nodes referencing map node outputs have correct outputs structure.
+
+    This test verifies that when a FinalOutputNode references a MapNode output,
+    the serialized output contains proper NODE_OUTPUT references instead of None values.
+    This addresses the Agent Builder issue where final outputs showed value=None in the UI.
+    """
+    workflow_display = get_workflow_display(workflow_class=TestWorkflowWithFinalOutputReferencingMap)
+
+    # WHEN we serialize it
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the final output node should have the correct outputs structure
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    map_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "MAP")
+    final_output_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL")
+
+    # AND the map node's subworkflow should have the one output variable
+    output_variable = next(iter(map_node["data"]["output_variables"]))
+    map_node_output_id = output_variable["id"]
+
+    # AND the final output node should have an outputs array with proper structure
+    assert "outputs" in final_output_node
+    outputs = final_output_node["outputs"]
+    assert len(outputs) == 1
+
+    output = outputs[0]
+    # AND the output should have the correct structure with NODE_OUTPUT reference instead of None
+    assert output["name"] == "value"
+    assert output["type"] == "JSON"
+
+    # AND the value should be a NODE_OUTPUT reference, not None
+    assert output["value"] is not None, f"Expected NODE_OUTPUT reference but got None. Full output: {output}"
+    assert output["value"]["type"] == "NODE_OUTPUT", f"Expected NODE_OUTPUT type but got {output['value']['type']}"
+    assert "node_id" in output["value"], f"Missing node_id in output value: {output['value']}"
+    assert output["value"]["node_output_id"] == map_node_output_id

vellum_ee/workflows/display/utils/events.py

@@ -36,6 +36,7 @@ def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionI
         dry_run=True,
     )
     register_workflow_display_context(event.span_id, workflow_display.display_context)
+    event.body.display_context = workflow_display.get_event_display_context()
 
     if event.body.workflow_definition.is_dynamic or _should_mark_workflow_dynamic(event):
         register_workflow_display_class(workflow_definition, workflow_display.__class__)

vellum_ee/workflows/display/utils/expressions.py

@@ -1,8 +1,12 @@
 from dataclasses import asdict, is_dataclass
+import inspect
+from io import StringIO
+import sys
 from typing import TYPE_CHECKING, Any, Dict, List, cast
 
 from pydantic import BaseModel
 
+from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
@@ -48,13 +52,31 @@ 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
 from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.server.virtual_file_loader import VirtualFileLoader
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 
+def virtual_open(file_path: str, mode: str = "r"):
+    """
+    Open a file, checking VirtualFileFinder instances first before falling back to regular open().
+    """
+    for finder in sys.meta_path:
+        if hasattr(finder, "loader") and isinstance(finder.loader, VirtualFileLoader):
+            namespace = finder.loader.namespace
+            if file_path.startswith(namespace + "/"):
+                relative_path = file_path[len(namespace) + 1 :]
+                content = finder.loader._get_code(relative_path)
+                if content is not None:
+                    return StringIO(content)
+
+    return open(file_path, mode)
+
+
 def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperator:
     if isinstance(descriptor, EqualsExpression):
         return "="
@@ -399,6 +421,40 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         dict_value = value.model_dump()
         return serialize_value(display_context, dict_value)
 
+    if callable(value):
+        function_definition = compile_function_definition(value)
+        inputs = getattr(value, "__vellum_inputs__", {})
+
+        if inputs:
+            serialized_inputs = {}
+            for param_name, input_ref in inputs.items():
+                serialized_inputs[param_name] = serialize_value(display_context, input_ref)
+
+            model_data = function_definition.model_dump()
+            model_data["inputs"] = serialized_inputs
+            function_definition = FunctionDefinition.model_validate(model_data)
+
+        source_path = inspect.getsourcefile(value)
+        if source_path is not None:
+            with virtual_open(source_path) as f:
+                source_code = f.read()
+        else:
+            source_code = f"Source code not available for {value.__name__}"
+
+        return {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": {
+                    "type": "CODE_EXECUTION",
+                    "name": function_definition.name,
+                    "description": function_definition.description,
+                    "definition": function_definition.model_dump(),
+                    "src": source_code,
+                },
+            },
+        }
+
     if not isinstance(value, BaseDescriptor):
         vellum_value = primitive_to_vellum_value(value)
         return {

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

@@ -67,9 +67,14 @@ def test_event_enricher_static_workflow(is_dynamic: bool, expected_config: Optio
     # WHEN the event_enricher is called with mocked dependencies
     event_enricher(event)
 
-    # AND workflow_version_exec_config is set to the expected config
+    # THEN workflow_version_exec_config is set to the expected config
     assert event.body.workflow_version_exec_config == expected_config
 
+    assert event.body.display_context is not None
+    assert hasattr(event.body.display_context, "node_displays")
+    assert hasattr(event.body.display_context, "workflow_inputs")
+    assert hasattr(event.body.display_context, "workflow_outputs")
+
 
 def test_event_enricher_marks_subworkflow_deployment_as_dynamic():
     """Test that event_enricher treats subworkflow deployments as dynamic."""
@@ -109,3 +114,8 @@ def test_event_enricher_marks_subworkflow_deployment_as_dynamic():
 
     assert hasattr(enriched_event.body, "workflow_version_exec_config")
     assert enriched_event.body.workflow_version_exec_config is not None
+
+    assert enriched_event.body.display_context is not None
+    assert hasattr(enriched_event.body.display_context, "node_displays")
+    assert hasattr(enriched_event.body.display_context, "workflow_inputs")
+    assert hasattr(enriched_event.body.display_context, "workflow_outputs")

vellum_ee/workflows/display/utils/vellum.py

@@ -102,7 +102,9 @@ def create_node_input_value_pointer_rule(
     if isinstance(value, OutputReference):
         if value not in display_context.global_node_output_displays:
             if issubclass(value.outputs_class, BaseNode.Outputs):
-                raise ValueError(f"Reference to node '{value.outputs_class._node_class.__name__}' not found in graph.")
+                raise ValueError(
+                    f"Reference to node '{value.outputs_class.__parent_class__.__name__}' not found in graph."
+                )
 
             raise ValueError(f"Reference to outputs '{value.outputs_class.__qualname__}' is invalid.")
 

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -294,7 +294,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                     )
 
             elif isinstance(workflow_output.instance, OutputReference):
-                terminal_node_id = workflow_output.instance.outputs_class._node_class.__id__
+                terminal_node_id = workflow_output.instance.outputs_class.__parent_class__.__id__
                 serialized_terminal_node = serialized_nodes.get(terminal_node_id)
                 if serialized_terminal_node and isinstance(serialized_terminal_node["data"], dict):
                     serialized_terminal_node["data"]["name"] = workflow_output_display.name
@@ -329,16 +329,18 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 continue
 
             target_node_display = self.display_context.node_displays[unadorned_target_node]
-            edges.append(
-                {
-                    "id": str(entrypoint_display.edge_display.id),
-                    "source_node_id": str(entrypoint_node_id),
-                    "source_handle_id": str(entrypoint_node_source_handle_id),
-                    "target_node_id": str(target_node_display.node_id),
-                    "target_handle_id": str(target_node_display.get_trigger_id()),
-                    "type": "DEFAULT",
-                }
-            )
+            entrypoint_edge_dict: Dict[str, Json] = {
+                "id": str(entrypoint_display.edge_display.id),
+                "source_node_id": str(entrypoint_node_id),
+                "source_handle_id": str(entrypoint_node_source_handle_id),
+                "target_node_id": str(target_node_display.node_id),
+                "target_handle_id": str(target_node_display.get_trigger_id()),
+                "type": "DEFAULT",
+            }
+            display_data = self._serialize_edge_display_data(entrypoint_display.edge_display)
+            if display_data is not None:
+                entrypoint_edge_dict["display_data"] = display_data
+            edges.append(entrypoint_edge_dict)
 
         for (source_node_port, target_node), edge_display in self.display_context.edge_displays.items():
             unadorned_source_node_port = get_unadorned_port(source_node_port)
@@ -353,18 +355,20 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             source_node_port_display = self.display_context.port_displays[unadorned_source_node_port]
             target_node_display = self.display_context.node_displays[unadorned_target_node]
 
-            edges.append(
-                {
-                    "id": str(edge_display.id),
-                    "source_node_id": str(source_node_port_display.node_id),
-                    "source_handle_id": str(source_node_port_display.id),
-                    "target_node_id": str(target_node_display.node_id),
-                    "target_handle_id": str(
-                        target_node_display.get_target_handle_id_by_source_node_id(source_node_port_display.node_id)
-                    ),
-                    "type": "DEFAULT",
-                }
-            )
+            regular_edge_dict: Dict[str, Json] = {
+                "id": str(edge_display.id),
+                "source_node_id": str(source_node_port_display.node_id),
+                "source_handle_id": str(source_node_port_display.id),
+                "target_node_id": str(target_node_display.node_id),
+                "target_handle_id": str(
+                    target_node_display.get_target_handle_id_by_source_node_id(source_node_port_display.node_id)
+                ),
+                "type": "DEFAULT",
+            }
+            display_data = self._serialize_edge_display_data(edge_display)
+            if display_data is not None:
+                regular_edge_dict["display_data"] = display_data
+            edges.append(regular_edge_dict)
 
         edges.extend(synthetic_output_edges)
 
@@ -405,6 +409,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             "output_variables": output_variables,
         }
 
+    def _serialize_edge_display_data(self, edge_display: EdgeDisplay) -> Optional[JsonObject]:
+        """Serialize edge display data, returning None if no display data is present."""
+        if edge_display.z_index is not None:
+            return {"z_index": edge_display.z_index}
+        return None
+
     def _apply_auto_layout(self, nodes_dict_list: List[Dict[str, Any]], edges: List[Json]) -> None:
         """Apply auto-layout to nodes that are all positioned at (0,0)."""
         nodes_for_layout: List[Tuple[str, NodeDisplayData]] = []
@@ -589,7 +599,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
             workflow_output_display = self.output_displays.get(workflow_output)
             workflow_output_displays[workflow_output] = (
-                workflow_output_display or self._generate_workflow_output_display(workflow_output)
+                workflow_output_display or self._generate_workflow_output_display(workflow_output, self._workflow)
             )
 
         return WorkflowDisplayContext(
@@ -678,9 +688,13 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
         return EntrypointDisplay(id=entrypoint_id, edge_display=edge_display)
 
-    def _generate_workflow_output_display(self, output: BaseDescriptor) -> WorkflowOutputDisplay:
-        output_id = uuid4_from_hash(f"{self.workflow_id}|id|{output.name}")
-
+    def _generate_workflow_output_display(
+        self, output: OutputReference, workflow_class: Type[BaseWorkflow]
+    ) -> WorkflowOutputDisplay:
+        # TODO: use the output.id field instead once we add `__parent_class__` to BaseWorkflow.Outputs
+        output_id = workflow_class.__output_ids__.get(output.name) or uuid4_from_hash(
+            f"{self.workflow_id}|id|{output.name}"
+        )
         return WorkflowOutputDisplay(id=output_id, name=output.name)
 
     def __init_subclass__(cls, **kwargs: Any) -> None: