vellum-ai 0.14.49__py3-none-any.whl → 0.14.50__py3-none-any.whl

vellum/__init__.py

@@ -544,7 +544,9 @@ from .types import (
     WorkflowExecutionSpanAttributes,
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
-    WorkflowExecutionUsageCalculationFulfilledBody,
+    WorkflowExecutionUsageCalculationError,
+    WorkflowExecutionUsageCalculationErrorCodeEnum,
+    WorkflowExecutionUsageResult,
     WorkflowExecutionViewOnlineEvalMetricResult,
     WorkflowExecutionWorkflowResultEvent,
     WorkflowExpandMetaRequest,
@@ -1177,7 +1179,9 @@ __all__ = [
     "WorkflowExecutionSpanAttributes",
     "WorkflowExecutionStreamingBody",
     "WorkflowExecutionStreamingEvent",
-    "WorkflowExecutionUsageCalculationFulfilledBody",
+    "WorkflowExecutionUsageCalculationError",
+    "WorkflowExecutionUsageCalculationErrorCodeEnum",
+    "WorkflowExecutionUsageResult",
     "WorkflowExecutionViewOnlineEvalMetricResult",
     "WorkflowExecutionWorkflowResultEvent",
     "WorkflowExpandMetaRequest",

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.49",
+            "X-Fern-SDK-Version": "0.14.50",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/client/types/__init__.py

@@ -568,7 +568,9 @@ from .workflow_execution_span import WorkflowExecutionSpan
 from .workflow_execution_span_attributes import WorkflowExecutionSpanAttributes
 from .workflow_execution_streaming_body import WorkflowExecutionStreamingBody
 from .workflow_execution_streaming_event import WorkflowExecutionStreamingEvent
-from .workflow_execution_usage_calculation_fulfilled_body import WorkflowExecutionUsageCalculationFulfilledBody
+from .workflow_execution_usage_calculation_error import WorkflowExecutionUsageCalculationError
+from .workflow_execution_usage_calculation_error_code_enum import WorkflowExecutionUsageCalculationErrorCodeEnum
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
 from .workflow_execution_view_online_eval_metric_result import WorkflowExecutionViewOnlineEvalMetricResult
 from .workflow_execution_workflow_result_event import WorkflowExecutionWorkflowResultEvent
 from .workflow_expand_meta_request import WorkflowExpandMetaRequest
@@ -1154,7 +1156,9 @@ __all__ = [
     "WorkflowExecutionSpanAttributes",
     "WorkflowExecutionStreamingBody",
     "WorkflowExecutionStreamingEvent",
-    "WorkflowExecutionUsageCalculationFulfilledBody",
+    "WorkflowExecutionUsageCalculationError",
+    "WorkflowExecutionUsageCalculationErrorCodeEnum",
+    "WorkflowExecutionUsageResult",
     "WorkflowExecutionViewOnlineEvalMetricResult",
     "WorkflowExecutionWorkflowResultEvent",
     "WorkflowExpandMetaRequest",

vellum/client/types/deployment_read.py

@@ -50,7 +50,7 @@ class DeploymentRead(UniversalBaseModel):
 
     active_model_version_ids: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
     """
-    Deprecated. This now always returns a null value.
+    Deprecated. This now always returns an empty array.
     """
 
     last_deployed_history_item_id: str = pydantic.Field()

vellum/client/types/slim_workflow_execution_read.py

@@ -15,7 +15,7 @@ from .execution_vellum_value import ExecutionVellumValue
 from .workflow_error import WorkflowError
 from .workflow_execution_actual import WorkflowExecutionActual
 from .workflow_execution_view_online_eval_metric_result import WorkflowExecutionViewOnlineEvalMetricResult
-from .workflow_execution_usage_calculation_fulfilled_body import WorkflowExecutionUsageCalculationFulfilledBody
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -30,7 +30,7 @@ class SlimWorkflowExecutionRead(UniversalBaseModel):
     error: typing.Optional[WorkflowError] = None
     latest_actual: typing.Optional[WorkflowExecutionActual] = None
     metric_results: typing.List[WorkflowExecutionViewOnlineEvalMetricResult]
-    usage_results: typing.List[WorkflowExecutionUsageCalculationFulfilledBody]
+    usage_results: typing.Optional[typing.List[WorkflowExecutionUsageResult]] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_event_execution_read.py

@@ -15,7 +15,7 @@ from .execution_vellum_value import ExecutionVellumValue
 from .workflow_error import WorkflowError
 from .workflow_execution_actual import WorkflowExecutionActual
 from .workflow_execution_view_online_eval_metric_result import WorkflowExecutionViewOnlineEvalMetricResult
-from .workflow_execution_usage_calculation_fulfilled_body import WorkflowExecutionUsageCalculationFulfilledBody
+from .workflow_execution_usage_result import WorkflowExecutionUsageResult
 from .vellum_span import VellumSpan
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
@@ -31,7 +31,7 @@ class WorkflowEventExecutionRead(UniversalBaseModel):
     error: typing.Optional[WorkflowError] = None
     latest_actual: typing.Optional[WorkflowExecutionActual] = None
     metric_results: typing.List[WorkflowExecutionViewOnlineEvalMetricResult]
-    usage_results: typing.List[WorkflowExecutionUsageCalculationFulfilledBody]
+    usage_results: typing.Optional[typing.List[WorkflowExecutionUsageResult]] = None
     spans: typing.List[VellumSpan]
 
     if IS_PYDANTIC_V2:

vellum/client/types/{workflow_execution_usage_calculation_fulfilled_body.py → workflow_execution_usage_calculation_error.py}

@@ -1,16 +1,15 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from .ml_model_usage_wrapper import MlModelUsageWrapper
-from .price import Price
+from .workflow_execution_usage_calculation_error_code_enum import WorkflowExecutionUsageCalculationErrorCodeEnum
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
 import pydantic
 
 
-class WorkflowExecutionUsageCalculationFulfilledBody(UniversalBaseModel):
-    usage: typing.List[MlModelUsageWrapper]
-    cost: typing.List[Price]
+class WorkflowExecutionUsageCalculationError(UniversalBaseModel):
+    code: WorkflowExecutionUsageCalculationErrorCodeEnum
+    message: str
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_execution_usage_calculation_error_code_enum.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+WorkflowExecutionUsageCalculationErrorCodeEnum = typing.Union[
+    typing.Literal["UNKNOWN", "DEPENDENCIES_FAILED", "NO_USAGE_CALCULATED", "INTERNAL_SERVER_ERROR"], typing.Any
+]

vellum/client/types/workflow_execution_usage_result.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .ml_model_usage_wrapper import MlModelUsageWrapper
+from .price import Price
+from .workflow_execution_usage_calculation_error import WorkflowExecutionUsageCalculationError
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class WorkflowExecutionUsageResult(UniversalBaseModel):
+    usage: typing.Optional[typing.List[MlModelUsageWrapper]] = None
+    cost: typing.Optional[typing.List[Price]] = None
+    error: typing.Optional[WorkflowExecutionUsageCalculationError] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/types/{workflow_execution_usage_calculation_fulfilled_body.py → workflow_execution_usage_calculation_error.py}

@@ -1,3 +1,3 @@
 # WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
 
-from vellum.client.types.workflow_execution_usage_calculation_fulfilled_body import *
+from vellum.client.types.workflow_execution_usage_calculation_error import *

vellum/types/workflow_execution_usage_calculation_error_code_enum.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.workflow_execution_usage_calculation_error_code_enum import *

vellum/types/workflow_execution_usage_result.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.workflow_execution_usage_result import *

vellum/workflows/nodes/core/map_node/node.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
+import concurrent.futures
 import logging
 from queue import Empty, Queue
-from threading import Thread
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -75,95 +75,90 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
             return
 
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
-        self._concurrency_queue: Queue[Thread] = Queue()
-        fulfilled_iterations: List[bool] = []
-        for index, item in enumerate(self.items):
-            fulfilled_iterations.append(False)
+        fulfilled_iterations: List[bool] = [False] * len(self.items)
+
+        max_workers = self.max_concurrency if self.max_concurrency is not None else len(self.items)
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = []
             current_execution_context = get_execution_context()
-            thread = Thread(
-                target=self._context_run_subworkflow,
-                kwargs={
-                    "item": item,
-                    "index": index,
-                    "current_execution_context": current_execution_context,
-                },
-            )
-            if self.max_concurrency is None:
-                thread.start()
-            else:
-                self._concurrency_queue.put(thread)
-
-        if self.max_concurrency is not None:
-            concurrency_count = 0
-            while concurrency_count < self.max_concurrency:
-                is_empty = self._start_thread()
-                if is_empty:
-                    break
-
-                concurrency_count += 1
-
-        try:
-            while map_node_event := self._event_queue.get():
-                index = map_node_event[0]
-                subworkflow_event = map_node_event[1]
-                self._context._emit_subworkflow_event(subworkflow_event)
-
-                if not is_workflow_event(subworkflow_event):
-                    continue
-
-                if subworkflow_event.workflow_definition != self.subworkflow:
-                    continue
-
-                if subworkflow_event.name == "workflow.execution.initiated":
-                    for output_name in mapped_items.keys():
-                        yield BaseOutput(name=output_name, delta=(None, index, "INITIATED"))
-
-                elif subworkflow_event.name == "workflow.execution.fulfilled":
-                    for output_reference, output_value in subworkflow_event.outputs:
-                        if not isinstance(output_reference, OutputReference):
-                            logger.error(
-                                "Invalid key to map node's subworkflow event outputs",
-                                extra={"output_reference_type": type(output_reference)},
+            for index, item in enumerate(self.items):
+                future = executor.submit(
+                    self._context_run_subworkflow,
+                    item=item,
+                    index=index,
+                    current_execution_context=current_execution_context,
+                )
+                futures.append(future)
+
+            while not all(fulfilled_iterations):
+                try:
+                    map_node_event = self._event_queue.get(block=False)
+                    index = map_node_event[0]
+                    subworkflow_event = map_node_event[1]
+                    self._context._emit_subworkflow_event(subworkflow_event)
+
+                    if not is_workflow_event(subworkflow_event):
+                        continue
+
+                    if subworkflow_event.workflow_definition != self.subworkflow:
+                        continue
+
+                    if subworkflow_event.name == "workflow.execution.initiated":
+                        for output_name in mapped_items.keys():
+                            yield BaseOutput(name=output_name, delta=(None, index, "INITIATED"))
+
+                    elif subworkflow_event.name == "workflow.execution.fulfilled":
+                        for output_reference, output_value in subworkflow_event.outputs:
+                            if not isinstance(output_reference, OutputReference):
+                                logger.error(
+                                    "Invalid key to map node's subworkflow event outputs",
+                                    extra={"output_reference_type": type(output_reference)},
+                                )
+                                continue
+
+                            output_mapped_items = mapped_items[output_reference.name]
+                            if index < 0 or index >= len(output_mapped_items):
+                                logger.error(
+                                    "Invalid map node index",
+                                    extra={"index": index, "output_name": output_reference.name},
+                                )
+                                continue
+
+                            output_mapped_items[index] = output_value
+                            yield BaseOutput(
+                                name=output_reference.name,
+                                delta=(output_value, index, "FULFILLED"),
                             )
-                            continue
 
-                        output_mapped_items = mapped_items[output_reference.name]
-                        if index < 0 or index >= len(output_mapped_items):
-                            logger.error(
-                                "Invalid map node index", extra={"index": index, "output_name": output_reference.name}
-                            )
-                            continue
+                        fulfilled_iterations[index] = True
 
-                        output_mapped_items[index] = output_value
-                        yield BaseOutput(
-                            name=output_reference.name,
-                            delta=(output_value, index, "FULFILLED"),
+                    elif subworkflow_event.name == "workflow.execution.paused":
+                        raise NodeException(
+                            code=WorkflowErrorCode.INVALID_OUTPUTS,
+                            message=f"Subworkflow unexpectedly paused on iteration {index}",
                         )
+                    elif subworkflow_event.name == "workflow.execution.rejected":
+                        raise NodeException(
+                            f"Subworkflow failed on iteration {index} with error: {subworkflow_event.error.message}",
+                            code=subworkflow_event.error.code,
+                        )
+                except Empty:
+                    all_futures_done = all(future.done() for future in futures)
 
-                    fulfilled_iterations[index] = True
-                    if all(fulfilled_iterations):
-                        break
-
-                    if self.max_concurrency is not None:
-                        self._start_thread()
-                elif subworkflow_event.name == "workflow.execution.paused":
-                    raise NodeException(
-                        code=WorkflowErrorCode.INVALID_OUTPUTS,
-                        message=f"Subworkflow unexpectedly paused on iteration {index}",
-                    )
-                elif subworkflow_event.name == "workflow.execution.rejected":
-                    raise NodeException(
-                        f"Subworkflow failed on iteration {index} with error: {subworkflow_event.error.message}",
-                        code=subworkflow_event.error.code,
-                    )
-        except Empty:
-            pass
+                    if all_futures_done:
+                        if not all(fulfilled_iterations):
+                            if self._event_queue.empty():
+                                logger.warning("All threads completed but not all iterations fulfilled")
+                                break
+                        else:
+                            break
 
         for output_name, output_list in mapped_items.items():
             yield BaseOutput(name=output_name, value=output_list)
 
     def _context_run_subworkflow(
-        self, *, item: MapNodeItemType, index: int, current_execution_context: ExecutionContext
+        self, item: MapNodeItemType, index: int, current_execution_context: ExecutionContext
     ) -> None:
         parent_context = current_execution_context.parent_context
         trace_id = current_execution_context.trace_id
@@ -186,14 +181,6 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         for event in events:
             self._event_queue.put((index, event))
 
-    def _start_thread(self) -> bool:
-        if self._concurrency_queue.empty():
-            return False
-
-        thread = self._concurrency_queue.get()
-        thread.start()
-        return True
-
     @overload
     @classmethod
     def wrap(

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -1,3 +1,5 @@
+import datetime
+import threading
 import time
 
 from vellum.workflows.inputs.base import BaseInputs
@@ -172,3 +174,50 @@ def test_map_node__nested_map_node():
         ["apple carrot", "apple potato"],
         ["banana carrot", "banana potato"],
     ]
+
+
+def test_map_node_parallel_execution_with_workflow():
+    # TODO: Find a better way to test this such that it represents what a user would see.
+    # https://linear.app/vellum/issue/APO-482/find-a-better-way-to-test-concurrency-with-map-nodes
+    thread_ids = {}
+
+    # GIVEN a series of nodes that simulate work
+    class BaseNode1(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            output: str
+            thread_id: int
+
+        def run(self) -> Outputs:
+            current_thread_id = threading.get_ident()
+            thread_ids[self.item] = current_thread_id
+
+            # Simulate work
+            time.sleep(0.01)
+
+            end = time.time()
+            end_str = datetime.datetime.fromtimestamp(end).strftime("%Y-%m-%d %H:%M:%S.%f")
+
+            return self.Outputs(output=end_str, thread_id=current_thread_id)
+
+    # AND a workflow that connects these nodes
+    class TestWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = BaseNode1
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = BaseNode1.Outputs.output
+            thread_id = BaseNode1.Outputs.thread_id
+
+    # AND a map node that uses this workflow
+    class TestMapNode(MapNode):
+        items = [1, 2, 3]
+        subworkflow = TestWorkflow
+
+    # WHEN we run the map node
+    node = TestMapNode()
+    list(node.run())
+
+    # AND each item should have run on a different thread
+    thread_ids_list = list(thread_ids.values())
+    assert len(set(thread_ids_list)) == 3

vellum/workflows/state/encoder.py

@@ -13,6 +13,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState, NodeExecutionCache
+from vellum.workflows.utils.functions import compile_function_definition
 
 
 class DefaultStateEncoder(JSONEncoder):
@@ -57,6 +58,9 @@ class DefaultStateEncoder(JSONEncoder):
         if isinstance(obj, type):
             return str(obj)
 
+        if callable(obj):
+            return compile_function_definition(obj)
+
         if obj.__class__ in self.encoders:
             return self.encoders[obj.__class__](obj)
 

vellum/workflows/workflows/base.py

@@ -276,6 +276,14 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         """
         return cls._get_edges_from_subgraphs(cls.get_unused_subgraphs())
 
+    @classmethod
+    def get_all_nodes(cls) -> Iterator[Type[BaseNode]]:
+        """
+        Returns an iterator over all nodes in the Workflow, used or unused.
+        """
+        yield from cls.get_nodes()
+        yield from cls.get_unused_nodes()
+
     @classmethod
     def get_entrypoints(cls) -> Iterable[Type[BaseNode]]:
         return iter({e for g in cls.get_subgraphs() for e in g.entrypoints})

{vellum_ai-0.14.49.dist-info → vellum_ai-0.14.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.49
+Version: 0.14.50
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.14.49.dist-info → vellum_ai-0.14.50.dist-info}/RECORD

@@ -26,8 +26,8 @@ vellum_ee/workflows/display/base.py,sha256=EqlQFD56kpqMY02ZBJBQajzJKh33Dwi60Wo77
 vellum_ee/workflows/display/editor/__init__.py,sha256=MSAgY91xCEg2neH5d8jXx5wRdR962ftZVa6vO9BGq9k,167
 vellum_ee/workflows/display/editor/types.py,sha256=x-tOOCJ6CF4HmiKDfCmcc3bOVfc1EBlP5o6u5WEfLoY,567
 vellum_ee/workflows/display/nodes/__init__.py,sha256=jI1aPBQf8DkmrYoZ4O-wR1duqZByOf5mDFmo_wFJPE4,307
-vellum_ee/workflows/display/nodes/base_node_display.py,sha256=1VoNyAw9MzgGePI2wrOShsNccrbS4bTuu3bnTii0Wu4,15480
-vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=gKAZfc7JBLzcwYPchnpHy2nMVMPmltAszOwLyXDrro0,2085
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=mzODbbNfrjOi7rVQb6FFCEjQHZkTs76nAc8L-Q5yCnQ,16491
+vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=jI_kUi9LnNLDpY63QtlC4TfN8P571VN4LpzH0I1ZtLk,1149
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/tests/test_base_node_display.py,sha256=Z4Mf7xLCNiblSbpKI0BrV5modQr-ZcFzhfir_OSyTTs,2997
 vellum_ee/workflows/display/nodes/types.py,sha256=St1BB6no528OyELGiyRabWao0GGw6mLhstQAvEACbGk,247
@@ -89,19 +89,20 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=KkYZc_bZuq1lmDcvUz3QxIqJLpQPCZioD1FHUNsMJY8,11211
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=aZaqRDrkO3ytcmdM2eKJqHSt60MF070NMj6M2vgzOKc,7711
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=r748dpS13HtwY7t_KQFExFssxRy0xI2d-wxmhiUHRe0,3850
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=rp9suYcwVZPpIQ3ChlWWvahMlaUd7u-31VmesR0Mn8w,7683
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=EL5kfakuoEcwD85dGjhMta-J-PpCHRSDoc80SdbBrQk,2769
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=RmFUDx8dYdfsOE2CGLvdXqNNRtLLpVzXDN8dqZyMcZ8,5822
 vellum_ee/workflows/display/types.py,sha256=i4T7ElU5b5h-nA1i3scmEhO1BqmNDc4eJDHavATD88w,2821
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/exceptions.py,sha256=LSwwxCYNxFkf5XMUcFkaZKpQ13OSrI7y_bpEUwbKVk0,169
-vellum_ee/workflows/display/utils/expressions.py,sha256=gbc_UDogJEI1juSNPfR3a-OXu2sIH7w3vLLw4YjOqDc,12416
+vellum_ee/workflows/display/utils/expressions.py,sha256=qsKRgxm9zKFgAgjc9LqKEWP1rtdzXA1NDsXu9kyhf60,12416
 vellum_ee/workflows/display/utils/registry.py,sha256=fWIm5Jj-10gNFjgn34iBu4RWv3Vd15ijtSN0V97bpW8,1513
 vellum_ee/workflows/display/utils/vellum.py,sha256=mtoXmSYwR7rvrq-d6CzCW_auaJXTct0Mi1F0xpRCiNQ,5627
 vellum_ee/workflows/display/vellum.py,sha256=o7mq_vk2Yapu9DDKRz5l76h8EmCAypWGQYe6pryrbB8,3576
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
-vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=NuWlnGNe3Htcfh-l_8e37uitdUsy6WZNB7W7dYcCoUg,33355
+vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=DbjLChDtlNAs86sWL5-ojYYzwFsOjACAGfquxM3VYcw,32563
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=gxz76AeCqgAZ9D2lZeTiZzxY9eMgn3qOSfVgiqYcOh8,2028
-vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=gTKddCTGzjWHJ8v4E0XqCLgxKuSXaFveoN2IT1LxrPw,29472
+vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=rRwXLgsXqiaSn3jzP7lc--pytRW3Jmnj2-zNq5l-FQ4,29472
 vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=aaKdmWrgEe5YyV4zuDY_4E3y-l59rIHQnNGiPj2OWxQ,359
 vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/server/virtual_file_loader.py,sha256=7JphJcSO3H85qiC2DpFfBWjC3JjrbRmoynBC6KKHVsA,2710
@@ -127,12 +128,12 @@ vellum_ee/workflows/tests/local_workflow/workflow.py,sha256=A4qOzOPNwePYxWbcAgIP
 vellum_ee/workflows/tests/test_display_meta.py,sha256=C25dErwghPNXio49pvSRxyOuc96srH6eYEwTAWdE2zY,2258
 vellum_ee/workflows/tests/test_server.py,sha256=SsOkS6sGO7uGC4mxvk4iv8AtcXs058P9hgFHzTWmpII,14519
 vellum_ee/workflows/tests/test_virtual_files.py,sha256=TJEcMR0v2S8CkloXNmCHA0QW0K6pYNGaIjraJz7sFvY,2762
-vellum/__init__.py,sha256=4UwLVTlKBQ0cTIJ3NTqxw51aEFNUPfmJ-rVYP1yVUU0,41758
+vellum/__init__.py,sha256=Hqfl49WZJzzqOKzVsTGi-j9twIqFOoRmACJsrEsjL44,41918
 vellum/client/README.md,sha256=qmaVIP42MnxAu8jV7u-CsgVFfs3-pHQODrXdZdFxtaw,4749
 vellum/client/__init__.py,sha256=PEnFl7LbXQcvAi3bVN2qyt5xm2FtVtq7xWKkcWM3Tg4,120166
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=fgLMgzbjkk4zz3CHZ_Wdqz6Sz1JL4L0v7uiNheKIcZA,1869
+vellum/client/core/client_wrapper.py,sha256=0Uo8ifbV1rC2jIjuU95Td5DeLVDs0xqQP3DETAbhbEU,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/http_client.py,sha256=Z77OIxIbL4OAB2IDqjRq_sYa5yNYAWfmdhdCSSvh6Y4,19552
@@ -200,7 +201,7 @@ vellum/client/resources/workspace_secrets/__init__.py,sha256=FTtvy8EDg9nNNg9WCat
 vellum/client/resources/workspace_secrets/client.py,sha256=zlBdbeTP6sqvtyl_DlrpfG-W5hSP7tJ1NYLSygi4CLU,8205
 vellum/client/resources/workspaces/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 vellum/client/resources/workspaces/client.py,sha256=RthwzN1o-Jxwg5yyNNodavFyNUSxfLoTv26w3mRR5g8,3595
-vellum/client/types/__init__.py,sha256=DODWRvaxjqdVCvpr4b6kxku_2WZKSvl7lEl6tSr_gXU,63222
+vellum/client/types/__init__.py,sha256=wFQ3c_Pu8mGQFHIUy5dORq6Afmp5jdl9pnfUizIXjtI,63474
 vellum/client/types/ad_hoc_execute_prompt_event.py,sha256=bCjujA2XsOgyF3bRZbcEqV2rOIymRgsLoIRtZpB14xg,607
 vellum/client/types/ad_hoc_expand_meta.py,sha256=1gv-NCsy_6xBYupLvZH979yf2VMdxAU-l0y0ynMKZaw,1331
 vellum/client/types/ad_hoc_fulfilled_prompt_execution_meta.py,sha256=oDG60TpwK1YNSKhRsBbiP2O3ZF9PKR-M9chGIfKw4R4,1004
@@ -271,7 +272,7 @@ vellum/client/types/create_test_suite_test_case_request.py,sha256=3LmAy6U8tUJ75d
 vellum/client/types/deployment_history_item.py,sha256=-u7UYEFpVOlFijErPLGO99WYQxAnctZK52W-GM4KJJU,1132
 vellum/client/types/deployment_provider_payload_response.py,sha256=b0lkt0rK88ARQaMWn9MAHeWtMBsZKofDMlOAUsQvv7g,818
 vellum/client/types/deployment_provider_payload_response_payload.py,sha256=xHLQnWFN0AZRZdrOiKawwpoKK7BTmnZfp0P7FCc2ZqE,188
-vellum/client/types/deployment_read.py,sha256=TYhgfS9rU_pyLfdSq7Ek-6WAMLEiryGJkB6Z-sZaj7A,1975
+vellum/client/types/deployment_read.py,sha256=l6cy00p4y7JncJ-BwVl_NdCVWPNRjZqFz6DdL2vTTqY,1977
 vellum/client/types/deployment_release_tag_deployment_history_item.py,sha256=df4qKHT1f-z0jnRS4UmP8MQe6u3PwYej_d8KDF7EL88,631
 vellum/client/types/deployment_release_tag_read.py,sha256=dUrTOz9LH1gAvC_ktMB_7NztkeBnlNSX_9x15Ld3D3I,1278
 vellum/client/types/docker_service_token.py,sha256=T0icNHBKsIs6TrEiDRjckM_f37hcF1DMwEE8161tTvY,614
@@ -565,7 +566,7 @@ vellum/client/types/slim_document.py,sha256=HJiymYPvRxfxhBUkD8epW0hQ2Vt9PQtv398Q
 vellum/client/types/slim_document_document_to_document_index.py,sha256=vo7WbRRzbApQxT0MZu_NkjQmsFD8LoezmyeKBeGZpI8,1346
 vellum/client/types/slim_release_review.py,sha256=7DXmD1AVa_Wj7e0qiR7GUN9cSqwkk1JloYmp_3oluQQ,783
 vellum/client/types/slim_workflow_deployment.py,sha256=Js-ycMFZ8-kNFPsd4bZew9nI_eN2M_58LzDHeCjkfTg,2009
-vellum/client/types/slim_workflow_execution_read.py,sha256=yZvOqC9z9qa3jlnRgrSlSybwPeY-cX-xuTmZXkPVops,1968
+vellum/client/types/slim_workflow_execution_read.py,sha256=Opm1HTYVMz_D2USQCB-5ZoJ4EjKKfrDhoXc0hETldVM,1936
 vellum/client/types/span_link.py,sha256=2NISI8V94W0MeIdos7aSKFmpVJgEEunuSEnKlWTUH5c,1353
 vellum/client/types/span_link_type_enum.py,sha256=NaBXnHnOKMZvgHfjhwJJNqM4wuTOxtGkMIXjN2hU-6A,130
 vellum/client/types/streaming_ad_hoc_execute_prompt_event.py,sha256=NdgmJ3AZMp6io-whZIGnGb49aiqz6__KafsrzjEF_9o,1183
@@ -717,7 +718,7 @@ vellum/client/types/workflow_deployment_release_workflow_deployment.py,sha256=ir
 vellum/client/types/workflow_deployment_release_workflow_version.py,sha256=V1Eb3goBX2lle851LkhR1tbCFa0z_O-yhMuQWCN6c-g,773
 vellum/client/types/workflow_error.py,sha256=EQajkEmLS64T0wYm0goHQl0rT7Lguurk8pLwkhjsgAI,282
 vellum/client/types/workflow_event_error.py,sha256=HIewu_kh3KNPpWegAQArvAGHCp-cBIXqlUAAc_dBZhc,687
-vellum/client/types/workflow_event_execution_read.py,sha256=S3o33XQYfo4JPmkXUJ-ZxCqvLfcemFeWrmOc4SGzV74,2040
+vellum/client/types/workflow_event_execution_read.py,sha256=TQaBs2ZkOOJOjCkdmgI9ZX7c4XgIaNIBozCmZlOoZp8,2008
 vellum/client/types/workflow_execution_actual.py,sha256=YL5WL4O4CyaZWSrxqpE4chJ28EJlyScj5JeaLttegEg,843
 vellum/client/types/workflow_execution_actual_chat_history_request.py,sha256=L6U8tgM7SiU4qGJMZChFzj6HfHgO-YAlTXfbT7ZIaE4,1993
 vellum/client/types/workflow_execution_actual_json_request.py,sha256=5QYaPCSOwFnjH_kTrB2bTznTMFExSZdBhTkmelf1h4Q,1931
@@ -741,7 +742,9 @@ vellum/client/types/workflow_execution_span.py,sha256=3vHEx3k31fLacQaV2iMT-vibjw
 vellum/client/types/workflow_execution_span_attributes.py,sha256=SRW7mD-6uS8eA57EU6q2thBqSFfJSH4tXI9H3szZwYQ,575
 vellum/client/types/workflow_execution_streaming_body.py,sha256=phni9pJKkFGsQ5IcS4ogtG1EjBzpdBiYpN9CPbkjxH8,746
 vellum/client/types/workflow_execution_streaming_event.py,sha256=_xazehYJ5ZwTDc5cC7rpX7nDir_4glPOnx9c9ZPod1g,1551
-vellum/client/types/workflow_execution_usage_calculation_fulfilled_body.py,sha256=TyEIbdTWfvRjS3TGx44Mwttc274gRzLB9YjvkE0BmTw,729
+vellum/client/types/workflow_execution_usage_calculation_error.py,sha256=O44pAaA3pOpn6dqxfsAFx4QnXeVfIggGWbgmTzQV4Ms,754
+vellum/client/types/workflow_execution_usage_calculation_error_code_enum.py,sha256=O8CGCaWKuhnRjmQXTsw4gQn5hfDFiKED8bJYzP8R0LM,258
+vellum/client/types/workflow_execution_usage_result.py,sha256=wZdRqzG_Lwi8gqDHGEU6ayx3pvO9oe8hIPzDDePELz8,928
 vellum/client/types/workflow_execution_view_online_eval_metric_result.py,sha256=1qxIHqBRhEMfbOhBpztOPhcH3mqe7bfezO7PUHUfDg4,759
 vellum/client/types/workflow_execution_workflow_result_event.py,sha256=gjyXmojwtAOtAzpILpFkJB9tM02okSXqYRw9-3rTVDA,939
 vellum/client/types/workflow_expand_meta_request.py,sha256=-6I1Zveo3wFJEWbmSsN9OiOI7ekCJxF4xEL_ApB6XE8,1151
@@ -1415,7 +1418,9 @@ vellum/types/workflow_execution_span.py,sha256=qnyiKgPrKKl0lvVtmpm09zOMTWKDBZ9nD
 vellum/types/workflow_execution_span_attributes.py,sha256=LCyfr-e1lwrTpMge9agbjtVDxt1l1FTZK8koMqxy6VM,172
 vellum/types/workflow_execution_streaming_body.py,sha256=MjkV8RLMtFj1r0yGPIuhf4Dz_EFeVU2tN8Oz6-cPssQ,171
 vellum/types/workflow_execution_streaming_event.py,sha256=XDEyaGRMfR9cpaRJ-WCb0O-o4LAdoMPCbjRLdYI1r-0,172
-vellum/types/workflow_execution_usage_calculation_fulfilled_body.py,sha256=Vabch9oglYZehKyAvOuAKhbASKAoLWqK0dg7pqaa3s4,189
+vellum/types/workflow_execution_usage_calculation_error.py,sha256=tMF1PYRRKjC0N-GL_Az2A8Mv-1H8tS3oln_NPh6k3zo,180
+vellum/types/workflow_execution_usage_calculation_error_code_enum.py,sha256=HMqRue9gC5NRgbqt_FhANKGeNz8Vgu9fjZpEvRTek9o,190
+vellum/types/workflow_execution_usage_result.py,sha256=SrVrcv5xngwbS-6eCWU4XJ9QyyUwGJ1mPfgHPOhNqbs,169
 vellum/types/workflow_execution_view_online_eval_metric_result.py,sha256=dLnk3CfQOAeYIO5kiR0U8SY4JcqFWvVYwkDL-LkA5Co,187
 vellum/types/workflow_execution_workflow_result_event.py,sha256=3bNxtChEfqny5eEazFcGmqQpmC8283Q0J2hxLje-uks,178
 vellum/types/workflow_expand_meta_request.py,sha256=Ahb7gjZekJ5qI0HGHLCbn3hCpkX08EnzeXEH_3ivB4E,166
@@ -1551,9 +1556,9 @@ vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=rgcjc3gaCEX9u
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=kUqwcRMMxjTHALbwGUXCJT_aJBrHS1bkg49oL8R0JO8,4337
 vellum/workflows/nodes/core/map_node/__init__.py,sha256=MXpZYmGfhsMJHqqlpd64WiJRtbAtAMQz-_3fCU_cLV0,56
-vellum/workflows/nodes/core/map_node/node.py,sha256=bmI48fv-UAmS14ZVV4VWrIUIYFytYGIVM6Gm7yFz8pM,9288
+vellum/workflows/nodes/core/map_node/node.py,sha256=rbF7fLAU0vUDEpgtWqeQTZFlhWOhJw38tgxWJ6exud8,9313
 vellum/workflows/nodes/core/map_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=A_M4WfdThNO5FdB7nyCyyVQBEeJWQaxmIDvvSrtO96A,5324
+vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=f3lSPYAU1vJUCLCujNOo0EAeBbOM9hnY5A1Wy58korc,6905
 vellum/workflows/nodes/core/retry_node/__init__.py,sha256=lN2bIy5a3Uzhs_FYCrooADyYU6ZGShtvLKFWpelwPvo,60
 vellum/workflows/nodes/core/retry_node/node.py,sha256=abtGvinLfi1tKqYIsWQKZtBUisF2Qw2yT1YoPw9cVk4,5297
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1668,7 +1673,7 @@ vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=ZXDmVafs6sExcbx1azrZjEGQsmuY68mSRWfI7t2PT4c,22330
 vellum/workflows/state/context.py,sha256=KOAI1wEGn8dGmhmAemJaf4SZbitP3jpIBcwKfznQaRE,3076
-vellum/workflows/state/encoder.py,sha256=TnOQojc5lTQ83g9QbpA4UCqShJvutmTMxbpKt-9gNe4,1911
+vellum/workflows/state/encoder.py,sha256=z7Mk6jQC-92wCj6XTK7VEnJ8px_lU8qy0BINqwGDN4I,2063
 vellum/workflows/state/store.py,sha256=uVe-oN73KwGV6M6YLhwZMMUQhzTQomsVfVnb8V91gVo,1147
 vellum/workflows/state/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/state/tests/test_state.py,sha256=YOiC9qZAzkdiqb7nRarNWeDwxo7xHv3y3czlHl81ezg,6741
@@ -1696,13 +1701,13 @@ vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrg
 vellum/workflows/utils/vellum_variables.py,sha256=UiGlUh0a8vel2FbW3w-xbHxSv_jNutkDdqMVtP_b42A,3385
 vellum/workflows/vellum_client.py,sha256=xkfoucodxNK5JR2-lbRqZx3xzDgExWkP6kySrpi_Ubc,1079
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=9dGZzoXbVVtw19pVhmawIA1wd1iLQttAKypuVFWb0fU,23793
+vellum/workflows/workflows/base.py,sha256=V60RZat8mG0XmMuIjprkHnacD_MpUdxGcN9t4TaP_Pg,24044
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=8P5YIsNMO78_CR1NNK6wkEdkMB4b3Q_Ni1qxh78OnHo,20481
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.49.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.49.dist-info/METADATA,sha256=UnFisKY5VZ2o5md6oV2OU-gTx6Y24oQd4u5Bv_rJfag,5484
-vellum_ai-0.14.49.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.49.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.49.dist-info/RECORD,,
+vellum_ai-0.14.50.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.50.dist-info/METADATA,sha256=E3j3kzjmM-9HAa1xAKCgCf5JsoBVzbm7vadnxywpahY,5484
+vellum_ai-0.14.50.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.50.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.50.dist-info/RECORD,,

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -44,18 +44,40 @@ if TYPE_CHECKING:
 _NodeDisplayAttrType = TypeVar("_NodeDisplayAttrType")
 
 
+def _get_node_input_ids_by_ref(node_class: Type[BaseNode], path: str, inst: Any):
+    if isinstance(inst, dict):
+        node_input_ids_by_name: Dict[str, UUID] = {}
+        for key, value in inst.items():
+            node_input_ids_by_name.update(_get_node_input_ids_by_ref(node_class, f"{path}.{key}", value))
+        return node_input_ids_by_name
+
+    return {path: uuid4_from_hash(f"{node_class.__id__}|{path}")}
+
+
 class BaseNodeDisplayMeta(type):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         cls = cast(Type["BaseNodeDisplay"], super().__new__(mcs, name, bases, dct))
+        # This cast shouldn't be necessary, but it's a workaround for a mypy bug
+        node_class = cast(Type[BaseNode], cls.infer_node_class() if name != "BaseNodeDisplay" else BaseNode)
 
         if not dct.get("output_display"):
-            node_class = cls.infer_node_class()
             cls.output_display = {
                 ref: NodeOutputDisplay(id=node_class.__output_ids__[ref.name], name=ref.name)
                 for ref in node_class.Outputs
                 if ref.name in node_class.__output_ids__
             }
 
+        if not dct.get("node_input_ids_by_name"):
+            node_input_ids_by_name: Dict[str, UUID] = {}
+            for ref in node_class:
+                if ref not in cls.__serializable_inputs__:
+                    continue
+
+                node_input_ids_by_name.update(_get_node_input_ids_by_ref(node_class, ref.name, ref.instance))
+
+            if node_input_ids_by_name:
+                cls.node_input_ids_by_name = node_input_ids_by_name
+
         return cls.__annotate_node__()
 
     def __annotate_node__(cls):

vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -1,9 +1,7 @@
 import types
-from uuid import UUID
-from typing import TYPE_CHECKING, Any, Dict, Generic, Type, TypeVar
+from typing import TYPE_CHECKING, Generic, Type, TypeVar
 
 from vellum.workflows.types.generics import NodeType
-from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.registry import get_from_node_display_registry
 
 if TYPE_CHECKING:
@@ -22,30 +20,9 @@ def get_node_display_class(node_class: Type[NodeType]) -> Type["BaseNodeDisplay"
     # `base_node_display_class` is always a Generic class, so it's safe to index into it
     NodeDisplayBaseClass = base_node_display_class[_NodeClassType]  # type: ignore[index]
 
-    def _get_node_input_ids_by_ref(path: str, inst: Any):
-        if isinstance(inst, dict):
-            node_input_ids_by_name: Dict[str, UUID] = {}
-            for key, value in inst.items():
-                node_input_ids_by_name.update(_get_node_input_ids_by_ref(f"{path}.{key}", value))
-            return node_input_ids_by_name
-
-        return {path: uuid4_from_hash(f"{node_class.__id__}|{path}")}
-
-    def exec_body(ns: Dict):
-        node_input_ids_by_name: Dict[str, UUID] = {}
-        for ref in node_class:
-            if ref not in base_node_display_class.__serializable_inputs__:
-                continue
-
-            node_input_ids_by_name.update(_get_node_input_ids_by_ref(ref.name, ref.instance))
-
-        if node_input_ids_by_name:
-            ns["node_input_ids_by_name"] = node_input_ids_by_name
-
     NodeDisplayClass = types.new_class(
         f"{node_class.__name__}Display",
         bases=(NodeDisplayBaseClass, Generic[_NodeClassType]),
-        exec_body=exec_body,
     )
 
     return NodeDisplayClass

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

@@ -0,0 +1,177 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node.workflow import BasicToolCallingNodeWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWorkflow)
+
+    serialized_workflow: dict = workflow_display.serialize()
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 0
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "8e7c0147-930d-4b7f-b6b1-6d79641cd3eb", "key": "text", "type": "STRING"},
+            {"id": "01a07e6d-7269-4f45-8b44-ef0227a2e88d", "key": "chat_history", "type": "CHAT_HISTORY"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    assert tool_calling_node == {
+        "id": "21f29cac-da87-495f-bba1-093d423f4e46",
+        "label": "GetCurrentWeatherNode",
+        "type": "GENERIC",
+        "display_data": {
+            "position": {"x": 0.0, "y": 0.0},
+            "comment": {"value": "\n    A tool calling node that calls the get_current_weather function.\n    "},
+        },
+        "base": {
+            "name": "ToolCallingNode",
+            "module": ["vellum", "workflows", "nodes", "experimental", "tool_calling_node", "node"],
+        },
+        "definition": {
+            "name": "GetCurrentWeatherNode",
+            "module": ["tests", "workflows", "basic_tool_calling_node", "workflow"],
+        },
+        "trigger": {"id": "2414743b-b1dd-4552-8abf-9b7481df9762", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "ports": [{"id": "3cd6d78c-9dad-42aa-ad38-31f67057c379", "name": "default", "type": "DEFAULT"}],
+        "adornments": None,
+        "attributes": [
+            {
+                "id": "44420e39-966f-4c59-bdf8-6365a61c5d2a",
+                "name": "ml_model",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "gpt-4o-mini"}},
+            },
+            {
+                "id": "669cfb4b-8c25-460e-8952-b63d91302cbc",
+                "name": "blocks",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": [
+                            {
+                                "block_type": "CHAT_MESSAGE",
+                                "state": None,
+                                "cache_config": None,
+                                "chat_role": "SYSTEM",
+                                "chat_source": None,
+                                "chat_message_unterminated": None,
+                                "blocks": [
+                                    {
+                                        "block_type": "RICH_TEXT",
+                                        "state": None,
+                                        "cache_config": None,
+                                        "blocks": [
+                                            {
+                                                "block_type": "PLAIN_TEXT",
+                                                "state": None,
+                                                "cache_config": None,
+                                                "text": "You are a weather expert",
+                                            }
+                                        ],
+                                    }
+                                ],
+                            },
+                            {
+                                "block_type": "CHAT_MESSAGE",
+                                "state": None,
+                                "cache_config": None,
+                                "chat_role": "USER",
+                                "chat_source": None,
+                                "chat_message_unterminated": None,
+                                "blocks": [
+                                    {
+                                        "block_type": "RICH_TEXT",
+                                        "state": None,
+                                        "cache_config": None,
+                                        "blocks": [
+                                            {
+                                                "block_type": "VARIABLE",
+                                                "state": None,
+                                                "cache_config": None,
+                                                "input_variable": "question",
+                                            }
+                                        ],
+                                    }
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+            {
+                "id": "78324739-ff89-47a5-902b-10da0cb95c6d",
+                "name": "functions",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": [
+                            {
+                                "state": None,
+                                "cache_config": None,
+                                "name": "get_current_weather",
+                                "description": None,
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {"location": {"type": "string"}, "unit": {"type": "string"}},
+                                    "required": ["location", "unit"],
+                                },
+                                "forced": None,
+                                "strict": None,
+                            }
+                        ],
+                    },
+                },
+            },
+            {
+                "id": "0f6dc102-3460-4963-91fa-7ba85d65ef7a",
+                "name": "prompt_inputs",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {"type": "JSON", "value": {"question": "What's the weather like in San Francisco?"}},
+                },
+            },
+            {
+                "id": "5c041b7d-732c-4773-a93a-32211f2af0b3",
+                "name": "max_tool_calls",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 1.0}},
+            },
+        ],
+        "outputs": [
+            {
+                "id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c",
+                "name": "text",
+                "type": "STRING",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": ""}},
+            },
+            {
+                "id": "4674f1d9-e3af-411f-8a55-40a3a3ab5394",
+                "name": "chat_history",
+                "type": "CHAT_HISTORY",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+            },
+        ],
+    }

vellum_ee/workflows/display/utils/expressions.py

@@ -253,7 +253,7 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
                 "type": "CONSTANT_VALUE",
                 "value": {
                     "type": "JSON",
-                    "items": constant_values,
+                    "value": constant_values,
                 },
             }
         else:

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -153,20 +153,8 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             "definition": None,
         }
 
-        # Add all the nodes in the workflow
-        for node in self._workflow.get_nodes():
-            node_display = self.display_context.node_displays[node]
-
-            try:
-                serialized_node = node_display.serialize(self.display_context)
-            except NotImplementedError as e:
-                self.add_error(e)
-                continue
-
-            serialized_nodes[node_display.node_id] = serialized_node
-
-        # Add all unused nodes in the workflow
-        for node in self._workflow.get_unused_nodes():
+        # Add all the nodes in the workflows
+        for node in self._workflow.get_all_nodes():
             node_display = self.display_context.node_displays[node]
 
             try:
@@ -417,16 +405,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
         port_displays: PortDisplays = {}
 
-        for node in self._workflow.get_nodes():
-            self._enrich_node_displays(
-                node=node,
-                node_displays=node_displays,
-                global_node_displays=global_node_displays,
-                global_node_output_displays=global_node_output_displays,
-                port_displays=port_displays,
-            )
-
-        for node in self._workflow.get_unused_nodes():
+        for node in self._workflow.get_all_nodes():
             self._enrich_node_displays(
                 node=node,
                 node_displays=node_displays,

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

@@ -466,7 +466,7 @@ def test_serialize_workflow__array_values():
     assert "value" in array_output
     assert array_output["value"] == {
         "type": "CONSTANT_VALUE",
-        "value": {"type": "JSON", "items": ["item1", "item2", "item3"]},
+        "value": {"type": "JSON", "value": ["item1", "item2", "item3"]},
     }
 
     nested_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "nested_array_value"]
@@ -477,7 +477,7 @@ def test_serialize_workflow__array_values():
     assert "value" in nested_array_output
     assert nested_array_output["value"] == {
         "type": "CONSTANT_VALUE",
-        "value": {"type": "JSON", "items": [["item1", "item2", "item3"], ["item4", "item5", "item6"]]},
+        "value": {"type": "JSON", "value": [["item1", "item2", "item3"], ["item4", "item5", "item6"]]},
     }
 
     mixed_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_array_value"]
@@ -488,7 +488,7 @@ def test_serialize_workflow__array_values():
     assert "value" in mixed_array_output
     assert mixed_array_output["value"] == {
         "type": "CONSTANT_VALUE",
-        "value": {"type": "JSON", "items": [["item1"], "item2", "item3"]},
+        "value": {"type": "JSON", "value": [["item1"], "item2", "item3"]},
     }