vellum-ai 1.6.4__py3-none-any.whl → 1.7.1__py3-none-any.whl

vellum_ee/assets/node-definitions.json

@@ -542,6 +542,208 @@
         }
       ]
     },
+    {
+      "id": "3ae7366b-28ce-4d6b-8ec1-c6366b1e1a8b",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute a Workflow Deployment.\n\n    subworkflow_inputs: EntityInputsInterface - The inputs for the Subworkflow\n    deployment: Union[UUID, str] - Either the Workflow Deployment's UUID or its name.\n    release_tag: str = LATEST_RELEASE_TAG - The release tag to use for the Workflow Execution\n    external_id: Optional[str] = OMIT - Optionally include a unique identifier for tracking purposes.\n        Must be unique within a given Workflow Deployment.\n    expand_meta: Optional[WorkflowExpandMetaRequest] = OMIT - Expandable execution fields to include in the response\n    metadata: Optional[Dict[str, Optional[Any]]] = OMIT - The metadata to use for the Workflow Execution\n    request_options: Optional[RequestOptions] = None - The request options to use for the Workflow Execution\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "SubworkflowDeploymentNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "subworkflow_deployment_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "a6eecf28-5c21-4406-80bb-917c6de84050",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "8fc8d25b-c9b5-4db7-a632-d4eb1eb3e9fd",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
+    {
+      "id": "d2f9a8ec-3023-46bb-aca3-dd67ffb61e18",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute a Prompt Deployment and surface a string output and json output if applicable for convenience.\n\n    prompt_inputs: EntityInputsInterface - The inputs for the Prompt\n    deployment: Union[UUID, str] - Either the Prompt Deployment's UUID or its name.\n    release_tag: str - The release tag to use for the Prompt Execution\n    external_id: Optional[str] - Optionally include a unique identifier for tracking purposes.\n        Must be unique within a given Prompt Deployment.\n    expand_meta: Optional[PromptDeploymentExpandMetaRequest] - Expandable execution fields to include in the response\n    raw_overrides: Optional[RawPromptExecutionOverridesRequest] - The raw overrides to use for the Prompt Execution\n    expand_raw: Optional[Sequence[str]] - Expandable raw fields to include in the response\n    metadata: Optional[Dict[str, Optional[Any]]] - The metadata to use for the Prompt Execution\n    request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BasePromptDeploymentNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "bases",
+          "prompt_deployment_node"
+        ]
+      },
+      "definition": {
+        "name": "PromptDeploymentNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "prompt_deployment_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "7d209a9c-14a5-4b74-949c-d3e681750049",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "d51b7c72-3e1f-400c-ba1c-1125b1047d9a",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ],
+      "outputs": [
+        {
+          "id": "09c6ba90-4d69-4848-aa0b-74bdfcdd5a97",
+          "name": "json",
+          "type": "JSON",
+          "value": null
+        },
+        {
+          "id": "5ef5e3c6-1578-46da-89f6-6da3dd01fb5f",
+          "name": "text",
+          "type": "STRING",
+          "value": null
+        },
+        {
+          "id": "48513658-a72b-4db4-ad49-75a48a6cd084",
+          "name": "results",
+          "type": "ARRAY",
+          "value": null
+        }
+      ]
+    },
+    {
+      "id": "0ac6bdba-dbae-4ce5-b815-3d670aae0572",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to perform a hybrid search against a Document Index in Vellum.\n\n    document_index: Union[UUID, str] - Either the UUID or name of the Vellum Document Index that you'd like to search\n        against\n    query: str - The query to search for\n    options: Optional[SearchRequestOptionsRequest] = None - Runtime configuration for the search\n    request_options: Optional[RequestOptions] = None - The request options to use for the search\n    chunk_separator: str = \"\n\n#####\n\n\" - The separator to use when joining the text of each search result\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseSearchNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "bases",
+          "search_node"
+        ]
+      },
+      "definition": {
+        "name": "SearchNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "search_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "37e64cf0-e604-4045-b8a0-d17e68c037e1",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "8dea61c3-107c-4f17-bcba-dbbdc1185360",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
+    {
+      "id": "ee9b5234-247b-49d1-bed4-490312f18838",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "Used to render a Jinja template.\n\n    Useful for lightweight data transformations and complex string templating.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "TemplatingNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "core",
+          "templating_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "005e1cd2-5452-4e1f-be6a-ac9fe3c02b9b",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "8f4460f0-717b-4972-a6f4-ac164e5e204e",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
     {
       "id": "035842e0-34ed-43af-97de-a706e40912ae",
       "label": "Tool Calling Node",
@@ -853,22 +1055,5 @@
       ]
     }
   ],
