vellum-ai 1.6.4__tar.gz → 1.7.0__tar.gz

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/PKG-INFO

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

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/ee/vellum_ee/assets/node-definitions.json

@@ -542,6 +542,163 @@
         }
       ]
     },
+    {
+      "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": "035842e0-34ed-43af-97de-a706e40912ae",
       "label": "Tool Calling Node",
@@ -854,18 +1011,6 @@
     }
   ],
   "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"

vellum_ai-1.7.0/ee/vellum_ee/workflows/display/exceptions.py

@@ -0,0 +1,3 @@
+from vellum_ee.workflows.display.utils.exceptions import NodeValidationError
+
+__all__ = ["NodeValidationError"]

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.7.0/ee/vellum_ee/workflows/display/utils/exceptions.py

@@ -0,0 +1,26 @@
+class UserFacingException(Exception):
+    def to_message(self) -> str:
+        return str(self)
+
+
+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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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_ai-1.6.4 → vellum_ai-1.7.0}/ee/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,7 +203,7 @@ 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

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/ee/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

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/ee/vellum_ee/workflows/tests/test_server.py

@@ -1,3 +1,4 @@
+import pytest
 import sys
 from uuid import uuid4
 from typing import Type, cast
@@ -6,6 +7,7 @@ from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_executor_response import CodeExecutorResponse
 from vellum.client.types.number_vellum_value import NumberVellumValue
 from vellum.workflows import BaseWorkflow
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
@@ -499,6 +501,45 @@ class MapNodeWorkflow(BaseWorkflow):
     assert event.body.outputs == {"results": [1.0, 1.0, 1.0]}
 
 
+def test_load_from_module__syntax_error_in_node_file():
+    """
+    Tests that a syntax error in a node file raises WorkflowInitializationException with user-facing message.
+    """
+    # GIVEN a workflow module with a node file containing a syntax error (missing colon)
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.broken_node import BrokenNode
+
+class Workflow(BaseWorkflow):
+    graph = BrokenNode
+""",
+        "nodes/__init__.py": "",
+        "nodes/broken_node.py": """\
+from vellum.workflows.nodes import BaseNode
+
+class BrokenNode(BaseNode)  # Missing colon
+    \"\"\"This node has a syntax error.\"\"\"
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    # WHEN we attempt to load the workflow
+    # THEN it should raise WorkflowInitializationException
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflow.load_from_module(namespace)
+
+    # AND the error message should be user-friendly
+    error_message = str(exc_info.value)
+    assert "Failed to load workflow module:" in error_message
+    assert "invalid syntax" in error_message or "expected ':'" in error_message
+
+
 def test_serialize_module__tool_calling_node_with_single_tool():
     """Test that serialize_module works with a tool calling node that has a single tool."""
 

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.6.4"
+version = "1.7.0"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/src/vellum/__init__.py

@@ -679,6 +679,7 @@ from .client.types import (
     WorkflowRequestNumberInputRequest,
     WorkflowRequestStringInputRequest,
     WorkflowRequestVideoInputRequest,
+    WorkflowResolvedState,
     WorkflowResultEvent,
     WorkflowResultEventOutputData,
     WorkflowResultEventOutputDataArray,
@@ -1429,6 +1430,7 @@ __all__ = [
     "WorkflowRequestNumberInputRequest",
     "WorkflowRequestStringInputRequest",
     "WorkflowRequestVideoInputRequest",
+    "WorkflowResolvedState",
     "WorkflowResultEvent",
     "WorkflowResultEventOutputData",
     "WorkflowResultEventOutputDataArray",

{vellum_ai-1.6.4 → vellum_ai-1.7.0}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.6.4",
+            "User-Agent": "vellum-ai/1.7.0",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.6.4",
+            "X-Fern-SDK-Version": "1.7.0",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None: