vellum-ai 0.14.63__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum_ee/workflows/display/types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, Tuple, Type
+from typing import TYPE_CHECKING, Dict, Iterator, List, Optional, Tuple, Type
 
 from vellum.client import Vellum as VellumClient
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 WorkflowInputsDisplays = Dict[WorkflowInputReference, WorkflowInputsDisplay]
 StateValueDisplays = Dict[StateValueReference, StateValueDisplay]
 NodeDisplays = Dict[Type[BaseNode], BaseNodeDisplay]
-NodeOutputDisplays = Dict[OutputReference, Tuple[Type[BaseNode], NodeOutputDisplay]]
+NodeOutputDisplays = Dict[OutputReference, NodeOutputDisplay]
 EntrypointDisplays = Dict[Type[BaseNode], EntrypointDisplay]
 WorkflowOutputDisplays = Dict[BaseDescriptor, WorkflowOutputDisplay]
 EdgeDisplays = Dict[Tuple[Port, Type[BaseNode]], EdgeDisplay]
@@ -51,3 +51,30 @@ class WorkflowDisplayContext:
     workflow_output_displays: WorkflowOutputDisplays = field(default_factory=dict)
     edge_displays: EdgeDisplays = field(default_factory=dict)
     port_displays: PortDisplays = field(default_factory=dict)
+    dry_run: bool = False
+    _errors: List[Exception] = field(default_factory=list)
+    _invalid_nodes: List[Type[BaseNode]] = field(default_factory=list)
+
+    def add_error(self, error: Exception, node: Optional[Type[BaseNode]] = None) -> None:
+        if self.dry_run:
+            self._errors.append(error)
+            return
+
+        raise error
+
+    def add_validation_error(self, error: Exception) -> None:
+        self._errors.append(error)
+
+    def add_invalid_node(self, node: Type[BaseNode]) -> None:
+        """Track a node that failed to serialize."""
+        if node not in self._invalid_nodes:
+            self._invalid_nodes.append(node)
+
+    @property
+    def errors(self) -> Iterator[Exception]:
+        return iter(self._errors)
+
+    @property
+    def invalid_nodes(self) -> Iterator[Type[BaseNode]]:
+        """Get an iterator over nodes that failed to serialize."""
+        return iter(self._invalid_nodes)

vellum_ee/workflows/display/utils/auto_layout.py