-  "errors": [
-    {
-      "node": "SubworkflowDeploymentNode",
-      "error": "ApiError: headers: {'server': 'gunicorn', 'date': 'Wed, 24 Sep 2025 04:58:53 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '58', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Authentication credentials were not provided.'}"
-    },
-    {
-      "node": "PromptDeploymentNode",
-      "error": "ApiError: headers: {'server': 'gunicorn', 'date': 'Wed, 24 Sep 2025 04:58:53 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '58', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Authentication credentials were not provided.'}"
-    },
-    {
-      "node": "SearchNode",
-      "error": "ValueError: Expected NodeReference query to have an instance"
-    },
-    {
-      "node": "TemplatingNode",
-      "error": "KeyError: TemplatingNode.Outputs.result"
-    }
-  ]
+  "errors": []
 }

vellum_ee/workflows/display/exceptions.py

@@ -1,7 +1,3 @@
-class NodeValidationError(Exception):
-    """Exception raised when a node fails validation during workflow display serialization."""
+from vellum_ee.workflows.display.utils.exceptions import NodeValidationError
 
-    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}")
+__all__ = ["NodeValidationError"]

vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -6,11 +6,11 @@ from typing import ClassVar, Generic, Optional, TypeVar
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
-from vellum_ee.workflows.display.exceptions import NodeValidationError
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.exceptions import NodeValidationError
 from vellum_ee.workflows.display.utils.expressions import virtual_open
 
 _CodeExecutionNodeType = TypeVar("_CodeExecutionNodeType", bound=CodeExecutionNode)

vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -8,11 +8,11 @@ from vellum.workflows.nodes import InlineSubworkflowNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.workflows.base import BaseWorkflow
-from vellum_ee.workflows.display.exceptions import NodeValidationError
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.exceptions import NodeValidationError
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import NodeInput
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display

vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -3,6 +3,7 @@ from typing import Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable.prompt_deployment_node import PromptDeploymentNode
 from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -43,9 +44,15 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
         array_display = self.output_display[node.Outputs.results]
         json_display = self.output_display[node.Outputs.json]
 
-        deployment = display_context.client.deployments.retrieve(
-            id=str(raise_if_descriptor(node.deployment)),
-        )
+        deployment_descriptor_id = str(raise_if_descriptor(node.deployment))
+        try:
+            deployment = display_context.client.deployments.retrieve(
+                id=deployment_descriptor_id,
+            )
+            deployment_id = str(deployment.id)
+        except Exception as e:
+            display_context.add_error(e)
+            deployment_id = str(uuid4_from_hash(deployment_descriptor_id))
         ml_model_fallbacks = raise_if_descriptor(node.ml_model_fallbacks)
 
         return {
@@ -60,7 +67,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
                 "target_handle_id": str(self.get_target_handle_id()),
                 "variant": "DEPLOYMENT",
-                "prompt_deployment_id": str(deployment.id),
+                "prompt_deployment_id": deployment_id,
                 "release_tag": raise_if_descriptor(node.release_tag),
                 "ml_model_fallbacks": list(ml_model_fallbacks) if ml_model_fallbacks else None,
             },

vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -48,8 +48,8 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
         node_id = self.node_id
         node_inputs = self._generate_search_node_inputs(node_id, node, display_context)
 
