vellum-ai 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

vellum_ee/assets/node-definitions.json

@@ -1,5 +1,110 @@
 {
   "nodes": [
+    {
+      "id": "55e74c90-9901-42fd-92c3-2dd0c5fd4876",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute an API call. This node exists to be backwards compatible with Vellum's API Node, and for most cases,\n    you should extend from `BaseAPINode` directly.\n\n    url: str - The URL to send the request to.\n    method: APIRequestMethod - The HTTP method to use for the request.\n    data: Optional[str] - The data to send in the request body.\n    json: Optional[\"JsonObject\"] - The JSON data to send in the request body.\n    headers: Optional[Dict[str, Union[str, VellumSecret]]] - The headers to send in the request.\n\n    authorization_type: Optional[AuthorizationType] = None - The type of authorization to use for the API call.\n    api_key_header_key: Optional[str] = None - The header key to use for the API key authorization.\n    bearer_token_value: Optional[Union[str, VellumSecretReference]] = None - The bearer token value to use\n    for the bearer token authorization.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseAPINode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "bases",
+          "api_node",
+          "node"
+        ]
+      },
+      "definition": {
+        "name": "APINode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "api_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "c2aa7c83-7eba-4996-acb4-85cd4f5bbf58",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "f165a94f-33f7-4c09-8896-9e683a39e11c",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ],
+      "attributes": [
+        {
+          "id": "aacb36f1-c980-460d-8002-43bb57128e05",
+          "name": "timeout",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        }
+      ]
+    },
+    {
+      "id": "43b3514f-3490-47d6-9b78-bbc4736f0159",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute an arbitrary script. This node exists to be backwards compatible with\n    Vellum's Code Execution Node, and for most cases, you should extend from `BaseNode` directly.\n\n    filepath: str - The path to the script to execute.\n    code_inputs: EntityInputsInterface - The inputs for the custom script.\n    runtime: CodeExecutionRuntime = \"PYTHON_3_12\" - The runtime to use for the custom script.\n    packages: Optional[Sequence[CodeExecutionPackage]] = None - The packages to use for the custom script.\n    request_options: Optional[RequestOptions] = None - The request options to use for the custom script.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "CodeExecutionNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "code_execution_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "fb1b8b44-5e7a-481b-a163-96e7e08219d5",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "e66138d5-e50d-40d8-bc27-00545ce5e283",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
     {
       "id": "5d3c60ce-7acf-4d8b-a68d-65cc0b561ac5",
       "display_data": {
@@ -78,6 +183,320 @@
       },
       "ports": []
     },
+    {
+      "id": "55d0f8e9-acbd-4d33-85ba-c7527348f62a",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute a Prompt defined inline.\n\n    prompt_inputs: EntityInputsInterface - The inputs for the Prompt\n    ml_model: str - Either the ML Model's UUID or its name.\n    blocks: List[PromptBlock] - The blocks that make up the Prompt\n    functions: Optional[List[FunctionDefinition]] - The functions to include in the Prompt\n    parameters: PromptParameters - The parameters for the Prompt\n    expand_meta: Optional[AdHocExpandMeta] - Expandable execution fields to include in the response\n    request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseInlinePromptNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "bases",
+          "inline_prompt_node",
+          "node"
+        ]
+      },
+      "definition": {
+        "name": "InlinePromptNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "inline_prompt_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "d14ff235-9e0a-4496-9fd4-ae4cf39fa518",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "66943bf3-3c32-42da-9d4f-faab541f4285",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ],
+      "outputs": [
+        {
+          "id": "af7d71b0-227c-4957-8234-d1dc76e62554",
+          "name": "json",
+          "type": "JSON",
+          "value": null
+        },
+        {
+          "id": "b283959e-b719-49d2-ab9a-15c804ab52e8",
+          "name": "text",
+          "type": "STRING",
+          "value": null
+        },
+        {
+          "id": "73c02172-2bd1-482d-b7fe-acc67135f7d0",
+          "name": "results",
+          "type": "ARRAY",
+          "value": null
+        }
+      ],
+      "attributes": [
+        {
+          "id": "e2455e77-82ad-460f-8735-10d427d4d448",
+          "name": "functions",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        },
+        {
+          "id": "bd29a2cd-4965-4741-a3c2-9d0c753efdd9",
+          "name": "parameters",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": {
+                "stop": [],
+                "temperature": 0.0,
+                "max_tokens": 4096.0,
+                "top_p": 1.0,
+                "top_k": 0.0,
+                "frequency_penalty": 0.0,
+                "presence_penalty": 0.0,
+                "logit_bias": null,
+                "custom_parameters": null
+              }
+            }
+          }
+        },
+        {
+          "id": "76f813d6-0025-4733-9d03-848c49c93d66",
+          "name": "ml_model",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        },
+        {
+          "id": "1216ae32-e051-4c48-bd7d-69f2a4527f12",
+          "name": "blocks",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        },
+        {
+          "id": "b66dc0b6-9e4d-4bbb-9b3c-b85e14071de0",
+          "name": "prompt_inputs",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        }
+      ]
+    },
+    {
+      "id": "9d62e15c-a640-4a65-b52c-ce0cbaa23a71",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute a Subworkflow defined inline.\n\n    subworkflow: Type[\"BaseWorkflow[InputsType, InnerStateType]\"] - The Subworkflow to execute\n    subworkflow_inputs: ClassVar[EntityInputsInterface] = {}\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "InlineSubworkflowNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "core",
+          "inline_subworkflow_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "d7c92c2f-d761-43e7-a7e6-34fd74b3b8b3",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "bb1e4a4f-60e7-4519-b127-80183008a3f7",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
+    {
+      "id": "2dded52f-a449-48fd-b58f-f59801c24bae",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to execute a Metric Definition and surface a float output representing the score.\n\n    metric_definition: Union[UUID, str] - Either the Metric Definition's UUID or its name.\n    metric_inputs: EntityInputsInterface - The inputs for the Metric\n    release_tag: str - The release tag to use for the Metric\n    request_options: Optional[RequestOptions] - The request options to use for the Metric\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "GuardrailNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "guardrail_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "1560db25-a416-4ce6-b175-d7bdfbdb27d8",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "94bc1403-af9f-4539-8208-1bbafbf09564",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
+    {
+      "id": "527a10bc-30b2-4e36-91d6-91c8e865bac8",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to map over a list of items and execute a Subworkflow on each iteration.\n\n    items: List[MapNodeItemType] - The items to map over\n    max_concurrency: Optional[int] = None - The maximum number of concurrent subworkflow executions\n    subworkflow: Type[\"BaseWorkflow\"] - The Subworkflow to execute\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseAdornmentNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base_adornment_node"
+        ]
+      },
+      "definition": {
+        "name": "MapNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "core",
+          "map_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "3a702aac-7b68-47d3-92e1-264883e9532c",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "0ae85239-a159-48af-b39c-2484eac901df",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
+    {
+      "id": "7426f273-a43d-4448-a2d2-76d0ee0d069c",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to merge the control flow of multiple nodes into a single node. This node exists to be backwards compatible\n    with Vellum's Merge Node, and for most cases, you should extend from `BaseNode.Trigger` directly.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "MergeNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "merge_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "3a91ba25-0dd0-4bc8-9f6d-c54ea4dccf64",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "50515fe3-4be8-43b9-8fc5-d52c1250115e",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
     {
       "id": "16b8d82d-458d-48d9-b57e-a447b19f311a",
       "display_data": {
@@ -435,49 +854,21 @@
     }
   ],
   "errors": [
-    {
-      "node": "APINode",
-      "error": "APINode.Outputs.text"
-    },
-    {
-      "node": "CodeExecutionNode",
-      "error": "vellum.workflows.nodes.displayable.code_execution_node.node.CodeExecutionNode.Ports.default"
-    },
-    {
-      "node": "InlinePromptNode",
-      "error": "vellum.workflows.nodes.displayable.inline_prompt_node.node.InlinePromptNode.Ports.default"
-    },
-    {
-      "node": "InlineSubworkflowNode",
-      "error": "'NoneType' object has no attribute 'get_inputs_class'"
-    },
-    {
-      "node": "GuardrailNode",
-      "error": "vellum.workflows.nodes.displayable.guardrail_node.node.GuardrailNode.Ports.default"
-    },
-    {
-      "node": "MapNode",
-      "error": "Expected NodeReference items to have an instance"
-    },
-    {
-      "node": "MergeNode",
-      "error": "vellum.workflows.nodes.displayable.merge_node.node.MergeNode.Ports.default"
-    },
     {
       "node": "SubworkflowDeploymentNode",
-      "error": "headers: {'server': 'gunicorn', 'date': 'Mon, 22 Sep 2025 14:24:17 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '28', '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': 'Invalid API key'}"
+      "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": "headers: {'server': 'gunicorn', 'date': 'Mon, 22 Sep 2025 14:24:17 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '28', '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': 'Invalid API key'}"
+      "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": "Expected NodeReference query to have an instance"
+      "error": "ValueError: Expected NodeReference query to have an instance"
     },
     {
       "node": "TemplatingNode",
-      "error": "TemplatingNode.Outputs.result"
+      "error": "KeyError: TemplatingNode.Outputs.result"
     }
   ]
 }

vellum_ee/scripts/generate_node_definitions.py

@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 def create_display_context_with_client() -> WorkflowDisplayContext:
     """Create a WorkflowDisplayContext with Vellum client for serialization."""
     client = create_vellum_client()
-    return WorkflowDisplayContext(client=client)
+    return WorkflowDisplayContext(client=client, dry_run=True)
 
 
 def get_all_displayable_node_classes() -> List[Type[BaseNode]]:
@@ -70,7 +70,7 @@ def main() -> None:
                 display_instance = display_class()
                 display_instance.serialize(display_context)
             except Exception as e:
-                errors.append({"node": node_class.__name__, "error": str(e)})
+                errors.append({"node": node_class.__name__, "error": f"{e.__class__.__name__}: {str(e)}"})
 
     result = {"nodes": successful_nodes, "errors": errors}
 

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -323,12 +323,12 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         )
         return node_definition
 
-    def get_node_output_display(self, output: OutputReference) -> Tuple[Type[BaseNode], NodeOutputDisplay]:
+    def get_node_output_display(self, output: OutputReference) -> NodeOutputDisplay:
         explicit_display = self.output_display.get(output)
         if explicit_display:
-            return self._node, explicit_display
+            return explicit_display
 
-        return (self._node, NodeOutputDisplay(id=uuid4_from_hash(f"{self.node_id}|{output.name}"), name=output.name))
+        return NodeOutputDisplay(id=uuid4_from_hash(f"{self.node_id}|{output.name}"), name=output.name)
 
     def get_node_port_display(self, port: Port) -> PortDisplay:
         overrides = self.port_displays.get(port)
@@ -347,6 +347,9 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         if default_port in port_displays:
             return port_displays[default_port].id
 
+        if default_port:
+            return self.get_node_port_display(default_port).id
+
         first_port = next((port for port in unadorned_node.Ports), None)
         if not first_port:
             raise ValueError(f"Node {self._node.__name__} must have at least one port.")

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

@@ -1,8 +1,7 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, Optional, TypeVar, cast
+from typing import ClassVar, Dict, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable import APINode
-from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -178,11 +177,9 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
         ]
         inputs.extend(additional_header_inputs)
 
-        _, text_output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
-        _, json_output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.json)]
-        _, status_code_output_display = display_context.global_node_output_displays[
-            cast(OutputReference, node.Outputs.status_code)
-        ]
+        text_output_display = self.get_node_output_display(node.Outputs.text)
+        json_output_display = self.get_node_output_display(node.Outputs.json)
+        status_code_output_display = self.get_node_output_display(node.Outputs.status_code)
 
         serialized_node: JsonObject = {
             "id": str(node_id),

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

@@ -7,6 +7,8 @@ from vellum.workflows.inputs.base import BaseInputs
 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
@@ -31,14 +33,25 @@ class BaseInlineSubworkflowNodeDisplay(
         node = self._node
         node_id = self.node_id
 
-        node_inputs, workflow_inputs = self._generate_node_and_workflow_inputs(node_id, node, display_context)
+        subworkflow_class = raise_if_descriptor(node.subworkflow)
+        if subworkflow_class is None:
+            display_context.add_error(
+                NodeValidationError(
+                    "InlineSubworkflowNode requires a subworkflow to be defined",
+                    node_class_name=node.__class__.__name__,
+                )
+            )
+            subworkflow_class = BaseWorkflow
 
+        node_inputs, workflow_inputs = self._generate_node_and_workflow_inputs(
+            node_id, node, display_context, subworkflow_class
+        )
         subworkflow_display = get_workflow_display(
             base_display_class=display_context.workflow_display_class,
-            workflow_class=raise_if_descriptor(node.subworkflow),
+            workflow_class=subworkflow_class,
             parent_display_context=display_context,
         )
-        workflow_outputs = self._generate_workflow_outputs(node, subworkflow_display.display_context)
+        workflow_outputs = self._generate_workflow_outputs(node, subworkflow_display.display_context, subworkflow_class)
         serialized_subworkflow = subworkflow_display.serialize()
 
         return {
@@ -63,8 +76,8 @@ class BaseInlineSubworkflowNodeDisplay(
         node_id: UUID,
         node: Type[InlineSubworkflowNode],
         display_context: WorkflowDisplayContext,
+        subworkflow: Type[BaseWorkflow],
     ) -> Tuple[List[NodeInput], List[VellumVariable]]:
-        subworkflow = raise_if_descriptor(node.subworkflow)
         subworkflow_inputs_class = subworkflow.get_inputs_class()
         subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
 
@@ -115,9 +128,10 @@ class BaseInlineSubworkflowNodeDisplay(
         self,
         node: Type[InlineSubworkflowNode],
         display_context: WorkflowDisplayContext,
+        subworkflow: Type[BaseWorkflow],
     ) -> List[VellumVariable]:
         workflow_outputs: List[VellumVariable] = []
-        for output_descriptor in raise_if_descriptor(node.subworkflow).Outputs:  # type: ignore[union-attr]
+        for output_descriptor in subworkflow.Outputs:  # type: ignore[union-attr]
             workflow_output_display = display_context.workflow_output_displays[output_descriptor]
             output_type = infer_vellum_variable_type(output_descriptor)
             workflow_outputs.append(

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

@@ -1,7 +1,8 @@
 from uuid import UUID
-from typing import Generic, Optional, TypeVar, cast
+from typing import Generic, Optional, Type, TypeVar, cast
 
 from vellum.workflows.nodes import MapNode
+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.nodes.utils import raise_if_descriptor
@@ -22,12 +23,19 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
         node = self._node
         node_id = self.node_id
 
-        subworkflow = cast(type[BaseWorkflow], raise_if_descriptor(node.subworkflow))
+        subworkflow_value = raise_if_descriptor(node.subworkflow)
+        subworkflow = (
+            cast(type[BaseWorkflow], subworkflow_value)
+            if subworkflow_value is not None
+            else self._default_workflow_class()
+        )
+
+        items = raise_if_descriptor(node.items)
 
         items_node_input = create_node_input(
             node_id=node_id,
             input_name="items",
-            value=node.items,
+            value=items or [],
             display_context=display_context,
             input_id=self.node_input_ids_by_name.get("items"),
         )
@@ -81,3 +89,9 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
             },
             **self.serialize_generic_fields(display_context),
         }
+
+    def _default_workflow_class(self) -> Type[BaseWorkflow]:
+        class MapNodeSubworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+            pass
+
+        return MapNodeSubworkflow

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

@@ -1,7 +1,6 @@
 import inspect
-from typing import Any, Generic, Tuple, Type, TypeVar
+from typing import Any, Generic, TypeVar
 
-from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.references.output import OutputReference
@@ -66,7 +65,7 @@ class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_Re
 
         return serialized_node
 
-    def get_node_output_display(self, output: OutputReference) -> Tuple[Type[BaseNode], NodeOutputDisplay]:
+    def get_node_output_display(self, output: OutputReference) -> NodeOutputDisplay:
         inner_node = self._node.__wrapped_node__
         if not inner_node:
             return super().get_node_output_display(output)