@@ -0,0 +1,130 @@
+from collections import defaultdict
+from typing import Dict, List, Set, Tuple
+
+from vellum_ee.workflows.display.base import EdgeDisplay
+from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
+
+
+def auto_layout_nodes(
+    nodes: List[Tuple[str, NodeDisplayData]],
+    edges: List[Tuple[str, str, EdgeDisplay]],
+    node_spacing: float = 150.0,
+    layer_spacing: float = 200.0,
+) -> List[Tuple[str, NodeDisplayData]]:
+    """
+    Auto-layout nodes in a hierarchical left-to-right arrangement.
+
+    Args:
+        nodes: List of (node_id, NodeDisplayData) tuples
+        edges: List of (source_node_id, target_node_id, EdgeDisplay) tuples
+        node_spacing: Vertical spacing between nodes in the same layer
+        layer_spacing: Horizontal spacing between layers
+
+    Returns:
+        List of (node_id, NodeDisplayData) tuples with updated positions
+    """
+    if not nodes:
+        return []
+
+    node_dict = {node_id: data for node_id, data in nodes}
+
+    graph: Dict[str, List[str]] = defaultdict(list)
+    in_degree: Dict[str, int] = defaultdict(int)
+    all_nodes = set(node_dict.keys())
+
+    for source, target, _ in edges:
+        if source in all_nodes and target in all_nodes:
+            graph[source].append(target)
+            in_degree[target] += 1
+
+    for node_id in all_nodes:
+        if node_id not in in_degree:
+            in_degree[node_id] = 0
+
+    layers = _topological_sort_layers(graph, in_degree, all_nodes)
+
+    positioned_nodes = []
+    current_x = 0.0
+
+    for layer in layers:
+        if not layer:
+            continue
+
+        layer_nodes = [(node_id, node_dict[node_id]) for node_id in layer]
+        total_height = _calculate_layer_height(layer_nodes, node_spacing)
+
+        current_y = -total_height / 2.0
+
+        for node_id in layer:
+            node_data = node_dict[node_id]
+            node_height = node_data.height or 100.0
+
+            new_position = NodeDisplayPosition(x=current_x, y=current_y)
+
+            updated_data = NodeDisplayData(
+                position=new_position, width=node_data.width, height=node_data.height, comment=node_data.comment
+            )
+
+            positioned_nodes.append((node_id, updated_data))
+            current_y += node_height + node_spacing
+
+        current_x += layer_spacing
+
+    return positioned_nodes
+
+
+def _topological_sort_layers(
+    graph: Dict[str, List[str]], in_degree: Dict[str, int], all_nodes: Set[str]
+) -> List[List[str]]:
+    """
+    Perform topological sorting and group nodes into layers.
+
+    Returns:
+        List of layers, where each layer is a list of node IDs
+    """
+    layers = []
+    remaining_nodes = set(all_nodes)
+
+    while remaining_nodes:
+        current_layer = []
+        for node in remaining_nodes:
+            if in_degree[node] == 0:
+                current_layer.append(node)
+
+        if not current_layer:
+            current_layer = [next(iter(remaining_nodes))]
+
+        layers.append(current_layer)
+
+        for node in current_layer:
+            remaining_nodes.remove(node)
+            for neighbor in graph[node]:
+                if neighbor in remaining_nodes:
+                    in_degree[neighbor] -= 1
+
+    return [sorted(layer) for layer in layers]
+
+
+def _calculate_layer_height(layer_nodes: List[Tuple[str, NodeDisplayData]], node_spacing: float) -> float:
+    """
+    Calculate the total height needed for a layer of nodes.
+
+    Args:
+        layer_nodes: List of (node_id, NodeDisplayData) tuples in the layer
+        node_spacing: Spacing between nodes
+
+    Returns:
+        Total height needed for the layer
+    """
+    if not layer_nodes:
+        return 0.0
+
+    total_height = 0.0
+    for i, (_, node_data) in enumerate(layer_nodes):
+        node_height = node_data.height or 100.0
+        total_height += node_height
+
+        if i < len(layer_nodes) - 1:
+            total_height += node_spacing
+
+    return total_height

vellum_ee/workflows/display/utils/events.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+from vellum import Vellum
+from vellum.workflows.events.workflow import WorkflowEvent, WorkflowExecutionInitiatedEvent
+from vellum_ee.workflows.display.utils.registry import (
+    get_parent_display_context_from_event,
+    register_workflow_display_class,
+    register_workflow_display_context,
+)
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def _should_mark_workflow_dynamic(event: WorkflowExecutionInitiatedEvent) -> bool:
+    """
+    Check if workflow should be marked as dynamic based on execution context.
+    Returns True if parent.type == WORKFLOW_RELEASE_TAG and parent.parent.type == WORKFLOW_NODE.
+    """
+    if not event.parent:
+        return False
+
+    parent = event.parent
+    if parent.type != "WORKFLOW_RELEASE_TAG":
+        return False
+
+    if not parent.parent or parent.parent.type != "WORKFLOW_NODE":
+        return False
+
+    return True
+
+
+def event_enricher(
+    event: WorkflowEvent, client: Optional[Vellum] = None, metadata: Optional[dict] = None
+) -> WorkflowEvent:
+    if event.name == "workflow.execution.initiated":
+        workflow_definition = event.body.workflow_definition
+        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)
+        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__)
+            workflow_version_exec_config = workflow_display.serialize()
+            setattr(event.body, "workflow_version_exec_config", workflow_version_exec_config)
+
+        if metadata is not None:
+            event.body.server_metadata = metadata
+
+    elif event.name == "workflow.execution.fulfilled":
+        if metadata is not None:
+            event.body.server_metadata = metadata
+
+    return event

vellum_ee/workflows/display/utils/exceptions.py

