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

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

vellum/workflows/exceptions.py

@@ -6,6 +6,19 @@ if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
 
 
+def import_workflow_class() -> Type["BaseWorkflow"]:
+    """
+    Helper function to help avoid circular imports.
+
+    Ideally, we use the one in types.generics, but _that_ causes circular imports
+    due to the `src/vellum/workflows/types/definition.py` module's import of `EnvironmentVariableReference`
+    """
+
+    from vellum.workflows.workflows import BaseWorkflow
+
+    return BaseWorkflow
+
+
 class NodeException(Exception):
     def __init__(
         self,
@@ -35,12 +48,13 @@ class WorkflowInitializationException(Exception):
     def __init__(
         self,
         message: str,
-        workflow_definition: Type["BaseWorkflow"],
+        workflow_definition: Optional[Type["BaseWorkflow"]] = None,
         code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS,
     ):
+
         self.message = message
         self.code = code
-        self.definition = workflow_definition
+        self.definition = workflow_definition if workflow_definition is not None else import_workflow_class()
         super().__init__(message)
 
     @property

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

@@ -1,13 +1,14 @@
-from typing import ClassVar, Union
+from typing import ClassVar, Generic, Union
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode, vellum_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.ports import NodePorts
+from vellum.workflows.types.generics import StateType
 
 
-class ErrorNode(BaseNode):
+class ErrorNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to raise an error to reject the surrounding Workflow.
 

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -23,6 +23,7 @@ from vellum import (
 from vellum.client.core import RequestOptions
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
@@ -147,6 +148,8 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         compiled_inputs: List[CodeExecutorInput] = []
 
         for input_name, input_value in self.code_inputs.items():
+            if input_value is undefined:
+                continue
             if isinstance(input_value, str):
                 compiled_inputs.append(
                     StringInput(

vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py

@@ -13,6 +13,7 @@ from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInp
 from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.number_input import NumberInput
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -1278,3 +1279,85 @@ def main(secret: str) -> str:
         packages=[],
         request_options=None,
     )
+
+
+def test_run_node__undefined_input_skipped():
+    """
+    Confirm that when an undefined value is passed as an input, it is skipped rather than raising an error.
+    The function should use the default parameter value when undefined input is skipped.
+    """
+
+    # GIVEN a node with both a valid input and an undefined input that runs inline
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        code = """\
+def main(word: str, undefined_input: str = "default") -> int:
+    return len(word) + len(undefined_input)
+"""
+        runtime = "PYTHON_3_11_6"
+        packages = []
+
+        code_inputs = {
+            "word": "hello",
+            "undefined_input": undefined,
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should run successfully without raising an error
+    assert outputs == {"result": 12, "log": ""}  # len("hello") + len("default") = 5 + 7 = 12
+
+
+def test_run_node__undefined_input_skipped_api_execution(vellum_client):
+    """
+    Confirm that when an undefined value is passed as an input in API execution mode,
+    it is skipped rather than raising an error.
+    """
+
+    # GIVEN a node with both a valid input and an undefined input that forces API execution
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        code = """\
+def main(word: str) -> int:
+    return len(word)
+"""
+        runtime = "PYTHON_3_11_6"
+        packages = [CodeExecutionPackage(name="requests", version="2.0.0")]
+
+        code_inputs = {
+            "word": "hello",
+            "undefined_input": undefined,
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should run successfully without raising an error
+    assert outputs == {"result": 5, "log": ""}
+
+    # AND the API should be called with only the non-undefined input
+    vellum_client.execute_code.assert_called_once_with(
+        input_values=[StringInput(name="word", value="hello")],
+        code="""\
+def main(word: str) -> int:
+    return len(word)
+""",
+        runtime="PYTHON_3_11_6",
+        output_type="NUMBER",
+        packages=[CodeExecutionPackage(name="requests", version="2.0.0")],
+        request_options=None,
+    )

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -4,6 +4,7 @@ import sys
 import traceback
 from typing import Any, Optional, Tuple, Union
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.utils import cast_to_output_type, wrap_inputs_for_backward_compatibility
@@ -54,7 +55,7 @@ def run_code_inline(
         "__arg__out": None,
         "print": _inline_print,
     }
-    run_args = [f"{name}=__arg__inputs['{name}']" for name in inputs.keys()]
+    run_args = [f"{name}=__arg__inputs['{name}']" for name, value in inputs.items() if value is not undefined]
     execution_code = f"""\
 {code}
 

vellum/workflows/nodes/displayable/conditional_node/node.py

@@ -1,4 +1,4 @@
-from typing import Set
+from typing import Generic, Set
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
@@ -6,9 +6,10 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.ports.utils import validate_ports
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class ConditionalNode(BaseNode):
+class ConditionalNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to conditionally determine which port to invoke next. This node exists to be backwards compatible with
     Vellum's Conditional Node, and for most cases, you should extend `BaseNode.Ports` directly.

vellum/workflows/nodes/displayable/merge_node/node.py

@@ -1,8 +1,11 @@
+from typing import Generic
+
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class MergeNode(BaseNode):
+class MergeNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to merge the control flow of multiple nodes into a single node. This node exists to be backwards compatible
     with Vellum's Merge Node, and for most cases, you should extend from `BaseNode.Trigger` directly.

vellum/workflows/nodes/displayable/note_node/node.py

@@ -1,8 +1,11 @@
+from typing import Generic
+
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class NoteNode(BaseNode):
+class NoteNode(BaseNode[StateType], Generic[StateType]):
     """
     A no-op Node purely used to display a note in the Vellum UI.
     """

vellum/workflows/runner/runner.py

@@ -145,6 +145,14 @@ class WorkflowRunner(Generic[StateType]):
             ]
             self._is_resuming = True
         elif previous_execution_id:
+            if not self.workflow.resolvers:
+                raise WorkflowInitializationException(
+                    message=f"No resolvers configured to load initial state for execution ID: {previous_execution_id}",
+                    workflow_definition=self.workflow.__class__,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
+            resolver_failed = True
             for resolver in self.workflow.resolvers:
                 try:
                     load_state_result = resolver.load_state(previous_execution_id)
@@ -161,10 +169,19 @@ class WorkflowRunner(Generic[StateType]):
                                 load_state_result.root_trace_id,
                                 load_state_result.root_span_id,
                             )
+                            resolver_failed = False
                             break
                 except Exception as e:
                     logger.warning(f"Failed to load state from resolver {type(resolver).__name__}: {e}")
                     continue
+
+            if resolver_failed:
+                raise WorkflowInitializationException(
+                    message=f"All resolvers failed to load initial state for execution ID: {previous_execution_id}",
+                    workflow_definition=self.workflow.__class__,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+
             self._entrypoints = self.workflow.get_entrypoints()
         else:
             normalized_inputs = deepcopy(inputs) if inputs else self.workflow.get_default_inputs()

vellum/workflows/utils/vellum_variables.py

@@ -87,6 +87,9 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
     elif _is_type_optionally_in(type_, (VellumError, VellumErrorRequest)):
         return "ERROR"
 
+    if type_ is typing.Any:
+        return "JSON"
+
     builtin_list_type = _builtin_list_to_vellum_type(type_)
     if builtin_list_type:
         return builtin_list_type

vellum/workflows/workflows/base.py

@@ -63,6 +63,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
 )
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.executable import BaseExecutable
 from vellum.workflows.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
@@ -681,7 +682,16 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
     @staticmethod
     def load_from_module(module_path: str) -> Type["BaseWorkflow"]:
         workflow_path = f"{module_path}.workflow"
-        module = importlib.import_module(workflow_path)
+        try:
+            module = importlib.import_module(workflow_path)
+        except TypeError as e:
+            if "Unexpected graph type" in str(e) or "unhashable type: 'set'" in str(e):
+                raise WorkflowInitializationException(
+                    message="Invalid graph structure detected. Nested sets or unsupported graph types are not allowed. "
+                    "Please contact Vellum support for assistance with Workflow configuration."
+                ) from e
+            else:
+                raise
         workflows: List[Type[BaseWorkflow]] = []
         for name in dir(module):
             if name.startswith("__"):

{vellum_ai-1.6.2.dist-info → vellum_ai-1.6.4.dist-info}/METADATA

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

{vellum_ai-1.6.2.dist-info → vellum_ai-1.6.4.dist-info}/RECORD

@@ -3,7 +3,7 @@ vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
 vellum_cli/__init__.py,sha256=CCTCiCvwxjFHXVSKhzUtZ3GE_h4HrbLEX_XC3qjPuAk,13618
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
 vellum_cli/config.py,sha256=qJrd8W__UZZaUMAG6BO3sxfkgpCoOS4NA3QfqneW-jE,9588
-vellum_cli/image_push.py,sha256=eeOBqKtKkPu6Kgm_jQCVCivogzAcdlIlkv61-QxH67c,11006
+vellum_cli/image_push.py,sha256=OLHfIlhKpqfaU2L2DhSkk0J_hQPUZ111lN2tqVDAywo,11554
 vellum_cli/init.py,sha256=WpnMXPItPmh0f0bBGIer3p-e5gu8DUGwSArT_FuoMEw,5093
 vellum_cli/logger.py,sha256=dcM_OmgqXLo93vDYswO5ylyUQQcTfnA5GTd5tbIt3wM,1446
 vellum_cli/move.py,sha256=lCHQ-U4BspgS512GxFFvUrglitaHkWfuKn1Hpfcn7-Q,2053
@@ -14,7 +14,7 @@ vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 vellum_cli/tests/conftest.py,sha256=wx3PlJjVB0HRf5dr2b_idOIw27WPPl0J0FNbhIJJaVk,1689
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
 vellum_cli/tests/test_image_push.py,sha256=X0YOPdoaAnWtK9IQTxaN_wWpw08-5G3v76k1Wu53JpU,12801
-vellum_cli/tests/test_image_push_error_handling.py,sha256=QRH0eYNEEIkD2-EVFQWYexOKlhMB6puh1GouovrE-VU,7647
+vellum_cli/tests/test_image_push_error_handling.py,sha256=iKtbvii9sP1aFTlfm0fFBVeYltHf7RMGPPt_d4Te73A,10375
 vellum_cli/tests/test_init.py,sha256=C_rV4lu-ab5iFoLRizs1XAUnSPdMf7oFuc1i4N4udOU,18285
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_move.py,sha256=FIrL1xlH5oFKGX2MugcTKL8JilpopmUC7hP5OaqF5zw,5213
@@ -48,7 +48,7 @@ vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=z4oeTgKnMGV
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=9_AslWjzj4RHH2sq3SIaq9FU0NCg7ex5TIWrNMybqXg,2173
 vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=KA4U5NADWCBBbTG0f76OOFW9HvlWd5DfZoqN5Y0ZK9c,12167
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=m20_ZZ3Au0ZCpI3TNC9xh54ld1X13CNq-T51VOtP23k,6434
-vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=AW5JuHXtmtcJKeRiZKd7iB1re_D7G7jl_OlaZs8nUl0,4219
+vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=we7NENZpci-LiWXJFTPWzliCMdjzCMMMWUCfgJ-oP0g,4297
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=xMHaPfTSZWYprQenlHm2g47u0a5O9Me_dhAjfqo8nKQ,3116
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=6PcAFA_EJn7vEMdqgoRjYTLHwnXCrJv80B10zuUx4jE,1026
 vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=uo4YZRV48iX4peGAA1xkGniSPrepywvW_gS7codt-VQ,3378
@@ -93,7 +93,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_generic_node
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_guardrail_node_serialization.py,sha256=LnZp1YXDn-AaaxiYgxrhCQeH-rLgmlu_r_lvM65EQ5w,7517
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py,sha256=-A9CAnzIhPMn44l_dwZcofBXBPNFa-oHke9p0w3W5PA,26358
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_subworkflow_serialization.py,sha256=gn7kisqAEG9JCZ18V88qMGvlcsTulSwpWvvEwjCfh6Y,21871
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py,sha256=ALNOn5BdcWxw0myi6pXi5IwWtTE9H2CGrodP1BANuAg,16790
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py,sha256=I1Mlt2Iy88C98IpJ21jl4Xu7TtSHqyx_4A4bjJgTJUE,16990
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_merge_node_serialization.py,sha256=UnfWTfKN8DrOLpjCfWMgENJBjgNLWcRVfexbwERKY-c,8501
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_prompt_deployment_serialization.py,sha256=SGlBiwohTTuf7oXqO3R1lP6u7gPea8Elt1CpZU_W9Bk,21482
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_serialization.py,sha256=JKfYNBCmy7n6v2fd6NyYGHI1_TJRlfDNWiZMvHrdCWU,13079
@@ -110,6 +110,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=pLCyMScV88DTBXRH7jXaXOEA1GBq8NIipCUFwIAWnwI,2771
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=exT7U-axwtYgFylagScflSQLJEND51qIAx2UATju6JM,6023
 vellum_ee/workflows/display/tests/workflow_serialization/test_final_output_node_map_reference_serialization.py,sha256=vl3pxUJlrYRA8zzFJ-gRm7fe-5fviLNSIsUC7imnMqk,3502
+vellum_ee/workflows/display/tests/workflow_serialization/test_terminal_node_any_serialization.py,sha256=4WAmSEJZlDBLPhsD1f4GwY9ahB9F6qJKGnL6j7ZYlzQ,1740
 vellum_ee/workflows/display/tests/workflow_serialization/test_web_search_node_serialization.py,sha256=vbDFBrWUPeeW7cxjNA6SXrsHlYcbOAhlQ4C45Vdnr1c,3428
 vellum_ee/workflows/display/tests/workflow_serialization/test_workflow_input_parameterization_error.py,sha256=vAdmn3YTBDpo55znbydQxsgg9ASqHcvsUPwiBR_7wfo,1461
 vellum_ee/workflows/display/types.py,sha256=LgRIZeEtV7bQe-nvrC4A0T6vMooSWT1rFtw-uTn45BQ,3752
@@ -151,7 +152,7 @@ vellum_ee/workflows/tests/local_workflow/nodes/templating_node.py,sha256=NQwFN61
 vellum_ee/workflows/tests/local_workflow/workflow.py,sha256=A4qOzOPNwePYxWbcAgIPLsmrVS_aVEZEc-wULSv787Q,393
 vellum_ee/workflows/tests/test_display_meta.py,sha256=PkXJVnMZs9GNooDkd59n4YTBAX3XGPQWeSSVbhehVFM,5112
 vellum_ee/workflows/tests/test_registry.py,sha256=B8xRIuEyLWfSqrYoPldNQXhKPfe50PllvtAZoI8-uPs,6066
-vellum_ee/workflows/tests/test_serialize_module.py,sha256=d4ZpMd3oIxiq-sBXeSQESS6ix6-1P6rdCRFqBEReJIU,2882
+vellum_ee/workflows/tests/test_serialize_module.py,sha256=zleQTcGZa5_nzwu4zpFoqEHhk7pb64hGrhObR4anhPQ,4471
 vellum_ee/workflows/tests/test_server.py,sha256=dXFBraU99Y6cKp2aBhLFXQTScSRcE9WaWjo1z9piqdU,23344
 vellum_ee/workflows/tests/test_virtual_files.py,sha256=TJEcMR0v2S8CkloXNmCHA0QW0K6pYNGaIjraJz7sFvY,2762
 vellum/__init__.py,sha256=i7aah42VTp3735JX69uHUipLZBD8PwX_CXUY_9t-zuY,49356
@@ -159,7 +160,7 @@ vellum/client/README.md,sha256=flqu57ubZNTfpq60CdLtJC9gp4WEkyjb_n_eZ4OYf9w,6497
 vellum/client/__init__.py,sha256=rMnKRqL5-356SBc-rfm56MkO87PuAi2mtcfBszcJU1M,74316
 vellum/client/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 vellum/client/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-vellum/client/core/client_wrapper.py,sha256=YjwRn4-30uWxm0Owf9bmnnSrmjminxXkRvDqEYfProI,2840
+vellum/client/core/client_wrapper.py,sha256=EQroyMygQaKudbqG-NTWixPzjdmHV_wnRNH5sxTldIY,2840
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/force_multipart.py,sha256=awxh5MtcRYe74ehY8U76jzv6fYM_w_D3Rur7KQQzSDk,429
@@ -1813,7 +1814,7 @@ vellum/workflows/events/tests/test_basic_workflow.py,sha256=Pj6orHsXz37jWC5FARi0
 vellum/workflows/events/tests/test_event.py,sha256=jsC8APdrddLs5ejk9NO0waPLLslsJlBMIvN0M_vpAHI,19692
 vellum/workflows/events/types.py,sha256=mVrqAH9Hs9SpXm08Hcxdyap_ImQPwGsxRr56rSNMP34,5043
 vellum/workflows/events/workflow.py,sha256=kLSWFXiDZH0TELWoDjQ_kHVomFnw8MVVUPDGIzgyosw,8997
-vellum/workflows/exceptions.py,sha256=jyqfR-oq6iMAXSqaOexc-RjL1uFVEuxgcZ_r8AMaAn8,1463
+vellum/workflows/exceptions.py,sha256=nb05hAh-afzZ9hek7vhegq-zDtmHopv-4No3aZ-gKO4,1941
 vellum/workflows/executable.py,sha256=um-gLJMVYfGJwGJfZIPlCRHhHIYm6pn8PUEfeqrNx5k,218
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/accessor.py,sha256=3lu1-_-dBfZdJvtX-q66jbmRAZtqIfdsh_3_JNuzg1E,4462
@@ -1885,7 +1886,7 @@ vellum/workflows/nodes/bases/tests/test_base_adornment_node.py,sha256=fXZI9KqpS4
 vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=igJrcSxSZADk5tLpssAt0uAXe9oJoLbilzueJJvA5p4,10942
 vellum/workflows/nodes/core/__init__.py,sha256=5zDMCmyt1v0HTJzlUBwq3U9L825yZGZhT9JL18-mRR4,455
 vellum/workflows/nodes/core/error_node/__init__.py,sha256=g7RRnlHhqu4qByfLjBwCunmgGA8dI5gNsjS3h6TwlSI,60
-vellum/workflows/nodes/core/error_node/node.py,sha256=GpvvJS0F1TzOHFPRYJVQMYy96C_MCOeZGo_pzt63bfU,1357
+vellum/workflows/nodes/core/error_node/node.py,sha256=CwGMLIq6z_MogmjlicBLZm2pE7VW69ZL8fnJzNEVKHs,1451
 vellum/workflows/nodes/core/inline_subworkflow_node/__init__.py,sha256=nKNEH1QTl-1PcvmYoqSWEl0-t6gAur8GLTXHzklRQfM,84
 vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=N6Yh1z_xlZif9bBPmpwOC3xzxaru3_F5sbFaYHm2x3A,7222
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1928,14 +1929,14 @@ vellum/workflows/nodes/displayable/bases/tests/test_utils.py,sha256=eqdqbKNRWVMD
 vellum/workflows/nodes/displayable/bases/types.py,sha256=C37B2Qh2YP7s7pUjd-EYKc2Zl1TbnCgI_mENuUSb8bo,1706
 vellum/workflows/nodes/displayable/bases/utils.py,sha256=X1YSPmbBlxDrTAw6dy2-9HrIG8Vb_J-2k1lP3i-SOsk,6951
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
-vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=cCpZPna1Exw060KlI8j3oMCfru1GCzUFJz9ucWdcZVM,10311
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=t4AuqyGOSgitYUUs6Tqzo7lDeyOyJ5g8x7Q9j4UkH7M,10426
 vellum/workflows/nodes/displayable/code_execution_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/main.py,sha256=5QsbmkzSlSbcbWTG_JmIqcP-JNJzOPTKxGzdHos19W4,79
-vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py,sha256=1XadX-I240ghXDSLBejYfDNUpDZcdQbB6aroCHlIBt4,38285
-vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=GxSjRBiH8kNg2dXUVTtnX47fqPIFoGHxRB4ySU6uVPk,3225
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py,sha256=RQy7SsA39kTJAudzpYNN3jK_kuq6bWNZUld54H5pRZA,40966
+vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=0F_4PVvB7vjsV0RS48Brv_4djebWOMR_zgzHxzA9iV4,3308
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
-vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=71ZUNfTiD7t2Kai2ypw0tmv1lSf1brQaHAQD-SeUrGE,1101
+vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=2g32hWosE3zwVaK2UPFnVEer1Nbn04s3friF2rGztmE,1195
 vellum/workflows/nodes/displayable/conftest.py,sha256=K2kLM2JGAfcrmmd92u8DXInUO5klFdggPWblg5RVcx4,5729
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
 vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=1_F9S7w-gIEUoXIdilgpqDeCKxJ0_J0oTYvE35dbjHk,4908
@@ -1951,9 +1952,9 @@ vellum/workflows/nodes/displayable/inline_prompt_node/node.py,sha256=0O1dksk0h6-
 vellum/workflows/nodes/displayable/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py,sha256=bBHs90mV5SZ3rJPAL0wx4WWyawUA406LgMPOdvpZC_A,10923
 vellum/workflows/nodes/displayable/merge_node/__init__.py,sha256=J8IC08dSH7P76wKlNuxe1sn7toNGtSQdFirUbtPDEs0,60
-vellum/workflows/nodes/displayable/merge_node/node.py,sha256=nZtGGVAvY4fvGg8vwV6sTQ8_QLRnigeXt0vf2FL272A,450
+vellum/workflows/nodes/displayable/merge_node/node.py,sha256=_zHW9fReWdpiM3GiUzdEgyOSznRqkPsTj-XKD6Oja8I,563
 vellum/workflows/nodes/displayable/note_node/__init__.py,sha256=KWA3P4fyYJ-fOTky8qNGlcOotQ-HeHJ9AjZt6mRQmCE,58
-vellum/workflows/nodes/displayable/note_node/node.py,sha256=sIN1VBQ7zeT3GhN0kupXbFfdpvgedWV79k4woJNp5IQ,394
+vellum/workflows/nodes/displayable/note_node/node.py,sha256=aO54y6p5FjQe4XOSlQVRSVby4a5Ikp_ZS98GiNkM8Gs,507
 vellum/workflows/nodes/displayable/prompt_deployment_node/__init__.py,sha256=krX1Hds-TSVYZsx0wJFX4wsAKkEFYOX1ifwRGiIM-EA,82
 vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=XeBn6d3ce-RJuUiTwpDKUKUJvcYLQw61YufpIGVWPHY,2641
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -2018,7 +2019,7 @@ vellum/workflows/resolvers/resolver.py,sha256=yK-oY0HDsFJcjlNKAm3vpsPKRIFerIh59F
 vellum/workflows/resolvers/tests/test_resolver.py,sha256=jXkJBb9SwtoH__bBN-ECohpyD0aTIB9ErEvtFhuTMQM,9750
 vellum/workflows/resolvers/types.py,sha256=Hndhlk69g6EKLh_LYg5ILepW5U_h_BYNllfzhS9k8p4,237
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=uG2iu_rMwEApUFbhv4BPfD5-RwqASQmL_AAedOZr6eQ,41502
+vellum/workflows/runner/runner.py,sha256=-x4Ud63HwH81LufNJXzUDP1LTv6yJZ9bBG-OLkPRHMA,42299
 vellum/workflows/sandbox.py,sha256=mezSZmilR_fwR8164n8CEfzlMeQ55IqfapHp4ftImvQ,3212
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=m9fCqbZn21GshCVCjJTD1dPZEQjFrsMXqlg7tM9fIwM,24283
@@ -2053,17 +2054,17 @@ vellum/workflows/utils/tests/test_names.py,sha256=DnRRnuORxQXx9ESegCzkxiWcHy2_bB
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
 vellum/workflows/utils/tests/test_vellum_variables.py,sha256=X7b-bbN3bFRx0WG31bowcaOgsXxEPYnh2sgpsqgKIsQ,2096
 vellum/workflows/utils/uuids.py,sha256=IaZQANz7fhF7la0_J1O50Y6D2PIYv_taRDTRzBT9aWw,1284
-vellum/workflows/utils/vellum_variables.py,sha256=Tgv09yYROgq8QZbrKKIOEdg0IQ8Vfgz_vRjY4tYzaTQ,7152
+vellum/workflows/utils/vellum_variables.py,sha256=X3lZn-EoWengRWBWRhTNW7hqbj7LkV-6NSMwCskWEbg,7203
 vellum/workflows/utils/zip.py,sha256=HVg_YZLmBOTXKaDV3Xhaf3V6sYnfqqZXQ8CpuafkbPY,1181
 vellum/workflows/vellum_client.py,sha256=3iDR7VV_NgLSm1iZQCKDvrmfEaX1bOJiU15QrxyHpv0,1237
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=3fx2nq6TXRjut-kg5K7umX-IVuw3QhsTL_6orRm8pMk,29274
+vellum/workflows/workflows/base.py,sha256=gV3qMaN1hMNEoO3s1Q1G7lMeacTObYDs9LHEwXNTYHE,29819
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=Boa-_m9ii2Qsa1RvVM-VYniF7zCpzGgEGy-OnPZkrHg,23941
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.6.2.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.6.2.dist-info/METADATA,sha256=uLqOztz36EpdnTmgOFriqcWfXXxEkc5a8MctyqbVR5M,5547
-vellum_ai-1.6.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.6.2.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
-vellum_ai-1.6.2.dist-info/RECORD,,
+vellum_ai-1.6.4.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.6.4.dist-info/METADATA,sha256=kRTvoaljnXd0hIt_CQhEMNHXgv8YFwb5Momhc8sRRjY,5547
+vellum_ai-1.6.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.6.4.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
+vellum_ai-1.6.4.dist-info/RECORD,,

vellum_cli/image_push.py

@@ -123,6 +123,13 @@ def image_push_command(
                     suggestion="Make sure your VELLUM_API_KEY environment variable is set correctly.",
                 )
                 return
+            elif e.status_code == 400 and isinstance(e.body, dict) and "detail" in e.body:
+                handle_cli_error(
+                    logger,
+                    title="API request failed",
+                    message=e.body["detail"],
+                )
+                return
             elif e.status_code == 500:
                 handle_cli_error(
                     logger,
@@ -215,6 +222,13 @@ def image_push_command(
                 suggestion="Make sure your VELLUM_API_KEY environment variable is set correctly.",
             )
             return
+        elif e.status_code == 400 and isinstance(e.body, dict) and "detail" in e.body:
+            handle_cli_error(
+                logger,
+                title="API request failed",
+                message=e.body["detail"],
+            )
+            return
         elif e.status_code == 500:
             handle_cli_error(
                 logger,

vellum_cli/tests/test_image_push_error_handling.py

@@ -62,6 +62,37 @@ def test_image_push_docker_service_token_500_error(mock_docker_from_env, mock_ru
     assert "try again later" in result.output
 
 
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push_docker_service_token_400_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    mock_docker_client = mock_docker_from_env.return_value
+    mock_docker_client.images.get.return_value.id = "test-image-id"
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"Pruning successful"),
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+    ]
+
+    vellum_client.container_images.docker_service_token.side_effect = ApiError(
+        status_code=400,
+        body={
+            "detail": "Invalid image configuration: missing required metadata",
+        },
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest"])
+
+    assert result.exit_code == 1
+    assert "API request failed" in result.output
+    assert "Invalid image configuration: missing required metadata" in result.output
+
+
 @patch("subprocess.run")
 @patch("docker.from_env")
 def test_image_push_docker_service_token_other_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
@@ -156,6 +187,43 @@ def test_image_push_container_image_500_error(mock_docker_from_env, mock_run, ve
     assert "try again later" in result.output
 
 
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push_container_image_400_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    mock_docker_client = mock_docker_from_env.return_value
+    mock_docker_client.images.get.return_value.id = "test-image-id"
+    mock_docker_client.images.push.return_value = ["pushed"]
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"Pruning successful"),
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b'[{"RepoDigests": ["test-repo@sha256:abcd1234"]}]'),
+    ]
+
+    vellum_client.container_images.docker_service_token.return_value = type(
+        "obj", (object,), {"access_token": "345678mnopqr", "organization_id": str(uuid4()), "repository": "myrepo.net"}
+    )()
+
+    vellum_client.container_images.push_container_image.side_effect = ApiError(
+        status_code=400,
+        body={
+            "detail": "Image validation failed: unsupported architecture",
+        },
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest"])
+
+    assert result.exit_code == 1
+    assert "API request failed" in result.output
+    assert "Image validation failed: unsupported architecture" in result.output
+
+
 @patch("subprocess.run")
 @patch("docker.from_env")
 def test_image_push_container_image_other_error(mock_docker_from_env, mock_run, vellum_client, monkeypatch):

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

@@ -32,15 +32,6 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
 
         items = raise_if_descriptor(node.items)
 
-        items_node_input = create_node_input(
-            node_id=node_id,
-            input_name="items",
-            value=items or [],
-            display_context=display_context,
-            input_id=self.node_input_ids_by_name.get("items"),
-        )
-        node_inputs = [items_node_input]
-
         subworkflow_display = get_workflow_display(
             base_display_class=display_context.workflow_display_class,
             workflow_class=subworkflow,
@@ -58,6 +49,16 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
             for input_variable in input_variables
             if isinstance(input_variable, dict) and input_variable["key"] == "items"
         )
+
+        # Use the same ID for the map node's items input as the subworkflow's items input
+        items_node_input = create_node_input(
+            node_id=node_id,
+            input_name="items",
+            value=items or [],
+            display_context=display_context,
+            input_id=str(items_workflow_input_id),
+        )
+        node_inputs = [items_node_input]
         item_workflow_input_id = next(
             input_variable["id"]
             for input_variable in input_variables

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

@@ -81,7 +81,7 @@ def test_serialize_workflow():
             "type": "MAP",
             "inputs": [
                 {
-                    "id": "4c0a109f-599e-4d04-a396-a51474fc2996",
+                    "id": "0acef1e7-caa1-4d9f-bb69-6981729af18d",
                     "key": "items",
                     "value": {
                         "rules": [
@@ -393,3 +393,7 @@ def test_serialize_workflow():
             "workflow",
         ],
     }
+
+    # AND the map node's items input ID should match the subworkflow's items input ID
+    items_input_id = map_node["data"]["items_input_id"]
+    assert map_node["inputs"][0]["id"] == items_input_id

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

@@ -0,0 +1,49 @@
+from typing import Any
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    input: Any
+
+
+class AnyFinalOutputNode(FinalOutputNode[BaseState, Any]):
+    class Outputs(FinalOutputNode.Outputs):
+        value: Any = Inputs.input
+
+
+class AnyFinalOutputNodeWorkflow(BaseWorkflow[Inputs, BaseState]):
+    graph = AnyFinalOutputNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        value = AnyFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow_with_any_output_type():
+    """
+    Tests that a terminal node with Any output type can be serialized correctly.
+    """
+    # GIVEN a Workflow that uses a Final Output Node with Any type
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=AnyFinalOutputNodeWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    terminal_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL")
+    assert terminal_node["data"]["output_type"] == "JSON"
+
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert output_variables[0]["type"] == "JSON"

vellum_ee/workflows/tests/test_serialize_module.py

@@ -1,6 +1,25 @@
+import pytest
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
+@pytest.fixture
+def temp_module_path():
+    """Fixture to manage sys.path for temporary modules."""
+    temp_dir = tempfile.mkdtemp()
+    sys.path.insert(0, temp_dir)
+    try:
+        yield temp_dir
+    finally:
+        sys.path.remove(temp_dir)
+        shutil.rmtree(temp_dir)
+
+
 def test_serialize_module_with_dataset():
     """Test that serialize_module correctly serializes dataset from sandbox modules."""
     module_path = "tests.workflows.basic_inputs_and_outputs"
@@ -75,3 +94,37 @@ def test_serialize_module_includes_additional_files():
     assert "def helper_function():" in additional_files["helper.py"]
     assert "sample data file" in additional_files["data.txt"]
     assert "CONSTANT_VALUE" in additional_files["utils/constants.py"]
+
+
+def test_serialize_module__with_invalid_nested_set_graph(temp_module_path):
+    """
+    Tests that serialize_module raises a clear user-facing exception for workflows with nested sets in graph attribute.
+    """
+    module_dir = Path(temp_module_path) / "test_invalid_workflow"
+    module_dir.mkdir()
+
+    (module_dir / "__init__.py").write_text("")
+
+    workflow_content = """
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+
+class TestNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        value = "test"
+
+class InvalidWorkflow(BaseWorkflow):
+    graph = {TestNode, {TestNode}}
+
+    class Outputs(BaseWorkflow.Outputs):
+        result = TestNode.Outputs.value
+"""
+    (module_dir / "workflow.py").write_text(workflow_content)
+
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflowDisplay.serialize_module("test_invalid_workflow")
+
+    error_message = str(exc_info.value)
+    assert "Invalid graph structure detected" in error_message
+    assert "Nested sets or unsupported graph types are not allowed" in error_message
+    assert "contact Vellum support" in error_message