vellum-ai 1.7.5__tar.gz → 1.7.7__tar.gz

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/PKG-INFO

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

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_cli/push.py

@@ -77,11 +77,7 @@ def push_command(
 
     logger.info(f"Loading workflow from {workflow_config.module}")
     resolved_workspace = workspace or workflow_config.workspace or DEFAULT_WORKSPACE_CONFIG.name
-    workspace_config = (
-        next((w for w in config.workspaces if w.name == resolved_workspace), DEFAULT_WORKSPACE_CONFIG)
-        if workspace
-        else DEFAULT_WORKSPACE_CONFIG
-    )
+    workspace_config = next((w for w in config.workspaces if w.name == resolved_workspace), DEFAULT_WORKSPACE_CONFIG)
     api_key = os.getenv(workspace_config.api_key)
     if not api_key:
         raise ValueError(f"No API key value found in environment for workspace '{workspace_config.name}'.")

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_cli/tests/test_push.py

@@ -1134,3 +1134,89 @@ def test_push__deploy_stores_deployment_config_in_lock_file(mock_module, vellum_
     deployment_config_str = call_args["deployment_config"]
     deployment_config = json.loads(deployment_config_str)
     assert deployment_config["name"] == "test-push-deploy-stores-deployment-config-in-lock-file"
+
+
+def test_push__custom_workspace_in_lockfile__uses_custom_workspace_without_flag(mock_module, vellum_client_class):
+    """
+    Tests that push respects the custom workspace from the lockfile when no --workspace flag is provided.
+    """
+
+    # GIVEN a workflow already configured in the lockfile with a custom workspace
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+    set_pyproject_toml = mock_module.set_pyproject_toml
+
+    # AND the lockfile has the workflow with a custom workspace
+    with open(os.path.join(temp_dir, "vellum.lock.json"), "w") as f:
+        json.dump(
+            {
+                "version": "1.0",
+                "workflows": [
+                    {
+                        "module": module,
+                        "workflow_sandbox_id": workflow_sandbox_id,
+                        "workspace": "my_custom_workspace",
+                        "container_image_name": None,
+                        "container_image_tag": None,
+                        "deployments": [],
+                        "ignore": None,
+                        "target_directory": None,
+                    }
+                ],
+                "workspaces": [],
+            },
+            f,
+            indent=2,
+        )
+
+    # AND the custom workspace is defined in pyproject.toml
+    set_pyproject_toml(
+        {
+            "workflows": [],
+            "workspaces": [
+                {
+                    "name": "my_custom_workspace",
+                    "api_key": "MY_CUSTOM_VELLUM_API_KEY",
+                }
+            ],
+        }
+    )
+
+    # AND the .env file has the custom api key
+    with open(os.path.join(temp_dir, ".env"), "w") as f:
+        f.write(
+            """\
+VELLUM_API_KEY=abcdef123456
+MY_CUSTOM_VELLUM_API_KEY=custom-key-xyz
+"""
+        )
+
+    # AND a workflow exists in the module
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API returns successfully
+    vellum_client_class.return_value.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=workflow_sandbox_id,
+    )
+    vellum_client_class.return_value._client_wrapper._environment.default = "https://api.vellum.ai/v1"
+
+    # WHEN calling `vellum push` WITHOUT the --workspace flag
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND the custom workspace API key should have been used
+    vellum_client_class.assert_called_once_with(
+        api_key="custom-key-xyz",
+        environment=mock.ANY,
+        api_version=None,
+    )
+
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        assert len(lock_file_content["workflows"]) == 1
+        assert lock_file_content["workflows"][0]["workspace"] == "my_custom_workspace"
+        assert lock_file_content["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -188,7 +188,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             type = primitive_type_to_vellum_variable_type(output)
             value = (
                 serialize_value(node_id, display_context, output.instance)
-                if output.instance is not None and output.instance != undefined
+                if output.instance is not None and output.instance is not undefined
                 else None
             )
 

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -688,3 +688,19 @@ def test_serialize_node__comment_expanded_preserved_when_explicitly_set(serializ
     assert "comment" in display_data
     assert display_data["comment"]["value"] == "This is a test comment."
     assert display_data["comment"]["expanded"] is False
+
+
+def test_serialize_node__attribute_with_type_annotation_no_default(serialize_node):
+    """
+    Tests that attributes with type annotations but no default values serialize as None.
+    """
+
+    # GIVEN a node with typed attributes but no default values
+    class NodeWithTypedAttributesNoDefault(BaseNode):
+        attr: str
+
+    # WHEN the node is serialized
+    serialized_node = serialize_node(NodeWithTypedAttributesNoDefault)
+
+    # THEN the attribute should serialize as None
+    assert serialized_node["attributes"][0]["value"] is None

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_manual_trigger_serialization.py

@@ -3,8 +3,6 @@
 import pytest
 from typing import cast
 
-from deepdiff import DeepDiff
-
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
@@ -42,27 +40,24 @@ def serialize(workflow_class) -> JsonObject:
 
 
 def test_manual_trigger_serialization():
-    """Workflow with ManualTrigger serializes with trigger field."""
+    """Workflow with ManualTrigger serializes with triggers field."""
     result = serialize(create_workflow(ManualTrigger))
-    workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
-    trigger = cast(JsonObject, workflow_raw_data["trigger"])
+    triggers = cast(JsonArray, result["triggers"])
+
+    assert len(triggers) == 1
+    trigger = cast(JsonObject, triggers[0])
 
     assert trigger["type"] == "MANUAL"
-    assert not DeepDiff(
-        {
-            "type": "MANUAL",
-            "definition": {"name": "ManualTrigger", "module": ["vellum", "workflows", "triggers", "manual"]},
-        },
-        trigger,
-        ignore_order=True,
-    )
+    assert "id" in trigger
+    assert "attributes" in trigger
+    assert trigger["attributes"] == []
+    assert "definition" not in trigger
 
 
 def test_no_trigger_serialization():
-    """Workflow without trigger has no trigger field."""
+    """Workflow without trigger has no triggers field."""
     result = serialize(create_workflow())
-    workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
-    assert "trigger" not in workflow_raw_data
+    assert "triggers" not in result
 
 
 def test_manual_trigger_multiple_entrypoints():
@@ -84,10 +79,12 @@ def test_manual_trigger_multiple_entrypoints():
             output_b = NodeB.Outputs.output
 
     result = serialize(MultiWorkflow)
+    triggers = cast(JsonArray, result["triggers"])
     workflow_data = cast(JsonObject, result["workflow_raw_data"])
-    trigger = cast(JsonObject, workflow_data["trigger"])
     nodes = cast(JsonArray, workflow_data["nodes"])
 
+    assert len(triggers) == 1
+    trigger = cast(JsonObject, triggers[0])
     assert trigger["type"] == "MANUAL"
     assert len([n for n in nodes if cast(JsonObject, n)["type"] == "GENERIC"]) >= 2
 
@@ -98,8 +95,8 @@ def test_serialized_workflow_structure():
     workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
     definition = cast(JsonObject, workflow_raw_data["definition"])
 
-    assert result.keys() == {"workflow_raw_data", "input_variables", "state_variables", "output_variables"}
-    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition", "output_values", "trigger"}
+    assert result.keys() == {"workflow_raw_data", "input_variables", "state_variables", "output_variables", "triggers"}
+    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition", "output_values"}
     assert definition["name"] == "TestWorkflow"
 
 

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -3,7 +3,7 @@ import inspect
 from io import StringIO
 import sys
 from uuid import UUID
-from typing import TYPE_CHECKING, Any, Dict, List, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 
 from pydantic import BaseModel
 
@@ -248,13 +248,11 @@ def serialize_key(key: Any) -> str:
         return str(key)
 
 
-# Sentinel value to indicate a value should be omitted from serialization
-_UNDEFINED_SENTINEL: JsonObject = {"__undefined__": True}
-
-
-def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContext", value: Any) -> Optional[JsonObject]:
     """
-    Serialize a value to a JSON object.
+    Serialize a value to a JSON object. Returns `None` if the value resolves to `undefined`.
+    This is safe because all valid values are a JSON object, including the `None` constant:
+    > `{"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}}`
 
     Args:
         executable_id: node id or workflow id
@@ -265,7 +263,7 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         serialized value
     """
     if value is undefined:
-        return _UNDEFINED_SENTINEL
+        return None
 
     if isinstance(value, ConstantValueReference):
         return serialize_value(executable_id, display_context, value._value)
@@ -353,7 +351,7 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         serialized_items = []
         for item in value:
             serialized_item = serialize_value(executable_id, display_context, item)
-            if serialized_item != _UNDEFINED_SENTINEL:
+            if serialized_item is not None:
                 serialized_items.append(serialized_item)
 
         if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
@@ -389,7 +387,7 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         serialized_entries: List[Dict[str, Any]] = []
         for key, val in value.items():
             serialized_val = serialize_value(executable_id, display_context, val)
-            if serialized_val != _UNDEFINED_SENTINEL:
+            if serialized_val is not None:
                 serialized_entries.append(
                     {
                         "id": str(uuid4_from_hash(f"{executable_id}|{key}")),
@@ -455,7 +453,9 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         if inputs:
             serialized_inputs = {}
             for param_name, input_ref in inputs.items():
-                serialized_inputs[param_name] = serialize_value(executable_id, display_context, input_ref)
+                serialized_input = serialize_value(executable_id, display_context, input_ref)
+                if serialized_input is not None:
+                    serialized_inputs[param_name] = serialized_input
 
             model_data = function_definition.model_dump()
             model_data["inputs"] = serialized_inputs

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -410,7 +410,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 self.display_context.add_error(e)
 
         # Serialize workflow-level trigger if present
-        trigger_data: Optional[JsonObject] = self._serialize_workflow_trigger()
+        triggers: Optional[JsonArray] = self._serialize_workflow_trigger()
 
         workflow_raw_data: JsonObject = {
             "nodes": cast(JsonArray, nodes_dict_list),
@@ -423,22 +423,25 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             "output_values": output_values,
         }
 
-        if trigger_data is not None:
-            workflow_raw_data["trigger"] = trigger_data
-
-        return {
+        result: JsonObject = {
             "workflow_raw_data": workflow_raw_data,
             "input_variables": input_variables,
             "state_variables": state_variables,
             "output_variables": output_variables,
         }
 
-    def _serialize_workflow_trigger(self) -> Optional[JsonObject]:
+        if triggers is not None:
+            result["triggers"] = triggers
+
+        return result
+
+    def _serialize_workflow_trigger(self) -> Optional[JsonArray]:
         """
         Serialize workflow-level trigger information.
 
         Returns:
-            JsonObject with trigger data if a trigger is present, None otherwise
+            JsonArray with trigger data if a trigger is present, None otherwise.
+            Each trigger in the array has: id (UUID), type (str), attributes (list)
         """
         # Get all trigger edges from the workflow's subgraphs
         trigger_edges = []
@@ -469,13 +472,19 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 f"Please add it to the trigger type mapping in get_trigger_type_mapping()."
             )
 
-        return {
-            "type": trigger_type.value,
-            "definition": {
-                "name": trigger_class.__name__,
-                "module": cast(JsonArray, trigger_class.__module__.split(".")),
-            },
-        }
+        # Return as a list with a single trigger object matching Django schema
+        trigger_id = uuid4_from_hash(f"{trigger_class.__module__} | {trigger_class.__qualname__}")
+
+        return cast(
+            JsonArray,
+            [
+                {
+                    "id": str(trigger_id),
+                    "type": trigger_type.value,
+                    "attributes": [],
+                }
+            ],
+        )
 
     def _serialize_edge_display_data(self, edge_display: EdgeDisplay) -> Optional[JsonObject]:
         """Serialize edge display data, returning None if no display data is present."""

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/ee/vellum_ee/workflows/tests/test_server.py

@@ -536,10 +536,49 @@ class BrokenNode(BaseNode)  # Missing colon
 
     # AND the error message should be user-friendly
     error_message = str(exc_info.value)
-    assert "Failed to load workflow module:" in error_message
+    assert "Syntax Error raised while loading Workflow:" in error_message
     assert "invalid syntax" in error_message or "expected ':'" in error_message
 
 
+def test_load_from_module__name_error_in_node_file():
+    """
+    Tests that a NameError in a node file raises WorkflowInitializationException with user-facing message.
+    """
+    # GIVEN a workflow module with a node file containing a NameError (undefined class reference)
+    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):
+    some_attribute = UndefinedClass()
+""",
+    }
+
+    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 "Invalid variable reference:" in error_message
+    assert "UndefinedClass" in error_message or "not defined" 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.7.5 → vellum_ai-1.7.7}/pyproject.toml

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

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/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.7.5",
+            "User-Agent": "vellum-ai/1.7.7",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.5",
+            "X-Fern-SDK-Version": "1.7.7",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/bases/base.py

@@ -1,10 +1,26 @@
 from abc import ABC, ABCMeta, abstractmethod
+from collections.abc import Callable as CollectionsCallable
 from dataclasses import field
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
 from uuid import UUID, uuid4
-from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
+from typing import (
+    Any,
+    Callable as TypingCallable,
+    Dict,
+    Generic,
+    Iterator,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -43,15 +59,15 @@ def _is_nested_class(nested: Any, parent: Type) -> bool:
     ) or any(_is_nested_class(nested, base) for base in parent.__bases__)
 
 
-def _is_annotated(cls: Type, name: str) -> bool:
+def _is_annotated(cls: Type, name: str) -> Any:
     if name in cls.__annotations__:
-        return True
+        return cls.__annotations__[name]
 
     for base in cls.__bases__:
-        if _is_annotated(base, name):
-            return True
+        if annotation := _is_annotated(base, name):
+            return annotation
 
-    return False
+    return None
 
 
 class BaseNodeMeta(ABCMeta):
@@ -151,8 +167,10 @@ class BaseNodeMeta(ABCMeta):
         try:
             attribute = super().__getattribute__(name)
         except AttributeError as e:
-            if _is_annotated(cls, name):
-                attribute = None
+            annotation = _is_annotated(cls, name)
+            origin_annotation = get_origin(annotation)
+            if origin_annotation is not CollectionsCallable and origin_annotation is not TypingCallable:
+                attribute = undefined
             else:
                 raise e
 
@@ -482,7 +500,8 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
                     setattr(base, leaf, input_value)
 
         for descriptor in self.__class__:
-            if not descriptor.instance:
+            if descriptor.instance is undefined:
+                setattr(self, descriptor.name, undefined)
                 continue
 
             if any(isinstance(t, type) and issubclass(t, BaseDescriptor) for t in descriptor.types):

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,10 +1,12 @@
 from abc import ABC
-from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Set, Tuple, Type
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.core import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
@@ -79,6 +81,56 @@ class BaseAdornmentNode(
     __wrapped_node__: Optional[Type["BaseNode"]] = None
     subworkflow: Type["BaseWorkflow"]
 
+    class Trigger(BaseNode.Trigger):
+        """
+        Trigger class for adornment nodes that delegates to the wrapped node's Trigger
+        for proper merge behavior handling.
+        """
+
+        @classmethod
+        def should_initiate(
+            cls,
+            state: StateType,
+            dependencies: Set["Type[BaseNode]"],
+            node_span_id: UUID,
+        ) -> bool:
+            """
+            Delegates to the wrapped node's Trigger.should_initiate method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for initiation logic.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Only delegate if the wrapped node has a specific merge behavior
+                # that differs from the default AWAIT_ATTRIBUTES
+                if (
+                    hasattr(wrapped_trigger, "merge_behavior")
+                    and wrapped_trigger.merge_behavior != MergeBehavior.AWAIT_ATTRIBUTES
+                ):
+                    return wrapped_trigger.should_initiate(state, dependencies, node_span_id)
+
+            # Fallback to the base implementation if no wrapped node
+            return super().should_initiate(state, dependencies, node_span_id)
+
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: set[Type[BaseNode]], invoked_by: Optional[UUID] = None
+        ) -> UUID:
+            """
+            Delegates to the wrapped node's Trigger._queue_node_execution method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for dependency tracking.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Delegate to the wrapped node's trigger logic for queuing
+                return wrapped_trigger._queue_node_execution(state, dependencies, invoked_by)
+
+            # Fallback to the base implementation if no wrapped node
+            return super()._queue_node_execution(state, dependencies, invoked_by)
+
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
         # Subclasses of BaseAdornableNode can override this method to provider their own

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -7,6 +7,7 @@ from vellum import (
     AdHocExpandMeta,
     ChatMessage,
     FunctionDefinition,
+    InitiatedAdHocExecutePromptEvent,
     PromptBlock,
     PromptOutput,
     PromptParameters,
@@ -185,7 +186,8 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 expand_meta=self.expand_meta,
                 request_options=request_options,
             )
-            return iter([response])
+            initiated_event = InitiatedAdHocExecutePromptEvent(execution_id=response.execution_id)
+            return iter([initiated_event, response])
         else:
             return self._context.vellum_client.ad_hoc.adhoc_execute_prompt_stream(
                 ml_model=self.ml_model,

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/displayable/search_node/node.py

@@ -1,6 +1,7 @@
 import json
 from typing import ClassVar
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseSearchNode as BaseSearchNode
@@ -37,7 +38,7 @@ class SearchNode(BaseSearchNode[StateType]):
         text: str
 
     def run(self) -> Outputs:
-        if self.query is None or self.query == "":
+        if self.query is undefined or self.query is None or self.query == "":
             raise NodeException(
                 message="Search query is required but was not provided",
                 code=WorkflowErrorCode.INVALID_INPUTS,

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/displayable/search_node/tests/test_node.py

@@ -234,3 +234,17 @@ def test_run_workflow__invalid_query_raises_validation_error(invalid_query):
     assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert "query" in exc_info.value.message.lower()
     assert "required" in exc_info.value.message.lower() or "missing" in exc_info.value.message.lower()
+
+
+def test_run_workflow__missing_query_attribute_raises_validation_error():
+    """Confirm that a SearchNode without a query attribute defined raises INVALID_INPUTS"""
+
+    class MySearchNode(SearchNode):
+        document_index = "document_index"
+
+    with pytest.raises(NodeException) as exc_info:
+        MySearchNode().run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "query" in exc_info.value.message.lower()
+    assert "required" in exc_info.value.message.lower()

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -15,7 +15,7 @@ from vellum import (
 from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.chat_message_request import ChatMessageRequest
-from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
+from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT, undefined
 from vellum.workflows.context import execution_context, get_execution_context, get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
@@ -226,6 +226,12 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             **request_options.get("additional_body_parameters", {}),
         }
 
+        if self.deployment is undefined:
+            raise NodeException(
+                code=WorkflowErrorCode.NODE_EXECUTION,
+                message="Expected subworkflow deployment attribute to be either a UUID or STR, got `undefined` instead",
+            )
+
         try:
             deployment_id = str(self.deployment) if isinstance(self.deployment, UUID) else None
             deployment_name = self.deployment if isinstance(self.deployment, str) else None

{vellum_ai-1.7.5 → vellum_ai-1.7.7}/src/vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py

@@ -265,7 +265,7 @@ def test_run_workflow__no_deployment():
 
     # AND the error message should be correct
     assert exc_info.value.code == WorkflowErrorCode.NODE_EXECUTION
-    assert "Expected subworkflow deployment attribute to be either a UUID or STR, got None instead" in str(
+    assert "Expected subworkflow deployment attribute to be either a UUID or STR, got `undefined` instead" in str(
         exc_info.value
     )