@@ -5,3 +5,22 @@ class UserFacingException(Exception):
 
 class UnsupportedSerializationException(UserFacingException):
     pass
+
+
+class NodeValidationError(UserFacingException):
+    """Exception raised when a node fails validation during workflow display serialization."""
+
+    def __init__(self, message: str, node_class_name: str):
+        self.message = message
+        self.node_class_name = node_class_name
+        super().__init__(f"Node validation error in {node_class_name}: {message}")
+
+
+class InvalidInputReferenceError(UserFacingException):
+    """Exception raised when a node references a non-existent workflow input."""
+
+    def __init__(self, message: str, inputs_class_name: str, attribute_name: str):
+        self.message = message
+        self.inputs_class_name = inputs_class_name
+        self.attribute_name = attribute_name
+        super().__init__(f"Invalid input reference in {inputs_class_name}.{attribute_name}: {message}")

vellum_ee/workflows/display/utils/expressions.py

@@ -1,12 +1,20 @@
-from typing import TYPE_CHECKING, Any, Dict, List, cast
+from dataclasses import asdict, is_dataclass
+import inspect
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+
+from pydantic import BaseModel
 
 from vellum.client.types.logical_operator import LogicalOperator
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.expressions.add import AddExpression
 from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+from vellum.workflows.expressions.concat import ConcatExpression
 from vellum.workflows.expressions.contains import ContainsExpression
 from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
 from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
@@ -17,29 +25,39 @@ from vellum.workflows.expressions.equals import EqualsExpression
 from vellum.workflows.expressions.greater_than import GreaterThanExpression
 from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
 from vellum.workflows.expressions.in_ import InExpression
+from vellum.workflows.expressions.is_error import IsErrorExpression
 from vellum.workflows.expressions.is_nil import IsNilExpression
 from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
 from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
+from vellum.workflows.expressions.length import LengthExpression
 from vellum.workflows.expressions.less_than import LessThanExpression
 from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.expressions.minus import MinusExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
 from vellum.workflows.expressions.or_ import OrExpression
 from vellum.workflows.expressions.parse_json import ParseJsonExpression
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
+from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 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
+from vellum.workflows.types.generics import is_workflow_class
+from vellum.workflows.utils.files import virtual_open
+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.display.utils.exceptions import InvalidInputReferenceError, UnsupportedSerializationException
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -70,6 +88,8 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "doesNotBeginWith"
     elif isinstance(descriptor, DoesNotEndWithExpression):
         return "doesNotEndWith"
+    elif isinstance(descriptor, IsErrorExpression):
+        return "isError"
     elif isinstance(descriptor, (IsNullExpression, IsNilExpression, IsUndefinedExpression)):
         return "null"
     elif isinstance(descriptor, (IsNotNullExpression, IsNotNilExpression, IsNotUndefinedExpression)):
@@ -90,6 +110,14 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "coalesce"
     elif isinstance(descriptor, ParseJsonExpression):
         return "parseJson"
+    elif isinstance(descriptor, LengthExpression):
+        return "length"
+    elif isinstance(descriptor, AddExpression):
+        return "+"
+    elif isinstance(descriptor, MinusExpression):
+        return "-"
+    elif isinstance(descriptor, ConcatExpression):
+        return "concat"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")
 
