vellum-ai 0.14.45__py3-none-any.whl → 0.14.46__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.45",
+            "X-Fern-SDK-Version": "0.14.46",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

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

@@ -1,4 +1,4 @@
-from typing import Callable, Generic, Iterator, Optional, Set, Type, Union
+from typing import Callable, Generic, Iterator, Optional, Set, Type
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
@@ -21,8 +21,7 @@ class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
     subworkflow: Type["BaseWorkflow"] - The Subworkflow to execute
     """
 
-    # TODO: We could remove str after we support generating enum values.
-    on_error_code: Optional[Union[WorkflowErrorCode, str]] = None
+    on_error_code: Optional[WorkflowErrorCode] = None
 
     class Outputs(BaseAdornmentNode.Outputs):
         error: Optional[WorkflowError] = None
@@ -66,9 +65,7 @@ class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
                     message="Subworkflow unexpectedly paused within Try Node",
                 )
             elif event.name == "workflow.execution.rejected":
-                # TODO: We should remove this once we support generating enum values.
-                event_error_code = event.error.code.value if isinstance(self.on_error_code, str) else event.error.code
-                if self.on_error_code and self.on_error_code != event_error_code:
+                if self.on_error_code and self.on_error_code != event.error.code:
                     exception = NodeException(
                         code=WorkflowErrorCode.INVALID_OUTPUTS,
                         message=f"""Unexpected rejection: {event.error.code.value}.

vellum/workflows/nodes/core/try_node/tests/test_node.py

@@ -57,30 +57,6 @@ def test_try_node__retry_on_error_code__missed():
     assert exc_info.value.code == WorkflowErrorCode.INVALID_OUTPUTS
 
 
-def test_try_node__on_error_code__str():
-    # GIVEN a try node that is configured to catch PROVIDER_ERROR
-    @TryNode.wrap(on_error_code="PROVIDER_ERROR")  # type: ignore
-    class TestNode(BaseNode):
-        class Outputs(BaseOutputs):
-            value: int
-
-        def run(self) -> Outputs:
-            raise NodeException(message="This will be caught", code=WorkflowErrorCode.PROVIDER_ERROR)
-
-    # WHEN the node is run and throws a PROVIDER_ERROR
-    node = TestNode(state=BaseState())
-    outputs = [o for o in node.run()]
-
-    # THEN the exception is caught
-    assert len(outputs) == 2
-    assert set(outputs) == {
-        BaseOutput(name="value"),
-        BaseOutput(
-            name="error", value=WorkflowError(message="This will be caught", code=WorkflowErrorCode.PROVIDER_ERROR)
-        ),
-    }
-
-
 def test_try_node__use_parent_inputs_and_state():
     # GIVEN a parent workflow Inputs and State
     class Inputs(BaseInputs):

vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -15,7 +15,7 @@ from vellum import (
 )
 from vellum.client import ApiError, RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
-from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
+from vellum.workflows.constants import LATEST_RELEASE_TAG
 from vellum.workflows.context import get_execution_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import vellum_error_to_workflow_error
@@ -48,13 +48,13 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
     deployment: ClassVar[Union[UUID, str]]
 
     release_tag: str = LATEST_RELEASE_TAG
-    external_id: Optional[str] = OMIT
+    external_id: Optional[str] = None
 