-        results_output_display = display_context.global_node_output_displays[node.Outputs.results]
-        text_output_display = display_context.global_node_output_displays[node.Outputs.text]
+        results_output_display = self.get_node_output_display(node.Outputs.results)
+        text_output_display = self.get_node_output_display(node.Outputs.text)
 
         return {
             "id": str(node_id),
@@ -111,8 +111,8 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
         limit = raw_limit if raw_limit is not None else options.limit if options is not None else None
 
         node_input_names_and_values = [
-            ("query", node.query),
-            ("document_index_id", node.document_index),
+            ("query", raise_if_descriptor(node.query)),
+            ("document_index_id", raise_if_descriptor(node.document_index)),
             ("weights", weights.dict() if weights else None),
             ("limit", limit),
             ("separator", raise_if_descriptor(node.chunk_separator)),

vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py

@@ -4,6 +4,7 @@ from typing import Generic, Optional, TypeVar
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import SubworkflowDeploymentNode
 from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -44,9 +45,15 @@ class BaseSubworkflowDeploymentNodeDisplay(
             for variable_name, variable_value in input_items
         ]
 
-        deployment = display_context.client.workflow_deployments.retrieve(
-            id=str(raise_if_descriptor(node.deployment)),
-        )
+        deployment_descriptor_id = str(raise_if_descriptor(node.deployment))
+        try:
+            deployment = display_context.client.workflow_deployments.retrieve(
+                id=deployment_descriptor_id,
+            )
+            deployment_id = str(deployment.id)
+        except Exception as e:
+            display_context.add_error(e)
+            deployment_id = str(uuid4_from_hash(deployment_descriptor_id))
 
         return {
             "id": str(node_id),
@@ -58,7 +65,7 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
                 "target_handle_id": str(self.get_target_handle_id()),
                 "variant": "DEPLOYMENT",
-                "workflow_deployment_id": str(deployment.id),
+                "workflow_deployment_id": deployment_id,
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             **self.serialize_generic_fields(display_context),

vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -50,7 +50,7 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
         # Misc type ignore is due to `node.Outputs` being generic
         # https://app.shortcut.com/vellum/story/4784
         output_descriptor = node.Outputs.result  # type: ignore [misc]
-        output_display = display_context.global_node_output_displays[output_descriptor]
+        output_display = self.get_node_output_display(output_descriptor)
         inferred_output_type = primitive_type_to_vellum_variable_type(output_descriptor)
 
         return {

vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py

@@ -6,8 +6,8 @@ from vellum.client.core.api_error import ApiError
 from vellum.workflows.nodes.displayable.code_execution_node.node import CodeExecutionNode
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.workflows.base import BaseWorkflow
-from vellum_ee.workflows.display.exceptions import NodeValidationError
 from vellum_ee.workflows.display.nodes.vellum.code_execution_node import BaseCodeExecutionNodeDisplay
+from vellum_ee.workflows.display.utils.exceptions import NodeValidationError
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -353,3 +353,33 @@ def test_serialize_node__adornment_order_matches_decorator_order():
     assert len(adornments) == 2
     assert adornments[0]["label"] == "Try Node"
     assert adornments[1]["label"] == "Retry Node"
+
+
+def test_serialize_workflow__retry_node_edges():
+    """
+    Tests that both retry-adorned nodes are correctly serialized in the nodes array.
+    """
+
+    @RetryNode.wrap(max_attempts=3, delay=60)
+    class FirstNode(BaseNode):
+        class Outputs(BaseOutputs):
+            value: str
+
+    @RetryNode.wrap(max_attempts=5, delay=120)
+    class SecondNode(BaseNode):
+        class Outputs(BaseOutputs):
+            result: str
+
+    class MyWorkflow(BaseWorkflow):
+        graph = FirstNode >> SecondNode
+
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    exec_config = cast(Dict[str, Any], workflow_display.serialize())
+
+    assert isinstance(exec_config["workflow_raw_data"], dict)
+    assert isinstance(exec_config["workflow_raw_data"]["nodes"], list)
+
+    nodes = cast(List[Dict[str, Any]], exec_config["workflow_raw_data"]["nodes"])
+
+    generic_nodes = [node for node in nodes if node["type"] == "GENERIC"]
+    assert len(generic_nodes) == 2

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

@@ -56,7 +56,7 @@ from vellum.workflows.types.core import JsonArray, JsonObject
 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.display.utils.exceptions import InvalidInputReferenceError, UnsupportedSerializationException
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileLoader
 
 if TYPE_CHECKING:
@@ -275,16 +275,24 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         return serialize_value(executable_id, display_context, child_descriptor)
 
     if isinstance(value, WorkflowInputReference):
-        try:
-            workflow_input_display = display_context.global_workflow_input_displays[value]
-        except KeyError:
-            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 '{workflow_class_name}' "
-                f"without parameterizing this Workflow with this Inputs definition. Update your Workflow "
-                f"definition to '{workflow_class_name}(BaseWorkflow[{inputs_class_name}, BaseState])'."
-            )
+        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",
             "input_variable_id": str(workflow_input_display.id),

vellum_ee/workflows/display/utils/vellum.py

@@ -15,7 +15,7 @@ from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
-from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.display.utils.exceptions import InvalidInputReferenceError, UnsupportedSerializationException
 from vellum_ee.workflows.display.utils.expressions import get_child_descriptor
 
 if TYPE_CHECKING:
@@ -124,6 +124,12 @@ def create_node_input_value_pointer_rule(
         child_descriptor = get_child_descriptor(value, display_context)
         return create_node_input_value_pointer_rule(child_descriptor, display_context)
     if isinstance(value, WorkflowInputReference):
+        if value not in display_context.global_workflow_input_displays:
+            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 InputVariablePointer(data=InputVariableData(input_variable_id=str(workflow_input_display.id)))
     if isinstance(value, VellumSecretReference):

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -39,7 +39,6 @@ from vellum_ee.workflows.display.base import (
     WorkflowOutputDisplay,
 )
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
-from vellum_ee.workflows.display.exceptions import NodeValidationError
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
@@ -57,6 +56,7 @@ from vellum_ee.workflows.display.types import (
     WorkflowOutputDisplays,
 )
 from vellum_ee.workflows.display.utils.auto_layout import auto_layout_nodes
+from vellum_ee.workflows.display.utils.exceptions import UserFacingException
 from vellum_ee.workflows.display.utils.expressions import serialize_value
 from vellum_ee.workflows.display.utils.registry import register_workflow_display_class
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
@@ -203,12 +203,20 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                     self.display_context.add_validation_error(validation_error)
 
                 serialized_node = node_display.serialize(self.display_context)
-            except (NotImplementedError, NodeValidationError) as e:
+            except (NotImplementedError, UserFacingException) as e:
                 self.display_context.add_error(e)
                 self.display_context.add_invalid_node(node)
                 continue
 
-            serialized_nodes[node_display.node_id] = serialized_node
+            # Use wrapped node's ID as dict key for adornment wrappers to prevent overwrites
+            wrapped_node = get_wrapped_node(node)
+            if wrapped_node:
+                wrapped_node_display = self.display_context.node_displays[wrapped_node]
+                dict_key = wrapped_node_display.node_id
+            else:
+                dict_key = node_display.node_id
+
+            serialized_nodes[dict_key] = serialized_node
 
         synthetic_output_edges: JsonArray = []
         output_variables: JsonArray = []

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

@@ -14,7 +14,7 @@ from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
-from vellum_ee.workflows.display.nodes import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.retry_node import BaseRetryNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.try_node import BaseTryNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -997,3 +997,56 @@ def test_serialize_workflow__with_complete_node_failure_prunes_edges():
     node_types = [node["type"] for node in data["workflow_raw_data"]["nodes"]]
     assert "ENTRYPOINT" in node_types
     assert "GENERIC" in node_types  # This is the WorkingNode that should still be serialized
+
+
+def test_serialize_workflow__node_with_invalid_input_reference():
+    """Test that serialization captures errors when nodes reference a non-existent input attribute."""
+
+    # GIVEN a workflow with defined inputs
+    class Inputs(BaseInputs):
+        valid_input: str
+
+    # AND a templating node that references a non-existent input
+    class MyTemplatingNode(TemplatingNode):
+        class Outputs(TemplatingNode.Outputs):
+            pass
+
+        template = "valid: {{ valid_input }}, invalid: {{ invalid_ref }}"
+        inputs = {
+            "valid_input": Inputs.valid_input,
+            "invalid_ref": Inputs.invalid_ref,
+        }
+
+    # AND a base node that also references the non-existent input
+    class MyBaseNode(BaseNode):
+        invalid_ref = Inputs.invalid_ref
+
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+        def run(self) -> BaseNode.Outputs:
+            return self.Outputs(result="done")
+
+    class MyBaseNodeDisplay(BaseNodeDisplay[MyBaseNode]):
+        __serializable_inputs__ = {MyBaseNode.invalid_ref}
+
+    # WHEN we create a workflow with both nodes and serialize with dry_run=True
+    class MyWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = MyTemplatingNode >> MyBaseNode
+
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow, dry_run=True)
+    serialized = workflow_display.serialize()
+
+    # THEN the serialization should succeed without raising an exception
+    assert serialized is not None
+    assert "workflow_raw_data" in serialized
+
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) > 0
+
+    # AND the error messages should reference the missing attribute
+    error_messages = [str(e) for e in errors]
+    assert any("invalid_ref" in msg for msg in error_messages)
+
+    invalid_nodes = list(workflow_display.display_context.invalid_nodes)
+    assert len(invalid_nodes) >= 2