@@ -117,29 +145,49 @@ def get_child_descriptor(value: LazyReference, display_context: "WorkflowDisplay
     return value._get()
 
 
-def _serialize_condition(display_context: "WorkflowDisplayContext", condition: BaseDescriptor) -> JsonObject:
+def _get_pydantic_model_definition(model_class: type) -> Optional[JsonObject]:
+    """Extract module path definition from a Pydantic model class."""
+    if not inspect.isclass(model_class) or not issubclass(model_class, BaseModel):
+        return None
+
+    module = model_class.__module__
+    name = model_class.__name__
+
+    module_path = module.split(".")
+
+    return {
+        "name": name,
+        "module": cast(JsonArray, module_path),
+    }
+
+
+def _serialize_condition(
+    executable_id: UUID, display_context: "WorkflowDisplayContext", condition: BaseDescriptor
+) -> JsonObject:
     if isinstance(
         condition,
         (
+            IsErrorExpression,
             IsNullExpression,
             IsNotNullExpression,
             IsNilExpression,
             IsNotNilExpression,
             IsUndefinedExpression,
             IsNotUndefinedExpression,
+            LengthExpression,
             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",
@@ -151,9 +199,11 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
     elif isinstance(
         condition,
         (
+            AddExpression,
             AndExpression,
             BeginsWithExpression,
             CoalesceExpression,
+            ConcatExpression,
             ContainsExpression,
             DoesNotBeginWithExpression,
             DoesNotContainExpression,
@@ -166,12 +216,13 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
             InExpression,
             LessThanExpression,
             LessThanOrEqualToExpression,
+            MinusExpression,
             NotInExpression,
             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",
@@ -182,9 +233,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__}")
@@ -200,15 +251,48 @@ def serialize_key(key: Any) -> str:
         return str(key)
 
 
-def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContext", value: Any) -> Optional[JsonObject]:
+    """
+    Serialize a value to a JSON object. Returns `None` if the value resolves to `undefined`.
+    This is safe because all valid values are a JSON object, including the `None` constant:
+    > `{"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}}`
+
+    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 None
+
     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):
+        if value not in display_context.global_workflow_input_displays:
+            workflow_inputs_class = display_context.workflow_display_class.infer_workflow_class().get_inputs_class()
+            if value.inputs_class != workflow_inputs_class:
+                inputs_class_name = value.inputs_class.__name__
+                workflow_class_name = display_context.workflow_display_class.infer_workflow_class().__name__
+                raise UnsupportedSerializationException(
+                    f"Inputs class '{inputs_class_name}' referenced during serialization of "
+                    f"'{workflow_class_name}' without parameterizing this Workflow with this Inputs definition. "
+                    f"Update your Workflow definition to "
+                    f"'{workflow_class_name}(BaseWorkflow[{inputs_class_name}, BaseState])'."
+                )
+            else:
+                raise InvalidInputReferenceError(
+                    message=f"Inputs class '{value.inputs_class.__qualname__}' has no attribute '{value.name}'",
+                    inputs_class_name=value.inputs_class.__qualname__,
+                    attribute_name=value.name,
+                )
         workflow_input_display = display_context.global_workflow_input_displays[value]
         return {
             "type": "WORKFLOW_INPUT",
@@ -223,12 +307,17 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         }
 
     if isinstance(value, OutputReference):
-        upstream_node, output_display = display_context.global_node_output_displays[value]
-        upstream_node_display = display_context.global_node_displays[upstream_node]
+        output_display = display_context.global_node_output_displays[value]
+
+        upstream_node_class = value.outputs_class.__parent_class__
+        if not issubclass(upstream_node_class, BaseNode):
+            raise ValueError(f"Output references must be to a node, not {upstream_node_class}")
+        unadorned_upstream_node_class = get_unadorned_node(upstream_node_class)
+        upstream_node = display_context.global_node_displays[unadorned_upstream_node_class]
 
         return {
             "type": "NODE_OUTPUT",
-            "node_id": str(upstream_node_display.node_id),
+            "node_id": str(upstream_node.node_id),
             "node_output_id": str(output_display.id),
         }
 
@@ -238,6 +327,21 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
             "vellum_secret_name": value.name,
         }
 
+    if isinstance(value, EnvironmentVariableReference):
+        if value.serialize_as_constant:
+            return {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "STRING",
+                    "value": value.name,
+                },
+            }
+        else:
+            return {
+                "type": "ENVIRONMENT_VARIABLE",
+                "environment_variable": value.name,
+            }
+
     if isinstance(value, ExecutionCountReference):
         node_class_display = display_context.global_node_displays[value.node_class]
 
@@ -246,8 +350,23 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
             "node_id": str(node_class_display.node_id),
         }
 
+    if isinstance(value, TriggerAttributeReference):
+        trigger_class = value.trigger_class
+        trigger_id = trigger_class.__id__
+
+        return {
+            "type": "TRIGGER_ATTRIBUTE",
+            "trigger_id": str(trigger_id),
+            "attribute_id": str(value.id),
+        }
+
     if isinstance(value, list):
-        serialized_items = [serialize_value(display_context, item) for item in value]
+        serialized_items = []
+        for item in value:
+            serialized_item = serialize_value(executable_id, display_context, item)
+            if serialized_item is not None:
+                serialized_items.append(serialized_item)
+
         if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
             constant_values = []
             for item in serialized_items:
@@ -273,15 +392,22 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
                 "items": cast(JsonArray, serialized_items),  # list[JsonObject] -> JsonArray
             }
 
+    if is_dataclass(value) and not isinstance(value, type):
+        dict_value = asdict(value)
+        return serialize_value(executable_id, display_context, dict_value)
+
     if isinstance(value, dict):
-        serialized_entries: List[Dict[str, Any]] = [
-            {
-                "id": str(uuid4_from_hash(f"{key}|{val}")),
-                "key": serialize_key(key),
-                "value": serialize_value(display_context, val),
-            }
-            for key, val in value.items()
-        ]
+        serialized_entries: List[Dict[str, Any]] = []
+        for key, val in value.items():
+            serialized_val = serialize_value(executable_id, display_context, val)
+            if serialized_val is not None:
+                serialized_entries.append(
+                    {
+                        "id": str(uuid4_from_hash(f"{executable_id}|{key}")),
+                        "key": serialize_key(key),
+                        "value": serialized_val,
+                    }
+                )
 
         # Check if all entries have constant values
         if all(entry["value"]["type"] == "CONSTANT_VALUE" for entry in serialized_entries):
@@ -298,7 +424,84 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
                 },
             }
         else:
-            return {"type": "DICTIONARY_REFERENCE", "entries": cast(JsonArray, serialized_entries)}
+            return {
+                "type": "DICTIONARY_REFERENCE",
+                "entries": cast(JsonArray, serialized_entries),
+            }
+
+    if is_workflow_class(value):
+        from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+        # Pass the parent display context so the subworkflow can resolve parent workflow inputs
+        workflow_display = get_workflow_display(
+            workflow_class=value,
+            parent_display_context=display_context,
+        )
+        serialized_value: dict = workflow_display.serialize()
+        name = serialized_value["workflow_raw_data"]["definition"]["name"]
+        description = value.__doc__ or ""
+        return {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": {
+                    "type": "INLINE_WORKFLOW",
+                    "name": name,
+                    "description": description,
+                    "exec_config": serialized_value,
+                },
+            },
+        }
+
+    if isinstance(value, BaseModel):
+        context = {"executable_id": executable_id, "client": display_context.client}
+        dict_value = value.model_dump(context=context)
+        dict_ref = serialize_value(executable_id, display_context, dict_value)
+        if dict_ref is not None and dict_ref.get("type") == "DICTIONARY_REFERENCE":
+            dict_ref["definition"] = _get_pydantic_model_definition(value.__class__)
+        return dict_ref
+
+    if callable(value):
+        function_definition = compile_function_definition(value)
+
+        name = function_definition.name
+        description = function_definition.description or ""
+
+        inputs = getattr(value, "__vellum_inputs__", {})
+
+        if inputs:
+            serialized_inputs = {}
+            for param_name, input_ref in inputs.items():
+                serialized_input = serialize_value(executable_id, display_context, input_ref)
+                if serialized_input is not None:
+                    serialized_inputs[param_name] = serialized_input
+
+            model_data = function_definition.model_dump()
+            model_data["inputs"] = serialized_inputs
+            function_definition_data = model_data
+        else:
+            function_definition_data = function_definition.model_dump()
+
+        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": name,
+                    "description": description,
+                    "definition": function_definition_data,
+                    "src": source_code,
+                },
+            },
+        }
 
     if not isinstance(value, BaseDescriptor):
         vellum_value = primitive_to_vellum_value(value)
@@ -309,4 +512,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)