vellum-ai 0.14.47__py3-none-any.whl → 0.14.49__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.47",
+            "X-Fern-SDK-Version": "0.14.49",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

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

@@ -1,4 +1,5 @@
 import inspect
+import os
 from typing import Any, ClassVar, Dict, Generic, List, Optional, Sequence, Tuple, Type, TypeVar, cast, get_args
 
 from vellum import (
@@ -95,9 +96,9 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
 
     def run(self) -> Outputs:
         output_type = self.__class__.get_output_type()
-        code = self._resolve_code()
+        code, filepath = self._resolve_code()
         if not self.packages and self.runtime == "PYTHON_3_11_6":
-            logs, result = run_code_inline(code, self.code_inputs, output_type)
+            logs, result = run_code_inline(code, self.code_inputs, output_type, filepath)
             return self.Outputs(result=result, log=logs)
 
         else:
@@ -210,7 +211,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
 
         return compiled_inputs
 
-    def _resolve_code(self) -> str:
+    def _resolve_code(self) -> Tuple[str, str]:
         if self.code and self.filepath:
             raise NodeException(
                 message="Cannot specify both `code` and `filepath` for a CodeExecutionNode",
@@ -218,7 +219,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
             )
 
         if self.code:
-            return self.code
+            return self.code, f"{self.__class__.__name__}.code.py"
 
         if not self.filepath:
             raise NodeException(
@@ -235,4 +236,4 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
-        return code
+        return code, os.path.join(os.path.dirname(root), self.filepath)

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

@@ -850,7 +850,16 @@ def main(arg1: list) -> str:
         node.run()
 
     # AND the result should be the correct output
-    assert exc_info.value.message == "dict has no key: 'invalid'"
+    assert (
+        exc_info.value.message
+        == """\
+Traceback (most recent call last):
+  File "ExampleCodeExecutionNode.code.py", line 2, in main
+    return arg1["invalid"]
+
+AttributeError: dict has no key: 'invalid'
+"""
+    )
 
 
 def test_run_node__execute_code__value_key_access():
@@ -933,3 +942,105 @@ def main(output: list[str]) -> list[str]:
 
     # THEN the node should successfully access the string value
     assert outputs == {"result": ['{"foo": "bar"}', '{"foo2": "bar2"}'], "log": ""}
+
+
+def test_run_node__string_key_access_still_works():
+    # GIVEN a node that accesses the '0' index of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Any]):
+        code = """\
+def main(input: str) -> str:
+    return input[0]
+"""
+        code_inputs = {"input": "hello"}
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully access the string value
+    assert outputs == {"result": "h", "log": ""}
+
+
+def test_run_node__iter_list():
+    # GIVEN a node that will return the first string in a list
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = """\
+def main(
+    input_list: list
+) -> str:
+    return next((
+        o.value for o in input_list if o.type == "STRING"
+    ), None)
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {
+            "input_list": [
+                StringVellumValue(value="foo"),
+                NumberVellumValue(value=1),
+            ]
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully access the string value
+    assert outputs == {"result": "foo", "log": ""}
+
+
+def test_run_node__iter_dict():
+    # GIVEN a node that will return the first string in a list
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, list[str]]):
+        code = """\
+def main(input_dict: dict) -> list[str]:
+    return [item.value for item in input_dict]
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {
+            "input_dict": {
+                "foo": "bar",
+                "baz": "qux",
+            }
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully access the string value
+    assert outputs == {"result": ["bar", "qux"], "log": ""}
+
+
+def test_run_node__show_clearer_runtime_error_message():
+    # GIVEN a node that will return the first string in a list
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, list[str]]):
+        code = """\
+def main(items: list[str]) -> list[str]:
+    return first(items)
+
+# Helper function to prove out stack traces
+def first(items: list[str]) -> str:
+    return items[0]
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {"items": []}
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN the node should successfully access the string value
+    assert (
+        exc_info.value.message
+        == """\
+Traceback (most recent call last):
+  File "ExampleCodeExecutionNode.code.py", line 2, in main
+    return first(items)
+  File "ExampleCodeExecutionNode.code.py", line 6, in first
+    return items[0]
+
+IndexError: list index out of range
+"""
+    )

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

@@ -1,5 +1,7 @@
 import io
 import os
+import sys
+import traceback
 from typing import Any, Optional, Tuple, Union
 
 from pydantic import BaseModel
@@ -40,6 +42,7 @@ def run_code_inline(
     code: str,
     inputs: EntityInputsInterface,
     output_type: Any,
+    filepath: str,
 ) -> Tuple[str, Any]:
     log_buffer = io.StringIO()
 
@@ -75,11 +78,29 @@ def run_code_inline(
 __arg__out = main({", ".join(run_args)})
 """
     try:
-        exec(execution_code, exec_globals)
+        compiled_code = compile(execution_code, filepath, "exec")
+        exec(compiled_code, exec_globals)
     except Exception as e:
+        lines = code.splitlines()
+        _, _, tb = sys.exc_info()
+        tb_generator = traceback.walk_tb(tb)
+        stack = traceback.StackSummary.extract(tb_generator)
+
+        # Filter stack to only include frames from the user's code file, and omit the first one
+        filtered_stack = traceback.StackSummary.from_list([frame for frame in stack if frame.filename == filepath][1:])
+        for frame in filtered_stack:
+            if not frame.line and frame.lineno and frame.lineno <= len(lines):
+                # Mypy doesn't like us setting private attributes
+                frame._line = lines[frame.lineno - 1]  # type: ignore[attr-defined]
+
+        error_message = f"""\
+Traceback (most recent call last):
+{''.join(filtered_stack.format())}
+{e.__class__.__name__}: {e}
+"""
         raise NodeException(
             code=WorkflowErrorCode.INVALID_CODE,
-            message=str(e),
+            message=error_message,
         )
 
     logs = log_buffer.getvalue()

vellum/workflows/types/code_execution_node_wrappers.py

@@ -2,7 +2,7 @@ class StringValueWrapper(str):
     def __getitem__(self, key):
         if key == "value":
             return self
-        raise KeyError(key)
+        return super().__getitem__(key)
 
     def __getattr__(self, attr):
         if attr == "value":
@@ -23,6 +23,10 @@ class ListWrapper(list):
             return self
         raise AttributeError(f"'list' object has no attribute '{attr}'")
 
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self[i]
+
 
 class DictWrapper(dict):
     """
@@ -52,11 +56,15 @@ class DictWrapper(dict):
     def __setattr__(self, name, value):
         self[name] = value
 
+    def __iter__(self):
+        for key in super().keys():
+            yield self[key]
+
 
 def clean_for_dict_wrapper(obj):
     if isinstance(obj, dict):
         wrapped = DictWrapper(obj)
-        for key in wrapped:
+        for key in wrapped.keys():
             wrapped[key] = clean_for_dict_wrapper(wrapped[key])
 
         return wrapped

{vellum_ai-0.14.47.dist-info → vellum_ai-0.14.49.dist-info}/METADATA

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

{vellum_ai-0.14.47.dist-info → vellum_ai-0.14.49.dist-info}/RECORD

@@ -1,9 +1,9 @@
 vellum_cli/CONTRIBUTING.md,sha256=FtDC7BGxSeMnwCXAUssFsAIElXtmJE-O5Z7BpolcgvI,2935
 vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
-vellum_cli/__init__.py,sha256=7aO9XFnaEVRiVshn86cFudebFUccT-gV8xIARJWqKYo,12257
+vellum_cli/__init__.py,sha256=sCNP_hmFCexEWp1oQdpj8QsIUiAbo4MIlTalZEFruD8,12398
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
 vellum_cli/config.py,sha256=v5BmZ-t_v4Jmqd7KVuQMZF2pRI-rbMspSkVYXIRoTmI,9448
-vellum_cli/image_push.py,sha256=8DDvRDJEZ-FukUCqGW1827bg1ybF4xBbx9WyqWYQE-g,6816
+vellum_cli/image_push.py,sha256=skFXf25ixMOX1yfcyAtii-RivYYv-_hsv-Z-bVB6m5Q,7380
 vellum_cli/init.py,sha256=WpnMXPItPmh0f0bBGIer3p-e5gu8DUGwSArT_FuoMEw,5093
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
 vellum_cli/ping.py,sha256=p_BCCRjgPhng6JktuECtkDQLbhopt6JpmrtGoLnLJT8,1161
@@ -12,7 +12,7 @@ vellum_cli/push.py,sha256=nWHLDi_w0LXycNkVv00CiNwY469BcTNBn7NphWpCA7E,9711
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=AFYZryKA2qnUuCPBxBKmHLFoPiE0WhBFFej9tNwSHdc,1526
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
-vellum_cli/tests/test_image_push.py,sha256=i3lJuW8nFRwL1M1OF6752IZYvGAFgKmkB2hd_rYlsmg,2028
+vellum_cli/tests/test_image_push.py,sha256=QM-JlR_aJappvwbCLteQZZf76sd7SE1sRj3armvFK-I,5706
 vellum_cli/tests/test_init.py,sha256=8UOc_ThfouR4ja5cCl_URuLk7ohr9JXfCnG4yka1OUQ,18754
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_ping.py,sha256=3ucVRThEmTadlV9LrJdCCrr1Ofj3rOjG6ue0BNR2UC0,2523
@@ -26,7 +26,7 @@ vellum_ee/workflows/display/base.py,sha256=EqlQFD56kpqMY02ZBJBQajzJKh33Dwi60Wo77
 vellum_ee/workflows/display/editor/__init__.py,sha256=MSAgY91xCEg2neH5d8jXx5wRdR962ftZVa6vO9BGq9k,167
 vellum_ee/workflows/display/editor/types.py,sha256=x-tOOCJ6CF4HmiKDfCmcc3bOVfc1EBlP5o6u5WEfLoY,567
 vellum_ee/workflows/display/nodes/__init__.py,sha256=jI1aPBQf8DkmrYoZ4O-wR1duqZByOf5mDFmo_wFJPE4,307
-vellum_ee/workflows/display/nodes/base_node_display.py,sha256=FGoFpqawVf7mPbMFDZdL9p3qy951Y1RZq8No9NQ8p8Y,15213
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=1VoNyAw9MzgGePI2wrOShsNccrbS4bTuu3bnTii0Wu4,15480
 vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=gKAZfc7JBLzcwYPchnpHy2nMVMPmltAszOwLyXDrro0,2085
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/tests/test_base_node_display.py,sha256=Z4Mf7xLCNiblSbpKI0BrV5modQr-ZcFzhfir_OSyTTs,2997
@@ -35,12 +35,12 @@ vellum_ee/workflows/display/nodes/utils.py,sha256=sloya5TpXsnot1HURc9L51INwflRqU
 vellum_ee/workflows/display/nodes/vellum/__init__.py,sha256=nUIgH2s0-7IbQRNrBhLPyRNe8YIrx3Yo9HeeW-aXXFk,1668
 vellum_ee/workflows/display/nodes/vellum/api_node.py,sha256=ZiOJsSovftbH1eVFdU0-UE4DUliIHPQZkwrFcooN-Vk,8856
 vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py,sha256=rJbHZBg9A_v2bjk-R6MfWzShcrS2gcKIOyYGoqwTx8s,6353
-vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=yWYK3bOK1hNt5jvqzSwUy4RwCHCP3lHYSU1jum7zxO8,4561
+vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=L308T4U6eaL0WUJ_hQ0qrH-i8IuMBCm5XjRO2_b-Mro,4507
 vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=MrvyiYD0qgQf3-ZYFcurQtin3FagAHGRoT7zYGiIao0,11150
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=m2DmOXm9-jiiIl6zwkXHNfsYp5PTpBHEdt5xaIsabWo,2363
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=jUDI2FwVaw0Or4zJL58J_g0S--i59Hzik60s_Es_M-8,3098
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=5_5D5PMzBOeUdVtRlANbfEsu7Gv3r37dLvpfjGAqYac,2330
-vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=mIwK1gwW7ljrN3dEVCsZlvaGVZhdlbS-hXCMgPf6Ebw,10362
+vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=gVwQwycEPNtCs8tWbFyIMLpCA7zXnqcmuuhFqRWNxZM,10368
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=fQV5o83BPTwGX6o-ThN4r7BcIhySyqwpW1JGYWpvSJI,5625
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=CiklGf5_tDbqE1XQm2mnbtoL01_2JYjcnB4FDTpMImQ,3824
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=yBWeN4T_lOsDVnNOKWRiT7JYKu0IR5Fx2z99iq6QKSA,3273
@@ -51,11 +51,11 @@ vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=3n1qa-zWIk0p_H94u
 vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=MWLZBXHsmj5vKgqOgI2HHcHAJzLS0sqybn6idhwug8Y,2669
 vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=J84_EUfwWwpeOfUFBdRorrD1Bod0jDBFdQ6xnRyp9Ho,3338
 vellum_ee/workflows/display/nodes/vellum/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py,sha256=-b09X3dgtRxnAuqMTp_q3T_tfE_3lRGkgohWmy8w9lE,3880
+vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py,sha256=ZasoqG8FmqnZDj2FfL5BGPq9fafOTJqV_4xjOKLi1gc,5434
 vellum_ee/workflows/display/nodes/vellum/tests/test_error_node.py,sha256=540FoWMpJ3EN_DPjHsr9ODJWCRVcUa5hZBn-5T2GiHU,1665
 vellum_ee/workflows/display/nodes/vellum/tests/test_note_node.py,sha256=uiMB0cOxKZzos7YKnj4ef4DFa2bOvZJWIv-hfbUV6Go,1218
 vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_deployment_node.py,sha256=G-qJyTNJkpqJiEZ3kCJl86CXJINLeFyf2lM0bQHCCOs,3822
-vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py,sha256=94ab2dL1adN4ScPxoX3TiYvMguBn0OmwFRq2oCzs7mQ,7468
+vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py,sha256=RPpromm0y9y-MukL8cmxpl9hYaw-JuNo8vFDOcLI4V4,8801
 vellum_ee/workflows/display/nodes/vellum/tests/test_retry_node.py,sha256=h93ysolmbo2viisyhRnXKHPxiDK0I_dSAbYoHFYIoO4,1953
 vellum_ee/workflows/display/nodes/vellum/tests/test_subworkflow_deployment_node.py,sha256=BUzHJgjdWnPeZxjFjHfDBKnbFjYjnbXPjc-1hne1B2Y,3965
 vellum_ee/workflows/display/nodes/vellum/tests/test_templating_node.py,sha256=LSk2gx9TpGXbAqKe8dggQW8yJZqj-Cf0EGJFeGGlEcw,3321
@@ -69,7 +69,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/__init__.py,sha256=47DE
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py,sha256=XOQDDRiG46etxTC7-_RUEutoNumXc02fo7oho4GYM0c,1900
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py,sha256=tsjGM-jOurPSkDIbrDFdjNLmkI1fPNPAw3J9-l9knCw,12848
-vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py,sha256=m9KpVN55_bHiooZOJLm7doRewhcTK53weVYRiglCJX0,19578
+vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py,sha256=rV7_NOUIsyHUrdSJ0pJFt7ha-uIC1nSLqdYpRhE9Zfg,21430
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_outputs_serialization.py,sha256=s6_mnk0pkztU59wYpSfOFpMhAJaRjmyfxM6WJGtnD4Y,6456
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_ports_serialization.py,sha256=PkSgghJDz0fpDB72HHPjLjo8LkZk-HpUkCQzRLX-iVw,40611
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_trigger_serialization.py,sha256=dsJr8I9AdPwMOGszirfNDzZP2Ychd94aAKuPXAzknMk,4632
@@ -94,14 +94,14 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_n
 vellum_ee/workflows/display/types.py,sha256=i4T7ElU5b5h-nA1i3scmEhO1BqmNDc4eJDHavATD88w,2821
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/exceptions.py,sha256=LSwwxCYNxFkf5XMUcFkaZKpQ13OSrI7y_bpEUwbKVk0,169
-vellum_ee/workflows/display/utils/expressions.py,sha256=voNX6ZLuLIVu8cCjqASrSnlCZuUL9TVbWkWD6zAMmnE,10644
+vellum_ee/workflows/display/utils/expressions.py,sha256=gbc_UDogJEI1juSNPfR3a-OXu2sIH7w3vLLw4YjOqDc,12416
 vellum_ee/workflows/display/utils/registry.py,sha256=fWIm5Jj-10gNFjgn34iBu4RWv3Vd15ijtSN0V97bpW8,1513
-vellum_ee/workflows/display/utils/vellum.py,sha256=HDe1vtIaU35OEg4oC1KC6WNwhw5Laf_mNURorzbeutQ,5418
+vellum_ee/workflows/display/utils/vellum.py,sha256=mtoXmSYwR7rvrq-d6CzCW_auaJXTct0Mi1F0xpRCiNQ,5627
 vellum_ee/workflows/display/vellum.py,sha256=o7mq_vk2Yapu9DDKRz5l76h8EmCAypWGQYe6pryrbB8,3576
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
 vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=NuWlnGNe3Htcfh-l_8e37uitdUsy6WZNB7W7dYcCoUg,33355
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=gxz76AeCqgAZ9D2lZeTiZzxY9eMgn3qOSfVgiqYcOh8,2028
-vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=U0LsUqjJ-5qrkqgFsvdWzqWX7OHEMzsDCWrXR1xyzp0,15599
+vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=gTKddCTGzjWHJ8v4E0XqCLgxKuSXaFveoN2IT1LxrPw,29472
 vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=aaKdmWrgEe5YyV4zuDY_4E3y-l59rIHQnNGiPj2OWxQ,359
 vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/server/virtual_file_loader.py,sha256=7JphJcSO3H85qiC2DpFfBWjC3JjrbRmoynBC6KKHVsA,2710
@@ -132,7 +132,7 @@ vellum/client/README.md,sha256=qmaVIP42MnxAu8jV7u-CsgVFfs3-pHQODrXdZdFxtaw,4749
 vellum/client/__init__.py,sha256=PEnFl7LbXQcvAi3bVN2qyt5xm2FtVtq7xWKkcWM3Tg4,120166
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=2b05KSUjKpa8HkExXYFatDZrzBB_PJoTnvwdO0cZNvc,1869
+vellum/client/core/client_wrapper.py,sha256=fgLMgzbjkk4zz3CHZ_Wdqz6Sz1JL4L0v7uiNheKIcZA,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/http_client.py,sha256=Z77OIxIbL4OAB2IDqjRq_sYa5yNYAWfmdhdCSSvh6Y4,19552
@@ -1587,12 +1587,12 @@ 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=ckMUenSsNkiYmSw6FmjSMHYaCk8Y8_sUjL6lkFFEqts,5412
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
-vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=Ko_Dy17AjfSx2A4u5Xno5R0KH2p5akEHq8L0rQkySGs,9576
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=U21jXW8XZoC51vP0pvbbUQzQidR6Ej2lMdGypIUyF3I,9708
 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_code_execution_node.py,sha256=Vl4huLXAQNNveDJTg1HF-scxbBVNuuElDUn-IRB6pkg,28343
-vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=oCI8HS_Y-hsNhvGIC8HgbIzKIZeWOkXMLaknDRf-qus,2928
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=N5SZeYyxEDrkbTagEvbnsTLgOeqrYEfIUOheM5qgjiU,31423
+vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=VRTKms59vrSR9mDk99cojParZVAP4lzjEeDwDNXU1tk,3837
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
 vellum/workflows/nodes/displayable/conftest.py,sha256=K2kLM2JGAfcrmmd92u8DXInUO5klFdggPWblg5RVcx4,5729
@@ -1676,7 +1676,7 @@ vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVik6ZVTfVOA,1826
 vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83yc5FIM33zuo8,353
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
-vellum/workflows/types/code_execution_node_wrappers.py,sha256=li3EuMWq6s3QrZ63Z36kSsvJudWjIwTVpBrZ594LVJ8,2169
+vellum/workflows/types/code_execution_node_wrappers.py,sha256=zPnfvhxpDS3vvM6hX1X6sPfvo1bu1kcPQfhNoJD9vtM,2362
 vellum/workflows/types/core.py,sha256=kMQremh_I8egXpiKmtMQbB6e3OczAWiRnnTq5V6xlD0,928
 vellum/workflows/types/definition.py,sha256=z81CL_u0FJol-9yUIqoXNTYAARtU8x__c6s-f4rb5c8,2335
 vellum/workflows/types/generics.py,sha256=tKXz0LwWJGKw1YGudyl9_yFDrRgU6yYV1yJV1Zv-LTw,1430
@@ -1701,8 +1701,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=8P5YIsNMO78_CR1NNK6wkEdkMB4b3Q_Ni1qxh78OnHo,20481
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.47.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.47.dist-info/METADATA,sha256=ljQBBvIKHzaM01hSSpxXWdIyQPl4GpYpLimvOm1lxCw,5484
-vellum_ai-0.14.47.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.47.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.47.dist-info/RECORD,,
+vellum_ai-0.14.49.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.49.dist-info/METADATA,sha256=UnFisKY5VZ2o5md6oV2OU-gTx6Y24oQd4u5Bv_rJfag,5484
+vellum_ai-0.14.49.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.49.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.49.dist-info/RECORD,,

vellum_cli/__init__.py

@@ -354,9 +354,10 @@ def images() -> None:
     help="Tags the provided image inside of Vellum's repo. "
     "This field does not push multiple local tags of the passed in image.",
 )
-def image_push(image: str, tag: Optional[List[str]] = None) -> None:
+@click.option("--workspace", type=str, help="The specific Workspace config to use when pushing")
+def image_push(image: str, tag: Optional[List[str]] = None, workspace: Optional[str] = None) -> None:
     """Push Docker image to Vellum"""
-    image_push_command(image, tag)
+    image_push_command(image, tag, workspace)
 
 
 @workflows.command(name="init")

vellum_cli/image_push.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 import re
 import subprocess
 from typing import List, Optional
@@ -9,15 +10,26 @@ from docker import DockerClient
 from dotenv import load_dotenv
 
 from vellum.workflows.vellum_client import create_vellum_client, create_vellum_environment
+from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, load_vellum_cli_config
 from vellum_cli.logger import load_cli_logger
 
 _SUPPORTED_ARCHITECTURE = "amd64"
 
 
-def image_push_command(image: str, tags: Optional[List[str]] = None) -> None:
-    load_dotenv()
+def image_push_command(image: str, tags: Optional[List[str]] = None, workspace: Optional[str] = None) -> None:
+    load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
     logger = load_cli_logger()
-    vellum_client = create_vellum_client()
+    config = load_vellum_cli_config()
+    workspace_config = next((w for w in config.workspaces if w.name == workspace), DEFAULT_WORKSPACE_CONFIG)
+
+    api_key = os.getenv(workspace_config.api_key, None)
+    if not api_key:
+        raise ValueError(f"API key {workspace_config.api_key} for workspace {workspace} not found")
+
+    vellum_client = create_vellum_client(
+        api_key=api_key,
+        api_url=workspace_config.api_url,
+    )
 
     # Check if we are self hosted by looking at our base url
     api_url = create_vellum_environment().default

vellum_cli/tests/test_image_push.py

@@ -1,16 +1,37 @@
+import pytest
+import json
+import os
+import shutil
 import subprocess
+import tempfile
 from unittest.mock import MagicMock, patch
+from uuid import uuid4
+from typing import Generator
 
 from click.testing import CliRunner
+from httpx import Response
 
 from vellum_cli import main as cli_main
 
 
+@pytest.fixture
+def mock_temp_dir() -> Generator[str, None, None]:
+    current_dir = os.getcwd()
+    temp_dir = tempfile.mkdtemp()
+    os.chdir(temp_dir)
+
+    yield temp_dir
+
+    os.chdir(current_dir)
+    shutil.rmtree(temp_dir)
+
+
 @patch("subprocess.run")
 @patch("docker.from_env")
 def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
     # GIVEN a self hosted vellum api URL env var
     monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
 
     # Mock Docker client
     mock_docker_client = MagicMock()
@@ -35,6 +56,94 @@ def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vell
     assert "Image successfully pushed" in result.output
 
 
+@patch("subprocess.run")
+@patch("docker.from_env")
+def test_image_push__self_hosted_happy_path__workspace_option(
+    mock_docker_from_env, mock_run, mock_httpx_transport, mock_temp_dir
+):
+    # GIVEN a workspace config with a new env for url
+    with open(os.path.join(mock_temp_dir, "vellum.lock.json"), "w") as f:
+        f.write(
+            json.dumps(
+                {
+                    "workspaces": [
+                        {
+                            "name": "my_workspace",
+                            "api_url": "MY_WORKSPACE_VELLUM_API_URL",
+                            "api_key": "MY_WORKSPACE_VELLUM_API_KEY",
+                        }
+                    ]
+                }
+            )
+        )
+
+    # AND a .env file with the workspace api key and url
+    with open(os.path.join(mock_temp_dir, ".env"), "w") as f:
+        f.write(
+            "VELLUM_API_KEY=123456abcdef\n"
+            "VELLUM_API_URL=https://api.vellum.ai\n"
+            "MY_WORKSPACE_VELLUM_API_KEY=789012ghijkl\n"
+            "MY_WORKSPACE_VELLUM_API_URL=https://api.vellum.mycompany.ai\n"
+        )
+
+    # AND the Docker client returns the correct response
+    mock_docker_client = MagicMock()
+    mock_docker_from_env.return_value = mock_docker_client
+
+    mock_run.side_effect = [
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"sha256:hellosha"),
+    ]
+
+    # AND the vellum client returns the correct response for
+    mock_httpx_transport.handle_request.side_effect = [
+        # First call to get the docker service token
+        Response(
+            status_code=200,
+            text=json.dumps(
+                {
+                    "access_token": "345678mnopqr",
+                    "organization_id": str(uuid4()),
+                    "repository": "myrepo.net",
+                }
+            ),
+        ),
+        # Second call to push the image
+        Response(
+            status_code=200,
+            text=json.dumps(
+                {
+                    "id": str(uuid4()),
+                    "name": "myrepo.net/myimage",
+                    "visibility": "PRIVATE",
+                    "created": "2021-01-01T00:00:00Z",
+                    "modified": "2021-01-01T00:00:00Z",
+                    "repository": "myrepo.net",
+                    "sha": "sha256:hellosha",
+                    "tags": [],
+                }
+            ),
+        ),
+    ]
+
+    # WHEN the user runs the image push command
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myrepo.net/myimage:latest", "--workspace", "my_workspace"])
+
+    # THEN the command exits successfully
+    assert result.exit_code == 0, (result.output, str(result.exception))
+
+    # AND gives the success message
+    assert "Image successfully pushed" in result.output
+
+    # AND the vellum client was called with the correct api key and url
+    request = mock_httpx_transport.handle_request.call_args[0][0]
+    assert request.headers["X-API-KEY"] == "789012ghijkl", result.stdout
+    assert str(request.url) == "https://api.vellum.mycompany.ai/v1/container-images/push"
+
+
 @patch("subprocess.run")
 @patch("docker.from_env")
 def test_image_push__self_hosted_blocks_repo(mock_docker_from_env, mock_run, vellum_client, monkeypatch):

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -260,10 +260,15 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
     def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
         unadorned_node = get_unadorned_node(self._node)
-        default_port = unadorned_node.Ports.default
+        default_port = next((port for port in unadorned_node.Ports if port.default), None)
+        if default_port in port_displays:
+            return port_displays[default_port].id
 
-        default_port_display = port_displays[default_port]
-        return default_port_display.id
+        first_port = next((port for port in unadorned_node.Ports), None)
+        if not first_port:
+            raise ValueError(f"Node {self._node.__name__} must have at least one port.")
+
+        return port_displays[first_port].id
 
     def get_trigger_id(self) -> UUID:
         return self.get_target_handle_id()

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

@@ -79,8 +79,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
 
         packages = raise_if_descriptor(node.packages)
 
-        _, output_display = display_context.global_node_output_displays[node.Outputs.result]
-        _, log_output_display = display_context.global_node_output_displays[node.Outputs.log]
+        output_display = self.output_display[node.Outputs.result]
+        log_output_display = self.output_display[node.Outputs.log]
 
         output_type = primitive_type_to_vellum_variable_type(node.get_output_type())
 

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

@@ -32,7 +32,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         output_display = self.output_display[node.Outputs.text]
         array_display = self.output_display[node.Outputs.results]
         json_display = self.output_display[node.Outputs.json]
-        node_blocks = raise_if_descriptor(node.blocks)
+        node_blocks = raise_if_descriptor(node.blocks) or []
         function_definitions = raise_if_descriptor(node.functions)
 
         ml_model = str(raise_if_descriptor(node.ml_model))

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

@@ -2,7 +2,9 @@ import pytest
 from uuid import UUID
 from typing import Type
 
+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.nodes.vellum.code_execution_node import BaseCodeExecutionNodeDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
@@ -110,3 +112,44 @@ def test_serialize_node__code_node_inputs(GetDisplayClass, expected_input_id):
             },
         },
     ]
+
+
+def test_serialize_node__with_unresolved_secret_references(vellum_client):
+    # GIVEN a node has access to a secret reference
+    class MyNode(CodeExecutionNode):
+        code_inputs = {"api_key": VellumSecretReference("MY_API_KEY")}
+
+    # AND the secret is not found
+    vellum_client.workspace_secrets.retrieve.side_effect = ApiError(
+        status_code=404,
+        body="Secret not found",
+    )
+
+    # AND a workflow with the code node
+    class Workflow(BaseWorkflow):
+        graph = MyNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    data: dict = workflow_display.serialize()
+
+    # THEN the condition should be serialized correctly
+    node = next(node for node in data["workflow_raw_data"]["nodes"] if node["type"] == "CODE_EXECUTION")
+    assert node["inputs"][0]["value"] == {
+        "combinator": "OR",
+        "rules": [
+            {
+                "type": "WORKSPACE_SECRET",
+                "data": {
+                    "type": "STRING",
+                    "workspace_secret_id": None,
+                },
+            }
+        ],
+    }
+
+    # AND we should have a warning of the invalid reference
+    # TODO: Come up with a proposal for how nodes should propagate warnings
+    # warnings = list(workflow_display.errors)
+    # assert len(warnings) == 1
+    # assert "Failed to resolve secret reference 'MY_API_KEY'" in str(warnings[0])

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

@@ -6,6 +6,7 @@ from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState
 from vellum_ee.workflows.display.nodes.vellum.inline_prompt_node import BaseInlinePromptNodeDisplay
@@ -215,3 +216,33 @@ def test_serialize_node__unreferenced_variable_block__still_serializes():
     # warnings = list(workflow_display.errors)
     # assert len(warnings) == 1
     # assert "Missing input variable 'foo' for prompt block 0" in str(warnings[0])
+
+
+def test_serialize_node__port_groups():
+    # GIVEN a prompt node with ports
+    class MyPromptNode(InlinePromptNode):
+        class Ports(InlinePromptNode.Ports):
+            apple = Port.on_if(LazyReference(lambda: MyPromptNode.Outputs.text).equals("apple"))
+            banana = Port.on_if(LazyReference(lambda: MyPromptNode.Outputs.text).equals("banana"))
+
+    # AND a workflow with the prompt node
+    class MyWorkflow(BaseWorkflow):
+        graph = MyPromptNode
+
+    # WHEN the prompt node is serialized
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should have the ports serialized
+    my_prompt_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["id"] == str(MyPromptNode.__id__)
+    )
+    ports = my_prompt_node["ports"]
+    assert len(ports) == 2
+    assert ports[0]["id"] == "149d97a4-3da3-44a9-95f7-ea7b8d38b877"
+    assert ports[1]["id"] == "71f2d2b3-194f-4492-bc1c-a5ca1f60fb0a"
+    assert ports[0]["name"] == "apple"
+    assert ports[1]["name"] == "banana"
+
+    # AND the legacy source_handle_id should be the default port
+    assert my_prompt_node["data"]["source_handle_id"] == "149d97a4-3da3-44a9-95f7-ea7b8d38b877"

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

@@ -1,4 +1,3 @@
-import pytest
 from uuid import uuid4
 from typing import List
 
@@ -257,11 +256,58 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
 
     # WHEN the workflow is serialized
     workflow_display = get_workflow_display(workflow_class=Workflow)
-    with pytest.raises(Exception) as exc_info:
-        workflow_display.serialize()
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the attribute reference
+    generic_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["id"] == str(GenericNode.__id__)
+    )
 
-    # THEN we should raise a user facing error
-    assert str(exc_info.value) == "Failed to serialize attribute 'attr': Nested references are not supported."
+    assert not DeepDiff(
+        {
+            "id": "11be9d37-0069-4695-a317-14a3b6519d4e",
+            "label": "test_serialize_node__workflow_input_as_nested_chat_history.<locals>.GenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "GenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "d4548468-85a4-449e-92e0-e2d8b8fd097c", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "c4a9a57d-1380-4689-8500-e8a0b6477291", "name": "default", "type": "DEFAULT"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "e878bbc9-1231-461e-9e9d-947604da116e",
+                    "name": "attr",
+                    "value": {
+                        "type": "DICTIONARY_REFERENCE",
+                        "entries": [
+                            {
+                                "key": "hello",
+                                "value": {
+                                    "type": "WORKFLOW_INPUT",
+                                    "input_variable_id": "f727c3f9-f27f-4ac9-abd7-12bf612a094e",
+                                },
+                            }
+                        ],
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        generic_node,
+        ignore_order=True,
+    )
 
 
 def test_serialize_node__node_output(serialize_node):

vellum_ee/workflows/display/utils/expressions.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Dict, cast
 
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -37,7 +37,7 @@ from vellum.workflows.references.output import OutputReference
 from vellum.workflows.references.state_value import StateValueReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
-from vellum.workflows.types.core import JsonObject
+from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
 
 if TYPE_CHECKING:
@@ -235,8 +235,54 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
             "node_id": str(node_class_display.node_id),
         }
 
-    if isinstance(value, dict) and any(isinstance(v, BaseDescriptor) for v in value.values()):
-        raise ValueError("Nested references are not supported.")
+    if isinstance(value, list):
+        serialized_items = [serialize_value(display_context, item) for item in value]
+        if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
+            constant_values = []
+            for item in serialized_items:
+                item_dict = cast(Dict[str, Any], item)
+                value_inner = item_dict["value"]
+
+                if value_inner["type"] == "JSON" and "items" in value_inner:
+                    # Nested JSON list
+                    constant_values.append(value_inner["items"])
+                else:
+                    constant_values.append(value_inner["value"])
+
+            return {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "JSON",
+                    "items": constant_values,
+                },
+            }
+        else:
+            return {
+                "type": "ARRAY_REFERENCE",
+                "items": cast(JsonArray, serialized_items),  # list[JsonObject] -> JsonArray
+            }
+
+    if isinstance(value, dict):
+        serialized_entries = [
+            {"key": key, "value": serialize_value(display_context, val)} for key, val in value.items()
+        ]
+
+        # Check if all entries have constant values
+        if all(entry["value"]["type"] == "CONSTANT_VALUE" for entry in serialized_entries):
+            constant_entries = {}
+            for entry in serialized_entries:
+                entry_value = entry["value"]["value"]
+                constant_entries[entry["key"]] = entry_value["value"]
+
+            return {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "JSON",
+                    "value": constant_entries,
+                },
+            }
+        else:
+            return {"type": "DICTIONARY_REFERENCE", "entries": cast(JsonArray, serialized_entries)}
 
     if not isinstance(value, BaseDescriptor):
         vellum_value = primitive_to_vellum_value(value)

vellum_ee/workflows/display/utils/vellum.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
+from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.array_vellum_value import ArrayVellumValue
 from vellum.client.types.vellum_value import VellumValue
@@ -117,13 +118,18 @@ def create_node_input_value_pointer_rule(
         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):
-        workspace_secret = display_context.client.workspace_secrets.retrieve(
-            id=value.name,
-        )
+        try:
+            workspace_secret = display_context.client.workspace_secrets.retrieve(
+                id=value.name,
+            )
+            workspace_secret_id: Optional[str] = str(workspace_secret.id)
+        except ApiError:
+            workspace_secret_id = None
+
         return WorkspaceSecretPointer(
             data=WorkspaceSecretData(
                 type="STRING",
-                workspace_secret_id=str(workspace_secret.id),
+                workspace_secret_id=workspace_secret_id,
             ),
         )
     if isinstance(value, ExecutionCountReference):

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

@@ -425,3 +425,349 @@ def test_serialize_workflow__nested_lazy_reference():
         "node_id": str(OuterNode.__id__),
         "node_output_id": str(OuterNode.__output_ids__["bar"]),
     }
+
+
+def test_serialize_workflow__array_values():
+    # GIVEN a node with array and nested array values
+    class MyNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            array_value = ["item1", "item2", "item3"]
+            nested_array_value = [["item1", "item2", "item3"], ["item4", "item5", "item6"]]
+            mixed_array_value = [["item1"], "item2", "item3"]
+
+    # AND a workflow that uses these outputs
+    class MyWorkflow(BaseWorkflow):
+        graph = MyNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            array_output = MyNode.Outputs.array_value
+            nested_array_output = MyNode.Outputs.nested_array_value
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN it should properly serialize the array and dictionary values
+    assert isinstance(data["workflow_raw_data"], dict)
+    assert isinstance(data["workflow_raw_data"]["nodes"], list)
+    raw_nodes = data["workflow_raw_data"]["nodes"]
+    generic_nodes = [node for node in raw_nodes if isinstance(node, dict) and node["type"] == "GENERIC"]
+    assert len(generic_nodes) > 0
+    my_node = generic_nodes[0]
+
+    outputs = my_node["outputs"]
+    assert isinstance(outputs, list)
+
+    array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "array_value"]
+    assert len(array_outputs) > 0
+    array_output = array_outputs[0]
+
+    assert isinstance(array_output, dict)
+    assert "value" in array_output
+    assert array_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "items": ["item1", "item2", "item3"]},
+    }
+
+    nested_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "nested_array_value"]
+    assert len(nested_array_outputs) > 0
+    nested_array_output = nested_array_outputs[0]
+
+    assert isinstance(nested_array_output, dict)
+    assert "value" in nested_array_output
+    assert nested_array_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "items": [["item1", "item2", "item3"], ["item4", "item5", "item6"]]},
+    }
+
+    mixed_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_array_value"]
+    assert len(mixed_array_outputs) > 0
+    mixed_array_output = mixed_array_outputs[0]
+
+    assert isinstance(mixed_array_output, dict)
+    assert "value" in mixed_array_output
+    assert mixed_array_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "items": [["item1"], "item2", "item3"]},
+    }
+
+
+def test_serialize_workflow__array_reference():
+    # GIVEN a node with array containing non-constant values (node references)
+    class FirstNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            value1: str
+            value2: str
+
+    class SecondNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            # Array containing a mix of constants and node references
+            mixed_array = ["constant1", FirstNode.Outputs.value1, "constant2", FirstNode.Outputs.value2]
+            mixed_nested_array = [["constant1", FirstNode.Outputs.value1], ["constant2", FirstNode.Outputs.value2]]
+
+    # AND a workflow that uses these outputs
+    class MyWorkflow(BaseWorkflow):
+        graph = FirstNode >> SecondNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            mixed_array_output = SecondNode.Outputs.mixed_array
+            mixed_nested_array_output = SecondNode.Outputs.mixed_nested_array
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN it should serialize as an ARRAY_REFERENCE
+    assert isinstance(data["workflow_raw_data"], dict)
+    assert isinstance(data["workflow_raw_data"]["nodes"], list)
+    assert len(data["workflow_raw_data"]["nodes"]) == 5
+    second_node = data["workflow_raw_data"]["nodes"][2]
+    assert isinstance(second_node, dict)
+
+    assert "outputs" in second_node
+    assert isinstance(second_node["outputs"], list)
+    outputs = second_node["outputs"]
+
+    mixed_array_outputs = [val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_array"]
+    assert len(mixed_array_outputs) > 0
+    mixed_array_output = mixed_array_outputs[0]
+
+    assert isinstance(mixed_array_output, dict)
+    assert "value" in mixed_array_output
+    assert mixed_array_output["value"] == {
+        "type": "ARRAY_REFERENCE",
+        "items": [
+            {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
+            {
+                "type": "NODE_OUTPUT",
+                "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                "node_output_id": "419b6afa-fab5-493a-ba1e-4606f4641616",
+            },
+            {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
+            {
+                "type": "NODE_OUTPUT",
+                "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                "node_output_id": "d1cacc41-478d-49a3-a6b3-1ba2d51291e2",
+            },
+        ],
+    }
+
+    mixed_nested_array_outputs = [
+        val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_nested_array"
+    ]
+    assert len(mixed_nested_array_outputs) > 0
+    mixed_nested_array_output = mixed_nested_array_outputs[0]
+
+    assert isinstance(mixed_nested_array_output, dict)
+    assert "value" in mixed_nested_array_output
+    assert mixed_nested_array_output["value"] == {
+        "type": "ARRAY_REFERENCE",
+        "items": [
+            {
+                "type": "ARRAY_REFERENCE",
+                "items": [
+                    {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
+                    {
+                        "type": "NODE_OUTPUT",
+                        "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                        "node_output_id": "419b6afa-fab5-493a-ba1e-4606f4641616",
+                    },
+                ],
+            },
+            {
+                "type": "ARRAY_REFERENCE",
+                "items": [
+                    {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
+                    {
+                        "type": "NODE_OUTPUT",
+                        "node_id": "702a08b5-61e8-4a7a-a83d-77f49e39c5be",
+                        "node_output_id": "d1cacc41-478d-49a3-a6b3-1ba2d51291e2",
+                    },
+                ],
+            },
+        ],
+    }
+
+
+def test_serialize_workflow__dict_values():
+    # GIVEN a node with a dictionary value
+    class MyNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            dict_value = {"key1": "value1", "key2": "value2"}
+            nested_dict_value = {
+                "key1": {"nested_key1": "value1", "nested_key2": "value2"},
+                "key2": {"nested_key1": "value1", "nested_key2": "value2"},
+            }
+            mixed_dict_value = {"key1": "value1", "key2": {"key3": "value3", "key4": "value4"}}
+
+    # AND a workflow that uses these outputs
+    class MyWorkflow(BaseWorkflow):
+        graph = MyNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            dict_output = MyNode.Outputs.dict_value
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN it should serialize as a CONSTANT_VALUE
+    assert isinstance(data["workflow_raw_data"], dict)
+    assert isinstance(data["workflow_raw_data"]["nodes"], list)
+    my_node = next(
+        node for node in data["workflow_raw_data"]["nodes"] if isinstance(node, dict) and node["type"] == "GENERIC"
+    )
+
+    assert isinstance(my_node["outputs"], list)
+    outputs = my_node["outputs"]
+
+    dict_output = next(val for val in outputs if isinstance(val, dict) and val["name"] == "dict_value")
+    assert isinstance(dict_output, dict)
+    assert "value" in dict_output
+    assert dict_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "value": {"key1": "value1", "key2": "value2"}},
+    }
+
+    nested_dict_output = next(val for val in outputs if isinstance(val, dict) and val["name"] == "nested_dict_value")
+    assert isinstance(nested_dict_output, dict)
+    assert "value" in nested_dict_output
+    assert nested_dict_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {
+            "type": "JSON",
+            "value": {
+                "key1": {"nested_key1": "value1", "nested_key2": "value2"},
+                "key2": {"nested_key1": "value1", "nested_key2": "value2"},
+            },
+        },
+    }
+
+    mixed_dict_output = next(val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_dict_value")
+    assert isinstance(mixed_dict_output, dict)
+    assert "value" in mixed_dict_output
+    assert mixed_dict_output["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {"type": "JSON", "value": {"key1": "value1", "key2": {"key3": "value3", "key4": "value4"}}},
+    }
+
+
+def test_serialize_workflow__dict_reference():
+    # GIVEN a node with a dictionary containing non-constant values (node references)
+    class FirstNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            value1: str
+
+    class SecondNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            # Dictionary containing a mix of constants and node references
+            mixed_dict = {
+                "key1": "constant1",
+                "key2": FirstNode.Outputs.value1,
+                "key3": "constant2",
+                "key4": FirstNode.Outputs.value1,
+            }
+            mixed_nested_dict = {
+                "key1": {"key1": "constant1", "key2": FirstNode.Outputs.value1},
+                "key2": {"key1": "constant2", "key2": FirstNode.Outputs.value1},
+            }
+
+    # AND a workflow that uses these outputs
+    class MyWorkflow(BaseWorkflow):
+        graph = FirstNode >> SecondNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            mixed_dict_output = SecondNode.Outputs.mixed_dict
+            mixed_nested_dict_output = SecondNode.Outputs.mixed_nested_dict
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data = workflow_display.serialize()
+
+    # THEN it should serialize as a CONSTANT_VALUE
+    assert isinstance(data["workflow_raw_data"], dict)
+    assert isinstance(data["workflow_raw_data"]["nodes"], list)
+    second_node = data["workflow_raw_data"]["nodes"][2]
+
+    assert isinstance(second_node, dict)
+    assert "outputs" in second_node
+    assert isinstance(second_node["outputs"], list)
+
+    outputs = second_node["outputs"]
+    mixed_dict_output = next(val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_dict")
+    assert isinstance(mixed_dict_output, dict)
+    assert "value" in mixed_dict_output
+    assert mixed_dict_output["value"] == {
+        "type": "DICTIONARY_REFERENCE",
+        "entries": [
+            {"key": "key1", "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}}},
+            {
+                "key": "key2",
+                "value": {
+                    "type": "NODE_OUTPUT",
+                    "node_id": "13b4f5c0-e6aa-4ef9-9a1a-79476bc32500",
+                    "node_output_id": "50a6bc11-afb3-49f2-879c-b28f5e16d974",
+                },
+            },
+            {"key": "key3", "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}}},
+            {
+                "key": "key4",
+                "value": {
+                    "type": "NODE_OUTPUT",
+                    "node_id": "13b4f5c0-e6aa-4ef9-9a1a-79476bc32500",
+                    "node_output_id": "50a6bc11-afb3-49f2-879c-b28f5e16d974",
+                },
+            },
+        ],
+    }
+
+    mixed_nested_dict_output = next(
+        val for val in outputs if isinstance(val, dict) and val["name"] == "mixed_nested_dict"
+    )
+    assert isinstance(mixed_nested_dict_output, dict)
+    assert "value" in mixed_nested_dict_output
+    assert mixed_nested_dict_output["value"] == {
+        "type": "DICTIONARY_REFERENCE",
+        "entries": [
+            {
+                "key": "key1",
+                "value": {
+                    "type": "DICTIONARY_REFERENCE",
+                    "entries": [
+                        {
+                            "key": "key1",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant1"}},
+                        },
+                        {
+                            "key": "key2",
+                            "value": {
+                                "type": "NODE_OUTPUT",
+                                "node_id": "13b4f5c0-e6aa-4ef9-9a1a-79476bc32500",
+                                "node_output_id": "50a6bc11-afb3-49f2-879c-b28f5e16d974",
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                "key": "key2",
+                "value": {
+                    "type": "DICTIONARY_REFERENCE",
+                    "entries": [
+                        {
+                            "key": "key1",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "constant2"}},
+                        },
+                        {
+                            "key": "key2",
+                            "value": {
+                                "type": "NODE_OUTPUT",
+                                "node_id": "13b4f5c0-e6aa-4ef9-9a1a-79476bc32500",
+                                "node_output_id": "50a6bc11-afb3-49f2-879c-b28f5e16d974",
+                            },
+                        },
+                    ],
+                },
+            },
+        ],
+    }