-    expand_meta: Optional[PromptDeploymentExpandMetaRequest] = OMIT
-    raw_overrides: Optional[RawPromptExecutionOverridesRequest] = OMIT
-    expand_raw: Optional[Sequence[str]] = OMIT
-    metadata: Optional[Dict[str, Optional[Any]]] = OMIT
-    ml_model_fallbacks: Optional[Sequence[str]] = OMIT
+    expand_meta: Optional[PromptDeploymentExpandMetaRequest] = None
+    raw_overrides: Optional[RawPromptExecutionOverridesRequest] = None
+    expand_raw: Optional[Sequence[str]] = None
+    metadata: Optional[Dict[str, Optional[Any]]] = None
+    ml_model_fallbacks: Optional[Sequence[str]] = None
 
     class Trigger(BasePromptNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
@@ -103,12 +103,7 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                 prompt_event_stream = self._get_prompt_event_stream()
                 next(prompt_event_stream)
             except ApiError as e:
-                if (
-                    e.status_code
-                    and e.status_code < 500
-                    and self.ml_model_fallbacks is not OMIT
-                    and self.ml_model_fallbacks is not None
-                ):
+                if e.status_code and e.status_code < 500 and self.ml_model_fallbacks is not None:
                     prompt_event_stream = self._retry_prompt_stream_with_fallbacks(tried_fallbacks)
                 else:
                     self._handle_api_error(e)
@@ -127,7 +122,6 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                     if (
                         event.error
                         and event.error.code == WorkflowErrorCode.PROVIDER_ERROR.value
-                        and self.ml_model_fallbacks is not OMIT
                         and self.ml_model_fallbacks is not None
                     ):
                         try:

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

@@ -821,3 +821,65 @@ def main(arg1: list) -> str:
 
     # AND the result should be the correct output
     assert outputs == {"result": "bar", "log": ""}
+
+
+def test_run_node__string_value_wrapper__get_attr():
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = """\
+def main(text: str) -> str:
+    return text.value
+"""
+        code_inputs = {
+            "text": "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 through the .value property
+    assert outputs == {"result": "hello", "log": ""}
+
+
+def test_run_node__string_value_wrapper__get_item():
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = """\
+def main(text: str) -> str:
+    return text["value"]
+"""
+        code_inputs = {
+            "text": "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 through the .value property
+    assert outputs == {"result": "hello", "log": ""}
+
+
+def test_run_node__string_value_wrapper__list_of_dicts():
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Any]):
+        code = """\
+def main(output: list[str]) -> list[str]:
+    results = []
+    for item in output:
+        results.append(item['value'])
+
+    return results
+"""
+        code_inputs = {"output": ['{"foo": "bar"}', '{"foo2": "bar2"}']}
+        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": ['{"foo": "bar"}', '{"foo2": "bar2"}'], "log": ""}

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

@@ -8,6 +8,7 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.utils import cast_to_output_type
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.code_execution_node_wrappers import ListWrapper, clean_for_dict_wrapper
 from vellum.workflows.types.core import EntityInputsInterface
 
 
@@ -35,58 +36,6 @@ def read_file_from_path(
         return None
 
 
-class ListWrapper(list):
-    def __getitem__(self, key):
-        item = super().__getitem__(key)
-        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
-            self.__setitem__(key, _clean_for_dict_wrapper(item))
-
-        return super().__getitem__(key)
-
-
-class DictWrapper(dict):
-    """
-    This wraps a dict object to make it behave basically the same as a standard javascript object
-    and enables us to use vellum types here without a shared library since we don't actually
-    typecheck things here.
-    """
-
-    def __getitem__(self, key):
-        return self.__getattr__(key)
-
-    def __getattr__(self, attr):
-        if attr not in self:
-            if attr == "value":
-                # In order to be backwards compatible with legacy Workflows, which wrapped
-                # several values as VellumValue objects, we use the "value" key to return itself
-                return self
-
-            raise AttributeError(f"dict has no key: '{attr}'")
-
-        item = super().__getitem__(attr)
-        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
-            self.__setattr__(attr, _clean_for_dict_wrapper(item))
-
-        return super().__getitem__(attr)
-
-    def __setattr__(self, name, value):
-        self[name] = value
-
-
-def _clean_for_dict_wrapper(obj):
-    if isinstance(obj, dict):
-        wrapped = DictWrapper(obj)
-        for key in wrapped:
-            wrapped[key] = _clean_for_dict_wrapper(wrapped[key])
-
-        return wrapped
-
-    elif isinstance(obj, list):
-        return ListWrapper(map(lambda item: _clean_for_dict_wrapper(item), obj))
-
-    return obj
-
-
 def run_code_inline(
     code: str,
     inputs: EntityInputsInterface,
@@ -107,12 +56,12 @@ def run_code_inline(
                     (
                         item.model_dump()
                         if isinstance(item, BaseModel)
-                        else _clean_for_dict_wrapper(item) if isinstance(item, (dict, list)) else item
+                        else clean_for_dict_wrapper(item) if isinstance(item, (dict, list, str)) else item
                     )
                     for item in value
                 ]
             )
-        return _clean_for_dict_wrapper(value)
+        return clean_for_dict_wrapper(value)
 
     exec_globals = {
         "__arg__inputs": {name: wrap_value(value) for name, value in inputs.items()},

vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py

@@ -9,7 +9,6 @@ from vellum import (
     PromptOutput,
     StringVellumValue,
 )
-from vellum.workflows.constants import OMIT
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import PromptDeploymentNode
 from vellum.workflows.state import BaseState
@@ -66,14 +65,14 @@ def test_text_prompt_deployment_node__basic(vellum_client):
 
     # AND we should have made the expected call to stream the prompt execution
     vellum_client.execute_prompt_stream.assert_called_once_with(
-        expand_meta=OMIT,
-        expand_raw=OMIT,
-        external_id=OMIT,
+        expand_meta=None,
+        expand_raw=None,
+        external_id=None,
         inputs=[],
-        metadata=OMIT,
+        metadata=None,
         prompt_deployment_id=None,
         prompt_deployment_name="my-deployment",
-        raw_overrides=OMIT,
+        raw_overrides=None,
         release_tag="LATEST",
         request_options={
             "additional_body_parameters": {"execution_context": {"parent_context": None, "trace_id": mock.ANY}}

vellum/workflows/nodes/utils.py

@@ -1,4 +1,5 @@
 from functools import cache
+import inspect
 import json
 import sys
 from types import ModuleType
@@ -14,6 +15,7 @@ from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.code_execution_node_wrappers import StringValueWrapper
 from vellum.workflows.types.core import Json
 from vellum.workflows.types.generics import NodeType
 
@@ -176,6 +178,8 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
 
 
 def _get_type_name(obj: Any) -> str:
+    if inspect.isclass(obj) and issubclass(obj, StringValueWrapper):
+        return "str"
     if isinstance(obj, type):
         return obj.__name__
 

vellum/workflows/types/code_execution_node_wrappers.py

@@ -0,0 +1,64 @@
+class StringValueWrapper(str):
+    def __getitem__(self, key):
+        if key == "value":
+            return self
+        raise KeyError(key)
+
+    def __getattr__(self, attr):
+        if attr == "value":
+            return self
+        raise AttributeError(f"'str' object has no attribute '{attr}'")
+
+
+class ListWrapper(list):
+    def __getitem__(self, key):
+        item = super().__getitem__(key)
+        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
+            self.__setitem__(key, clean_for_dict_wrapper(item))
+
+        return super().__getitem__(key)
+
+
+class DictWrapper(dict):
+    """
+    This wraps a dict object to make it behave basically the same as a standard javascript object
+    and enables us to use vellum types here without a shared library since we don't actually
+    typecheck things here.
+    """
+
+    def __getitem__(self, key):
+        return self.__getattr__(key)
+
+    def __getattr__(self, attr):
+        if attr not in self:
+            if attr == "value":
+                # In order to be backwards compatible with legacy Workflows, which wrapped
+                # several values as VellumValue objects, we use the "value" key to return itself
+                return self
+
+            raise AttributeError(f"dict has no key: '{attr}'")
+
+        item = super().__getitem__(attr)
+        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
+            self.__setattr__(attr, clean_for_dict_wrapper(item))
+
+        return super().__getitem__(attr)
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+
+def clean_for_dict_wrapper(obj):
+    if isinstance(obj, dict):
+        wrapped = DictWrapper(obj)
+        for key in wrapped:
+            wrapped[key] = clean_for_dict_wrapper(wrapped[key])
+
+        return wrapped
+
+    elif isinstance(obj, list):
+        return ListWrapper(map(lambda item: clean_for_dict_wrapper(item), obj))
+    elif isinstance(obj, str):
+        return StringValueWrapper(obj)
+
+    return obj

vellum/workflows/vellum_client.py

@@ -1,22 +1,34 @@
 import os
-from typing import Optional
+from typing import List, Optional
 
 from vellum import Vellum, VellumEnvironment
 
 
-def create_vellum_client(api_key: Optional[str] = None) -> Vellum:
+def create_vellum_client(api_key: Optional[str] = None, api_url: Optional[str] = None) -> Vellum:
     if api_key is None:
         api_key = os.getenv("VELLUM_API_KEY", default="")
 
     return Vellum(
         api_key=api_key,
-        environment=create_vellum_environment(),
+        environment=create_vellum_environment(api_url),
     )
 
 
-def create_vellum_environment() -> VellumEnvironment:
+def create_vellum_environment(api_url: Optional[str] = None) -> VellumEnvironment:
     return VellumEnvironment(
-        default=os.getenv("VELLUM_DEFAULT_API_URL", os.getenv("VELLUM_API_URL", "https://api.vellum.ai")),
-        documents=os.getenv("VELLUM_DOCUMENTS_API_URL", os.getenv("VELLUM_API_URL", "https://documents.vellum.ai")),
-        predict=os.getenv("VELLUM_PREDICT_API_URL", os.getenv("VELLUM_API_URL", "https://predict.vellum.ai")),
+        default=_resolve_env([api_url, "VELLUM_DEFAULT_API_URL", "VELLUM_API_URL"], "https://api.vellum.ai"),
+        documents=_resolve_env([api_url, "VELLUM_DOCUMENTS_API_URL", "VELLUM_API_URL"], "https://documents.vellum.ai"),
+        predict=_resolve_env([api_url, "VELLUM_PREDICT_API_URL", "VELLUM_API_URL"], "https://predict.vellum.ai"),
     )
+
+
+def _resolve_env(names: List[Optional[str]], default: str = "") -> str:
+    for name in names:
+        if not name:
+            continue
+
+        value = os.getenv(name)
+        if value:
+            return value
+
+    return default

{vellum_ai-0.14.45.dist-info → vellum_ai-0.14.46.dist-info}/METADATA

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

{vellum_ai-0.14.45.dist-info → vellum_ai-0.14.46.dist-info}/RECORD

@@ -2,13 +2,13 @@ vellum_cli/CONTRIBUTING.md,sha256=FtDC7BGxSeMnwCXAUssFsAIElXtmJE-O5Z7BpolcgvI,29
 vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
 vellum_cli/__init__.py,sha256=7aO9XFnaEVRiVshn86cFudebFUccT-gV8xIARJWqKYo,12257
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
-vellum_cli/config.py,sha256=aKnhvM5B8QdPA4cQC5Sqg7ImP-vNcVdSkZmk_OBpQTw,9309
+vellum_cli/config.py,sha256=v5BmZ-t_v4Jmqd7KVuQMZF2pRI-rbMspSkVYXIRoTmI,9448
 vellum_cli/image_push.py,sha256=8DDvRDJEZ-FukUCqGW1827bg1ybF4xBbx9WyqWYQE-g,6816
 vellum_cli/init.py,sha256=WpnMXPItPmh0f0bBGIer3p-e5gu8DUGwSArT_FuoMEw,5093
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
 vellum_cli/ping.py,sha256=p_BCCRjgPhng6JktuECtkDQLbhopt6JpmrtGoLnLJT8,1161
 vellum_cli/pull.py,sha256=2hSJGeqooevMb--mcvRLQ1GYT-9290cI7VdSRifzmTg,12561
-vellum_cli/push.py,sha256=0bHAhp6B67JUFuiL9sSekrLOw-x2Dp6VsrzhFbOy7e4,9508
+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
@@ -17,7 +17,7 @@ vellum_cli/tests/test_init.py,sha256=8UOc_ThfouR4ja5cCl_URuLk7ohr9JXfCnG4yka1OUQ
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_ping.py,sha256=3ucVRThEmTadlV9LrJdCCrr1Ofj3rOjG6ue0BNR2UC0,2523
 vellum_cli/tests/test_pull.py,sha256=iTxVbJGuehvgNt8Vp9W3Y5Bvaocfws8bl8LMGEbc_qQ,47508
-vellum_cli/tests/test_push.py,sha256=j22l7p_cy1KXdcvQKhWiM2bpu-3WL1q5IJquRm84mxE,25580
+vellum_cli/tests/test_push.py,sha256=uNMmPG9Z0uRN6xYYMzBGZaCXJZkAHWcbcSJRJ4eQk70,31182
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,10 +45,10 @@ vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=yZO9U
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=T3a6Lv51SC1506bTVd8T9y_KVmP2VP4IQarAO87xdmM,3755
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=yBWeN4T_lOsDVnNOKWRiT7JYKu0IR5Fx2z99iq6QKSA,3273
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=3E0UqmgVYdtbj4nyq8gKju8EpMsRHMCQ0KLrJhug3XU,1084
-vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=7wgyHaeolEKBKBZioqt1zc7cHxkuaW_2diL9XjIdFNE,3461
+vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=NCh9T7M4V1w-5i_bfYdI6L4jj1C_JGBuVBb0nXXsN38,3239
 vellum_ee/workflows/display/nodes/vellum/retry_node.py,sha256=X3xnlAU5JisL0jRvaG_V9RvTF7ZlGufTO8tXLLVhGIg,3280
 vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=7vU_4IxYe7iwn4p7J909cxF1TOR-tUlFXA7k3ySQPwM,9320
-vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=5NWneQCRtawbl_fI9cZXH5ssD2EheHAMhl2mnZOsJ0c,2814
+vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=TIMpOL0dm__xvnDHotCEjBQWCp2hgRDJUnRuPMBrZcE,2592
 vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=Nk5pxly4d-kactJ3Z4SLErZCm8hicyj2rCArZw8pW9k,3283
 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=OoNO-BstB96F-VMK6FZ9aXyi-0wyNePo6HiaJC6SYRw,3880
@@ -91,17 +91,17 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_n
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=r748dpS13HtwY7t_KQFExFssxRy0xI2d-wxmhiUHRe0,3850
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=EL5kfakuoEcwD85dGjhMta-J-PpCHRSDoc80SdbBrQk,2769
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=RmFUDx8dYdfsOE2CGLvdXqNNRtLLpVzXDN8dqZyMcZ8,5822
-vellum_ee/workflows/display/types.py,sha256=NKtEGFhvgz1i_oAayXFIS06QZautixnS3id5DckCIjg,2637
+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=jtFyogkad5i8OKbaragW_C5-J2wXpMroRNqzkq5AJE0,10635
+vellum_ee/workflows/display/utils/expressions.py,sha256=Q0Vf-88wtbOIM1ZRkAaF5tMZc2V-i8LeZ32wFmHFmZg,10642
 vellum_ee/workflows/display/utils/registry.py,sha256=fWIm5Jj-10gNFjgn34iBu4RWv3Vd15ijtSN0V97bpW8,1513
-vellum_ee/workflows/display/utils/vellum.py,sha256=4gm4mPvM7srq5IGytPi41QvO6LPC5NwWPy_sRM1Iicg,5520
+vellum_ee/workflows/display/utils/vellum.py,sha256=HDe1vtIaU35OEg4oC1KC6WNwhw5Laf_mNURorzbeutQ,5418
 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=MifwBKquksk55O8qxYsxfPgFbiHUkgZ-tQNlO-a25uU,32896
-vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=s6yMO0RxoM8scmfT8TJ-9cwl-WHFe7JSyEJA0alCeEs,1913
-vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=ZmbW-_QgKE7Sx3H0KK4wvm48I5HvXs5ITJRsFiriM5w,13810
+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/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=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=Z-JHK2jGxhtTtmkLeOaUGGJWIUNYGNVBLvUewC6lp6w,118148
 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=2R_elVxC5Z8J7AjG_3HT1Vmw7m81NGxIOuC5HYXmvCI,1869
+vellum/client/core/client_wrapper.py,sha256=Bo-z8mq3B7ugaNmdHcHDd0_iCRPsJMoD6YQfXPjlnC8,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -1562,9 +1562,9 @@ vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id
 vellum/workflows/nodes/core/templating_node/node.py,sha256=iqBmr2i-f-BqhisNQJiDfewjol0ur7-XpupLStyMJsg,3731
 vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=nXkgGDBg4wP36NwykdMEVWwx_xjv8oGT2rYkwuCB_VU,10075
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
-vellum/workflows/nodes/core/try_node/node.py,sha256=1DAgNXFTGMRikbsPKclb9S9ZCzNCfeQYYNjbi2UCwds,4685
+vellum/workflows/nodes/core/try_node/node.py,sha256=XdyOvlwQ3m4h0-_WNtaBl2t_CdlzPXclulkLOtUcX3E,4388
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=yoGPUdeO8Oa3N66XpwIhVVvGTBYSTQPPNTpwWefZIv4,5763
+vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=h6eUc3SggvhzBWlOD0PrPUlkoCSQHwjqYn81VkxSIxU,4948
 vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDXl0Nmz4QzJV2PYe5RI,1023
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
 vellum/workflows/nodes/displayable/api_node/node.py,sha256=cp0nAukcOpM6TcNhbz12h08TMJxp_LM-MLDl1dAzYsk,2534
@@ -1580,7 +1580,7 @@ vellum/workflows/nodes/displayable/bases/inline_prompt_node/constants.py,sha256=
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=wqN1EjyjTL6McUmlkHWu3GXVzcNaqDjavvmKUHDaVqg,10623
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py,sha256=YPOFoaEBENfOzE_qWo3WdQ_E1dQk78aLCWk8gOMvTjg,16042
-vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=lwH7mfiHcRKFxU1Y9IPQVgb3o5trssuhwlKnA30rTWk,9777
+vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=T99UWACTD9ytVDVHa6W2go00V7HNwDxOyBFyMM2GnhQ,9567
 vellum/workflows/nodes/displayable/bases/search_node.py,sha256=3UtbqY3QO4kzfJHbmUNZGnEEfJmaoiF892u8H6TGjp8,5381
 vellum/workflows/nodes/displayable/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/tests/test_utils.py,sha256=eqdqbKNRWVMDPevgwLg1i6YK0g4L4bCy-7xCBN5yYZI,3156
@@ -1591,8 +1591,8 @@ vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=Ko_Dy17Ajf
 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=AzgTK2YSvVj7zr6gWZfz0-YGf1cVQ9DiSx9fe5BR4uE,24690
-vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=G-sc7yOL5g6rLk99X8HAbXNcLxRaqpju9IXq1iUwnQI,4470
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=Km_BH9W61IJSRj5CdiSmEOINOIouG_a5Gey0fCDmShQ,26620
+vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=oCI8HS_Y-hsNhvGIC8HgbIzKIZeWOkXMLaknDRf-qus,2928
 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
@@ -1628,7 +1628,7 @@ vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.p
 vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=LaxohBcKfSW2PSiBBlx67FdW_q4YC2BM2ouH-vuGPAA,4700
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
-vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=sGlAzTgKz8OsqeT3e7FbQyPpvs_2Fk9_jfD6BRyc6M0,2628
+vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=dc3EEn1sOICpr3GdS8eyeFtExaGwWWcw9eHSdkRhQJU,2584
 vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
 vellum/workflows/nodes/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
@@ -1640,7 +1640,7 @@ vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWl
 vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
 vellum/workflows/nodes/tests/test_utils.py,sha256=qNB6ApIsnFtE_9HDaEah9KD-zX8e10FhDixewS1uRcc,5199
-vellum/workflows/nodes/utils.py,sha256=ziHJc5uU4foxIvacl0Vg7fEJJ0jiznqqhyvURVj0FsY,9005
+vellum/workflows/nodes/utils.py,sha256=j3I_qKlkU9WDplYbeija3-rC_KAKD4dyums1xROWFKQ,9193
 vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfvh-ms1QE,94
 vellum/workflows/outputs/base.py,sha256=1OGHqBJVk7i8cW8uewFWOhIjuMlRRpzCDrGE30ZwDjw,8763
 vellum/workflows/ports/__init__.py,sha256=bZuMt-R7z5bKwpu4uPW7LlJeePOQWmCcDSXe5frUY5g,101
@@ -1676,6 +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=cQ1Se6fe1uqGUs8uVQxkk2OEVikcHbwTM0CyU2AsgqI,2010
 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
@@ -1693,15 +1694,15 @@ vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEW
 vellum/workflows/utils/tests/test_vellum_variables.py,sha256=maI5e7Od7UlpMwlrOrcdlXqnFhonkXGnWq8G2-YQLi8,1155
 vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrgTY,739
 vellum/workflows/utils/vellum_variables.py,sha256=UiGlUh0a8vel2FbW3w-xbHxSv_jNutkDdqMVtP_b42A,3385
-vellum/workflows/vellum_client.py,sha256=GxOy3dX6A04xiY69vPv1S4YGuQ_TMxwHi6WRMimQBBE,762
+vellum/workflows/vellum_client.py,sha256=xkfoucodxNK5JR2-lbRqZx3xzDgExWkP6kySrpi_Ubc,1079
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
 vellum/workflows/workflows/base.py,sha256=9dGZzoXbVVtw19pVhmawIA1wd1iLQttAKypuVFWb0fU,23793
 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=8P5YIsNMO78_CR1NNK6wkEdkMB4b3Q_Ni1qxh78OnHo,20481
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.45.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.45.dist-info/METADATA,sha256=BfwTGG-Soly3Rh8Hqs0qan0I50KGBzN7o4hDZfMfdQo,5484
-vellum_ai-0.14.45.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.45.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.45.dist-info/RECORD,,
+vellum_ai-0.14.46.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.46.dist-info/METADATA,sha256=QVjFBBT5KT2PzAvAibMrRv8VD7GpQoUhjlXaR_H--Fw,5484
+vellum_ai-0.14.46.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.46.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.46.dist-info/RECORD,,

vellum_cli/config.py

@@ -16,10 +16,15 @@ PYPROJECT_TOML_PATH = "pyproject.toml"
 
 class WorkspaceConfig(UniversalBaseModel):
     name: str
-    api_key: str
+    api_key: str = "VELLUM_API_KEY"
+    api_url: Optional[str] = None
 
     def merge(self, other: "WorkspaceConfig") -> "WorkspaceConfig":
-        return WorkspaceConfig(name=self.name or other.name, api_key=self.api_key or other.api_key)
+        return WorkspaceConfig(
+            name=self.name or other.name,
+            api_key=self.api_key or other.api_key,
+            api_url=self.api_url or other.api_url,
+        )
 
 
 DEFAULT_WORKSPACE_CONFIG = WorkspaceConfig(name="default", api_key="VELLUM_API_KEY")

vellum_cli/push.py

@@ -97,6 +97,7 @@ def push_command(
 
     client = create_vellum_client(
         api_key=api_key,
+        api_url=workspace_config.api_url,
     )
     sys.path.insert(0, os.getcwd())
 
@@ -105,6 +106,7 @@ def push_command(
     workflow = BaseWorkflow.load_from_module(workflow_config.module)
     workflow_display = get_workflow_display(
         workflow_class=workflow,
+        client=client,
         dry_run=dry_run or False,
     )
     exec_config = workflow_display.serialize()
@@ -234,9 +236,11 @@ def push_command(
 """
         )  # type: ignore[attr-defined]
     else:
+        default_api_url = client._client_wrapper._environment.default
+        base_url = default_api_url.split("/v1")[0].replace("//api.", "//app.")
         logger.info(
             f"""Successfully pushed {workflow_config.module} to Vellum!
-Visit at: https://app.vellum.ai/workflow-sandboxes/{response.workflow_sandbox_id}"""
+Visit at: {base_url}/workflow-sandboxes/{response.workflow_sandbox_id}"""
         )
 
     if not workflow_config.workflow_sandbox_id:

vellum_cli/tests/test_push.py

@@ -7,6 +7,7 @@ from unittest import mock
 from uuid import uuid4
 
 from click.testing import CliRunner
+from httpx import Response
 
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
@@ -29,19 +30,25 @@ def _extract_tar_gz(tar_gz_bytes: bytes) -> dict[str, str]:
     return files
 
 
-def _ensure_workflow_py(temp_dir: str, module: str) -> str:
-    base_dir = os.path.join(temp_dir, *module.split("."))
+def _ensure_file(temp_dir: str, module: str, file_name: str, content: str) -> str:
+    file_path = os.path.join(temp_dir, *module.split("."), file_name)
+    base_dir = os.path.dirname(file_path)
     os.makedirs(base_dir, exist_ok=True)
+
+    with open(file_path, "w") as f:
+        f.write(content)
+
+    return content
+
+
+def _ensure_workflow_py(temp_dir: str, module: str) -> str:
     workflow_py_file_content = """\
 from vellum.workflows import BaseWorkflow
 
 class ExampleWorkflow(BaseWorkflow):
     pass
 """
-    with open(os.path.join(temp_dir, *module.split("."), "workflow.py"), "w") as f:
-        f.write(workflow_py_file_content)
-
-    return workflow_py_file_content
+    return _ensure_file(temp_dir, module, "workflow.py", workflow_py_file_content)
 
 
 def test_push__no_config(mock_module):
@@ -133,6 +140,38 @@ def test_push__happy_path(mock_module, vellum_client, base_command):
     assert extracted_files["workflow.py"] == workflow_py_file_content
 
 
+def test_push__verify_default_url_in_raw_httpx_transport(mock_module, mock_httpx_transport):
+    # GIVEN a single workflow configured
+    module = mock_module.module
+    temp_dir = mock_module.temp_dir
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=json.dumps(
+            {
+                "workflow_sandbox_id": str(uuid4()),
+            }
+        ),
+    )
+
+    # WHEN calling `vellum push`
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "push", module])
+
+    # THEN it should succeed
+    assert result.exit_code == 0
+
+    # AND we should have called the push API with the correct args
+    mock_httpx_transport.handle_request.assert_called_once()
+    request = mock_httpx_transport.handle_request.call_args[0][0]
+    assert str(request.url) == "https://api.vellum.ai/v1/workflows/push"
+
+    # AND the new URL is in the message at the end
+    assert "Visit at: https://app.vellum.ai/workflow-sandboxes/" in result.output
+
+
 def test_push__no_config__module_found(mock_module, vellum_client):
     # GIVEN no config file set
     temp_dir = mock_module.temp_dir
@@ -486,7 +525,74 @@ Files that were different between the original project and the generated artifac
     )
 
 
-def test_push__workspace_option__uses_different_api_key(mock_module, vellum_client_class):
+@pytest.mark.parametrize(
+    "file_data",
+    [
+        {
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+
+class ExampleWorkflow(BaseWorkflow):
+    pass
+"""
+        },
+        {
+            "nodes/start_node.py": """\
+from vellum.workflows.nodes import CodeExecutionNode
+from vellum.workflows.references import VellumSecretReference
+
+class StartNode(CodeExecutionNode):
+    code_inputs = {
+        "foo": VellumSecretReference("MY_SECRET_KEY"),
+    }
+""",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class ExampleWorkflow(BaseWorkflow):
+    graph = StartNode
+""",
+        },
+        {
+            "nodes/start_node.py": """\
+from vellum.workflows.nodes import PromptDeploymentNode
+
+class StartNode(PromptDeploymentNode):
+    deployment = "my-deployment"
+""",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class ExampleWorkflow(BaseWorkflow):
+    graph = StartNode
+""",
+        },
+        {
+            "nodes/start_node.py": """\
+from vellum.workflows.nodes import SubworkflowDeploymentNode
+
+class StartNode(SubworkflowDeploymentNode):
+    deployment = "my-deployment"
+""",
+            "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class ExampleWorkflow(BaseWorkflow):
+    graph = StartNode
+""",
+        },
+    ],
+    ids=[
+        "base_case",
+        "with_secret_reference",
+        "with_prompt_deployment",
+        "with_subworkflow_deployment",
+    ],
+)
+def test_push__workspace_option__uses_different_api_key(mock_module, vellum_client_class, file_data):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir
     module = mock_module.module
@@ -521,7 +627,8 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
         )
 
     # AND a workflow exists in the module successfully
-    _ensure_workflow_py(temp_dir, module)
+    for file_name, content in file_data.items():
+        _ensure_file(temp_dir, module, file_name, content)
 
     # AND the push API call returns a new workflow sandbox id
     new_workflow_sandbox_id = str(uuid4())
@@ -564,6 +671,83 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
         }
 
 
+def test_push__workspace_option__uses_different_api_url_env(mock_module, mock_httpx_transport):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+    set_pyproject_toml = mock_module.set_pyproject_toml
+
+    # AND a different workspace is set in the pyproject.toml
+    set_pyproject_toml(
+        {
+            "workflows": [
+                {
+                    "module": module,
+                    "workflow_sandbox_id": workflow_sandbox_id,
+                }
+            ],
+            "workspaces": [
+                {
+                    "name": "my_other_workspace",
+                    "api_url": "MY_OTHER_VELLUM_API_URL",
+                }
+            ],
+        }
+    )
+
+    # AND the .env file has the other api key stored
+    with open(os.path.join(temp_dir, ".env"), "w") as f:
+        f.write(
+            """\
+VELLUM_API_KEY=abcdef123456
+MY_OTHER_VELLUM_API_URL=https://app.aws-vpc-staging.vellum.ai
+"""
+        )
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns a new workflow sandbox id
+    new_workflow_sandbox_id = str(uuid4())
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=json.dumps(
+            {
+                "workflow_sandbox_id": new_workflow_sandbox_id,
+            }
+        ),
+    )
+
+    # WHEN calling `vellum push` on strict mode
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module, "--workspace", "my_other_workspace"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API once with the correct api url
+    request = mock_httpx_transport.handle_request.call_args[0][0]
+    assert str(request.url) == "https://app.aws-vpc-staging.vellum.ai/v1/workflows/push"
+
+    # AND the vellum lock file should have been updated with the correct workspace
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        assert lock_file_content["workflows"][1] == {
+            "module": module,
+            "workflow_sandbox_id": new_workflow_sandbox_id,
+            "workspace": "my_other_workspace",
+            "container_image_name": None,
+            "container_image_tag": None,
+            "deployments": [],
+            "ignore": None,
+            "target_directory": None,
+        }
+
+    # AND the new URL is in the message at the end
+    assert "Visit at: https://app.aws-vpc-staging.vellum.ai/workflow-sandboxes/" in result.output
+
+
 def test_push__workspace_option__both_options_already_configured(mock_module, vellum_client_class):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir

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

@@ -4,7 +4,6 @@ from typing import Generic, Optional, TypeVar, cast
 from vellum.workflows.nodes.displayable.prompt_deployment_node import PromptDeploymentNode
 from vellum.workflows.references import OutputReference
 from vellum.workflows.types.core import JsonObject
-from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -42,10 +41,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
         _, output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
         _, array_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.results)]
 
-        # TODO: Pass through the name instead of retrieving the ID
-        # https://app.shortcut.com/vellum/story/4702
-        vellum_client = create_vellum_client()
-        deployment = vellum_client.deployments.retrieve(
+        deployment = display_context.client.deployments.retrieve(
             id=str(raise_if_descriptor(node.deployment)),
         )
         ml_model_fallbacks = raise_if_descriptor(node.ml_model_fallbacks)

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

@@ -3,7 +3,6 @@ from typing import Generic, Optional, TypeVar
 
 from vellum.workflows.nodes import SubworkflowDeploymentNode
 from vellum.workflows.types.core import JsonObject
-from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -37,10 +36,7 @@ class BaseSubworkflowDeploymentNodeDisplay(
             for variable_name, variable_value in subworkflow_inputs.items()
         ]
 
-        # TODO: Pass through the name instead of retrieving the ID
-        # https://app.shortcut.com/vellum/story/4702
-        vellum_client = create_vellum_client()
-        deployment = vellum_client.workflow_deployments.retrieve(
+        deployment = display_context.client.workflow_deployments.retrieve(
             id=str(raise_if_descriptor(node.deployment)),
         )
 

vellum_ee/workflows/display/types.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Dict, Tuple, Type
 
+from vellum.client import Vellum as VellumClient
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.events.workflow import WorkflowEventDisplayContext  # noqa: F401
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, StateValueReference, WorkflowInputReference
+from vellum.workflows.vellum_client import create_vellum_client
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import (
     EdgeDisplay,
@@ -35,6 +37,7 @@ PortDisplays = Dict[Port, PortDisplay]
 
 @dataclass
 class WorkflowDisplayContext:
+    client: VellumClient = field(default_factory=create_vellum_client)
     workflow_display_class: Type["BaseWorkflowDisplay"] = field(default_factory=get_default_workflow_display_class)
     workflow_display: WorkflowMetaDisplay = field(default_factory=lambda: WorkflowMetaDisplay.get_default(BaseWorkflow))
     workflow_input_displays: WorkflowInputsDisplays = field(default_factory=dict)

vellum_ee/workflows/display/utils/expressions.py

@@ -107,7 +107,7 @@ def get_child_descriptor(value: LazyReference, display_context: "WorkflowDisplay
             )
 
         node_class_name = ".".join(reference_parts[:-2])
-        for node in display_context.node_displays.keys():
+        for node in display_context.global_node_displays.keys():
             if node.__name__ == node_class_name:
                 return getattr(node.Outputs, output_name)
 

vellum_ee/workflows/display/utils/vellum.py

@@ -13,7 +13,6 @@ from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
-from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
 from vellum_ee.workflows.display.utils.expressions import get_child_descriptor
 
@@ -118,8 +117,7 @@ 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):
-        vellum_client = create_vellum_client()
-        workspace_secret = vellum_client.workspace_secrets.retrieve(
+        workspace_secret = display_context.client.workspace_secrets.retrieve(
             id=value.name,
         )
         return WorkspaceSecretPointer(

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -6,6 +6,7 @@ import logging
 from uuid import UUID
 from typing import Any, Dict, ForwardRef, Generic, Iterator, List, Optional, Tuple, Type, TypeVar, Union, cast, get_args
 
+from vellum.client import Vellum as VellumClient
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -21,6 +22,7 @@ from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
 from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.base import (
     EdgeDisplay,
     EntrypointDisplay,
@@ -84,9 +86,16 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         self,
         *,
         parent_display_context: Optional[WorkflowDisplayContext] = None,
+        client: Optional[VellumClient] = None,
         dry_run: bool = False,
     ):
         self._parent_display_context = parent_display_context
+        self._client = client or (
+            # propagate the client from the parent display context if it is not provided
+            self._parent_display_context.client
+            if self._parent_display_context
+            else create_vellum_client()
+        )
         self._errors: List[Exception] = []
         self._dry_run = dry_run
 
@@ -494,6 +503,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             )
 
         return WorkflowDisplayContext(
+            client=self._client,
             workflow_display=workflow_meta_display,
             workflow_input_displays=workflow_input_displays,
             global_workflow_input_displays=global_workflow_input_displays,

vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py

@@ -1,6 +1,7 @@
 import types
 from typing import TYPE_CHECKING, Generic, Optional, Type, TypeVar
 
+from vellum.client import Vellum as VellumClient
 from vellum.workflows.types.generics import WorkflowType
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.registry import get_from_workflow_display_registry
@@ -35,6 +36,7 @@ def get_workflow_display(
     *,
     workflow_class: Type[WorkflowType],
     parent_display_context: Optional[WorkflowDisplayContext] = None,
+    client: Optional[VellumClient] = None,
     dry_run: bool = False,
     # DEPRECATED: The following arguments will be removed in 0.15.0
     root_workflow_class: Optional[Type[WorkflowType]] = None,
@@ -42,5 +44,6 @@ def get_workflow_display(
 ) -> "BaseWorkflowDisplay":
     return _get_workflow_display_class(workflow_class=workflow_class)(
         parent_display_context=parent_display_context,
+        client=client,
         dry_run=dry_run,
     )

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

@@ -7,6 +7,7 @@ from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.nodes.displayable.final_output_node.node import FinalOutputNode
+from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
 from vellum_ee.workflows.display.nodes import BaseNodeDisplay
@@ -372,3 +373,55 @@ def test_serialize_workflow__terminal_node_mismatches_workflow_output_name():
         "node_id": str(ExitNode.__id__),
         "node_output_id": str(ExitNode.__output_ids__["value"]),
     }
+
+
+def test_serialize_workflow__nested_lazy_reference():
+    # GIVEN an inner node that references the output of an outer node
+    class InnerNode(BaseNode):
+        foo = LazyReference[str]("OuterNode.Outputs.bar")
+
+        class Outputs(BaseNode.Outputs):
+            foo = "foo"
+
+    # AND a workflow that uses the inner node
+    class InnerWorkflow(BaseWorkflow):
+        graph = InnerNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            foo = InnerNode.Outputs.foo
+
+    # AND a subworkflow that uses the inner workflow
+    class SubworkflowNode(InlineSubworkflowNode):
+        subworkflow = InnerWorkflow
+
+    # AND the outer node
+    class OuterNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            bar: str
+
+    # AND a workflow that uses the subworkflow node and the outer node
+    class MyWorkflow(BaseWorkflow):
+        graph = SubworkflowNode >> OuterNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            answer = SubworkflowNode.Outputs.foo
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    data: dict = workflow_display.serialize()
+
+    # THEN it should have properly serialized the lazy reference
+    subworkflow_node = next(
+        node for node in data["workflow_raw_data"]["nodes"] if isinstance(node, dict) and node["type"] == "SUBWORKFLOW"
+    )
+    inner_node = next(
+        node
+        for node in subworkflow_node["data"]["workflow_raw_data"]["nodes"]
+        if isinstance(node, dict) and node["type"] == "GENERIC"
+    )
+
+    assert inner_node["attributes"][0]["value"] == {
+        "type": "NODE_OUTPUT",
+        "node_id": str(OuterNode.__id__),
+        "node_output_id": str(OuterNode.__output_ids__["bar"]),
+    }