vellum-ai 0.11.8__py3-none-any.whl → 0.11.10__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.11.8",
+            "X-Fern-SDK-Version": "0.11.10",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

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

@@ -73,7 +73,8 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
     request_options: Optional[RequestOptions] = None - The request options to use for the custom script.
     """
 
-    filepath: ClassVar[str]
+    filepath: ClassVar[Optional[str]] = None
+    code: ClassVar[Optional[str]] = None
 
     code_inputs: ClassVar[EntityInputsInterface]
     runtime: CodeExecutionRuntime = "PYTHON_3_11_6"
@@ -190,6 +191,21 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         return compiled_inputs
 
     def _resolve_code(self) -> str:
+        if self.code and self.filepath:
+            raise NodeException(
+                message="Cannot specify both `code` and `filepath` for a CodeExecutionNode",
+                code=VellumErrorCode.INVALID_INPUTS,
+            )
+
+        if self.code:
+            return self.code
+
+        if not self.filepath:
+            raise NodeException(
+                message="Must specify either `code` or `filepath` for a CodeExecutionNode",
+                code=VellumErrorCode.INVALID_INPUTS,
+            )
+
         root = inspect.getfile(self.__class__)
         code = read_file_from_path(node_filepath=root, script_filepath=self.filepath)
         if not code:

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

@@ -1,6 +1,8 @@
+import pytest
 import os
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
 from vellum.workflows.references.vellum_secret import VellumSecretReference
@@ -62,6 +64,145 @@ def main(word: str) -> int:
     )
 
 
+def test_run_workflow__code_attribute(vellum_client):
+    """Confirm that CodeExecutionNodes can use the `code` attribute to specify the code to execute."""
+
+    # GIVEN a node that subclasses CodeExecutionNode
+    class Inputs(BaseInputs):
+        word: str
+
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        code = """\
+def main(word: str) -> int:
+    print(word)  # noqa: T201
+    return len(word)
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": Inputs.word,
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="hello",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(word="hello")),
+        )
+    )
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert outputs == {"result": 5, "log": "hello"}
+
+    # AND we should have invoked the Code with the expected inputs
+    vellum_client.execute_code.assert_called_once_with(
+        input_values=[
+            StringInput(name="word", value="hello"),
+        ],
+        code="""\
+def main(word: str) -> int:
+    print(word)  # noqa: T201
+    return len(word)
+""",
+        runtime="PYTHON_3_11_6",
+        output_type="NUMBER",
+        packages=[],
+        request_options=None,
+    )
+
+
+def test_run_workflow__code_and_filepath_defined(vellum_client):
+    """Confirm that CodeExecutionNodes raise an error if both `code` and `filepath` are defined."""
+
+    # GIVEN a node that subclasses CodeExecutionNode
+    class Inputs(BaseInputs):
+        word: str
+
+    class State(BaseState):
+        pass
+
+    fixture = os.path.abspath(os.path.join(__file__, "../fixtures/main.py"))
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        filepath = fixture
+        code = """\
+def main(word: str) -> int:
+    print(word)  # noqa: T201
+    return len(word)
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": Inputs.word,
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="hello",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(word="hello")),
+        )
+    )
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN the node should have produced the exception we expected
+    assert exc_info.value.message == "Cannot specify both `code` and `filepath` for a CodeExecutionNode"
+
+
+def test_run_workflow__code_and_filepath_not_defined(vellum_client):
+    """Confirm that CodeExecutionNodes raise an error if neither `code` nor `filepath` are defined."""
+
+    # GIVEN a node that subclasses CodeExecutionNode
+    class Inputs(BaseInputs):
+        word: str
+
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": Inputs.word,
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="hello",
+        output=NumberVellumValue(value=5),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(word="hello")),
+        )
+    )
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN the node should have produced the exception we expected
+    assert exc_info.value.message == "Must specify either `code` or `filepath` for a CodeExecutionNode"
+
+
 def test_run_workflow__vellum_secret(vellum_client):
     """Confirm that CodeExecutionNodes can use Vellum Secrets"""
 

{vellum_ai-0.11.8.dist-info → vellum_ai-0.11.10.dist-info}/METADATA

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

{vellum_ai-0.11.8.dist-info → vellum_ai-0.11.10.dist-info}/RECORD

@@ -1,17 +1,17 @@
 vellum_cli/CONTRIBUTING.md,sha256=FtDC7BGxSeMnwCXAUssFsAIElXtmJE-O5Z7BpolcgvI,2935
 vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
-vellum_cli/__init__.py,sha256=pftUQ6FiyfebNEB8xcfwzLjpfFDCAiH15xHBU6xr_wY,6733
+vellum_cli/__init__.py,sha256=XG6aC1NSPfBjNFzqiy9Lbk4DnELCKO8lpIZ3jeJR0r0,6990
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
 vellum_cli/config.py,sha256=wJQnv3tCgu1BOugg0AOP94yQ-x1yAg8juX_QoFN9Y7w,5223
 vellum_cli/image_push.py,sha256=SJwhwWJsLjwGNezNVd_oCVpFMfPsAB3dfLWmriZZUtw,4419
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
-vellum_cli/pull.py,sha256=6wIiorqSx2rmR6atZJHHBuLSviocxK_n0DQxEDGmCzo,4008
+vellum_cli/pull.py,sha256=EkQirsTe0KCpJ8oHTE3S9_M2XHSrb2wrXNq4hTkMZng,5770
 vellum_cli/push.py,sha256=kbvlzZ9KnkS5DxxKHQP5ZvHHk1-CbCDg9LqnIRAWyt4,5258
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=eFGwBxib3Nki830lIFintB0b6r4x8T_KMnmzhlTY5x0,1337
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
-vellum_cli/tests/test_pull.py,sha256=N6ZphvHYGokclbpbTpgOmpu_m2GtocDEesbdeHFjO5Y,13194
+vellum_cli/tests/test_pull.py,sha256=pGqpBkahC360UITDE8BlcJ7LPd9DyRPn4NrCNdkQmAQ,15907
 vellum_cli/tests/test_push.py,sha256=V2iGcskh2X3OHj2uV5Vx_BhmtyfmUkyx0lrp8DDOExc,5824
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,7 +20,7 @@ vellum_ee/workflows/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 vellum_ee/workflows/display/base.py,sha256=3ZFUYRNKL24fBqXhKpa_Dq2W1a-a86J20dmJYA3H2eY,1755
 vellum_ee/workflows/display/nodes/__init__.py,sha256=5XOcZJXYUgaLS55QgRJzyQ_W1tpeprjnYAeYVezqoGw,160
 vellum_ee/workflows/display/nodes/base_node_display.py,sha256=3W7X1V2Lv0k6djYp60LDu-0lYVMNsEjPXmNmIQ4UW6s,5961
-vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=HoD3AGCMXKoHyyRJteUYlQ7DR26Srjhlrv4fZlLCyKc,1649
+vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=F30B7L3HJLdeYzQmn17KVduWWXPb3KFvFFEVltYWxvY,2124
 vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=xg6DWEm8CDiOn_fX74fT2XtSEDCnq06dHKj7HX9JnJw,907
 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=0y20AAqDivg58hQjHbiCPjEdEghfWmWr-NdYw3u-AwM,1054
@@ -28,7 +28,7 @@ vellum_ee/workflows/display/nodes/types.py,sha256=St1BB6no528OyELGiyRabWao0GGw6m
 vellum_ee/workflows/display/nodes/utils.py,sha256=sloya5TpXsnot1HURc9L51INwflRqUzHxRVnCS9Cd-4,973
 vellum_ee/workflows/display/nodes/vellum/__init__.py,sha256=nmPLj8vkbVCS46XQqmHq8Xj8Mr36wCK_vWf26A9KIkw,1505
 vellum_ee/workflows/display/nodes/vellum/api_node.py,sha256=4SSQGecKWHuoGy5YIGJeOZVHGKwTs_8Y-gf3GvsHb0M,8506
-vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=HzB4zQ6MYlRII9GsZcBPzOswFUuwBjn-b3FuDLNyujg,4025
+vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=qJXUTVGfL88Katxu6HQb4yCPUzBFTBFDXcf8pdId3U8,4076
 vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=gUbSP8_oSAMNIb0CGiefd2FMYgoO6wMoG6iA1FakMjk,13293
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=ygTjSjYDI4DtkxADWub5rhBnRWItMKWF6fezBrgpOKA,1979
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=UezalObmZ3mcg7Nou2RgiI_0cmc7_tSdZLNB591iCcI,2772
@@ -73,13 +73,13 @@ vellum_ee/workflows/display/vellum.py,sha256=OSv0ZS50h1zJbunJ9TH7VEWFw-exXdK_Zsd
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
 vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=HkakkrNgVFoHlUP7yHlQjHOvii3CZ90iyU1062PfoW4,12819
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=AMxNnTm2z3LIR5rqxoCAfuy37F2FTuSRDVtKUoezO8M,1184
-vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=UiE1vJ4nzt1tHAxvXSt8qnV101I__gd5YdiPuKA4TWk,17370
+vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=DWaiYdP138kN3fbQvloh6VEBPlxzd6zSLydc6NpYu3s,17145
 vellum/__init__.py,sha256=QmGeEPXeFxgkZa849KKK3wH3Y641wyt00Rytfay6KiM,35520
 vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=o4m7iRZWEV8rP3GkdaztHAjNmjxjWERlarviFoHzuKI,110927
 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=KtxhfH7jJZXfEPTJ_JeglwXX43TbY0JGd81hjEJN-Gw,1890
+vellum/client/core/client_wrapper.py,sha256=6zb4goHdzGRX1BY9bkyHFFaNstiWKUbnXvOxT_2cidM,1891
 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
@@ -1302,11 +1302,11 @@ vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=1_OXD
 vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=MdrAKN8QGPk_JnNjbEBaVVKwVLPE2judbBcWuYJgbkY,4964
 vellum/workflows/nodes/displayable/bases/search_node.py,sha256=S7J8tTW681O4wcWYerGOfH6h-_BlE8-JMJHpW8eCVG0,3564
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
-vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=uwT_sn-XT0uYe7E-0DcJfcb3X33pwE0sw-2ri7FhoTo,8073
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=OHU9SnB0JDTTSFIp7io-9Jckelqtq84AP-QOcZBRNXY,8640
 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=2Kr7fKtjc1fW5z_6z6noKfWoETIVJbYi0AGhhSw-hsU,3376
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=s93M_EnU-4n60iSKv3FCf0kppwzFH5FNi9o9E58fQ3I,7510
 vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=LfI3kj2zQz6UGMld_uA9z2LjZobqRcgxQO4jdUWkg7o,376
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=REFZdEVetXGyOK1RbIN1T6yRblrP0hfyZUls2KfjTKg,1016
@@ -1378,8 +1378,8 @@ vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
 vellum/workflows/workflows/base.py,sha256=mnI-kZ78yt7u6NFSTUo-tYjDnarP-RJ7uZjwjCn6PCQ,16795
 vellum/workflows/workflows/event_filters.py,sha256=-uQcMB7IpPd-idMku8f2QNVhPXPFWo6FZLlGjRf8rCo,1996
-vellum_ai-0.11.8.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.11.8.dist-info/METADATA,sha256=7H-xm-0FDR9QYaVdqlM8w4rVbWfsK9-0osBbv0npgWk,5128
-vellum_ai-0.11.8.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-vellum_ai-0.11.8.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.11.8.dist-info/RECORD,,
+vellum_ai-0.11.10.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.11.10.dist-info/METADATA,sha256=mPMns1QolQ74Dw64M1w0SbtZXWFMMpEfK7VBYRrAmj8,5129
+vellum_ai-0.11.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.11.10.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.11.10.dist-info/RECORD,,

{vellum_ai-0.11.8.dist-info → vellum_ai-0.11.10.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

vellum_cli/__init__.py

@@ -148,6 +148,11 @@ def pull(
 Should only be used for debugging purposes.""",
 )
 @click.option("--workflow-sandbox-id", type=str, help="Pull the Workflow from a specific Sandbox ID")
+@click.option(
+    "--workflow-deployment",
+    type=str,
+    help="""Pull the Workflow from a specific Deployment. Can use the name or the ID of the Deployment.""",
+)
 @click.option(
     "--exclude-code",
     is_flag=True,
@@ -158,6 +163,7 @@ def workflows_pull(
     module: Optional[str],
     include_json: Optional[bool],
     workflow_sandbox_id: Optional[str],
+    workflow_deployment: Optional[str],
     exclude_code: Optional[bool],
 ) -> None:
     """
@@ -169,6 +175,7 @@ def workflows_pull(
         module=module,
         include_json=include_json,
         workflow_sandbox_id=workflow_sandbox_id,
+        workflow_deployment=workflow_deployment,
         exclude_code=exclude_code,
     )
 

vellum_cli/pull.py

@@ -1,39 +1,84 @@
 import io
 import os
 from pathlib import Path
+from uuid import UUID
 import zipfile
-from typing import Optional
+from typing import Optional, Union
 
 from dotenv import load_dotenv
+from pydash import snake_case
 
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_cli.config import VellumCliConfig, WorkflowConfig, load_vellum_cli_config
 from vellum_cli.logger import load_cli_logger
 
 
-def resolve_workflow_config(
+def _is_valid_uuid(val: Union[str, UUID, None]) -> bool:
+    try:
+        UUID(str(val))
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+class WorkflowConfigResolutionResult(UniversalBaseModel):
+    workflow_config: Optional[WorkflowConfig] = None
+    pk: Optional[str] = None
+
+
+def _resolve_workflow_config(
     config: VellumCliConfig,
     module: Optional[str] = None,
     workflow_sandbox_id: Optional[str] = None,
-) -> Optional[WorkflowConfig]:
+    workflow_deployment: Optional[str] = None,
+) -> WorkflowConfigResolutionResult:
+    if workflow_sandbox_id and workflow_deployment:
+        raise ValueError("Cannot specify both workflow_sandbox_id and workflow_deployment")
+
     if module:
-        return next((w for w in config.workflows if w.module == module), None)
+        workflow_config = next((w for w in config.workflows if w.module == module), None)
+        return WorkflowConfigResolutionResult(
+            workflow_config=workflow_config,
+            pk=workflow_config.workflow_sandbox_id if workflow_config else None,
+        )
     elif workflow_sandbox_id:
         workflow_config = WorkflowConfig(
             workflow_sandbox_id=workflow_sandbox_id,
             module=f"workflow_{workflow_sandbox_id.split('-')[0]}",
         )
         config.workflows.append(workflow_config)
-        return workflow_config
+        return WorkflowConfigResolutionResult(
+            workflow_config=workflow_config,
+            pk=workflow_config.workflow_sandbox_id,
+        )
+    elif workflow_deployment:
+        module = (
+            f"workflow_{workflow_deployment.split('-')[0]}"
+            if _is_valid_uuid(workflow_deployment)
+            else snake_case(workflow_deployment)
+        )
+        workflow_config = WorkflowConfig(
+            module=module,
+        )
+        config.workflows.append(workflow_config)
+        return WorkflowConfigResolutionResult(
+            workflow_config=workflow_config,
+            pk=workflow_deployment,
+        )
     elif config.workflows:
-        return config.workflows[0]
+        return WorkflowConfigResolutionResult(
+            workflow_config=config.workflows[0],
+            pk=config.workflows[0].workflow_sandbox_id,
+        )
 
-    return None
+    return WorkflowConfigResolutionResult()
 
 
 def pull_command(
     module: Optional[str] = None,
     workflow_sandbox_id: Optional[str] = None,
+    workflow_deployment: Optional[str] = None,
     include_json: Optional[bool] = None,
     exclude_code: Optional[bool] = None,
 ) -> None:
@@ -41,17 +86,20 @@ def pull_command(
     logger = load_cli_logger()
     config = load_vellum_cli_config()
 
-    workflow_config = resolve_workflow_config(
-        config,
-        module,
-        workflow_sandbox_id,
+    workflow_config_result = _resolve_workflow_config(
+        config=config,
+        module=module,
+        workflow_sandbox_id=workflow_sandbox_id,
+        workflow_deployment=workflow_deployment,
     )
     save_lock_file = not module
 
+    workflow_config = workflow_config_result.workflow_config
     if not workflow_config:
         raise ValueError("No workflow config found in project to pull from.")
 
-    if not workflow_config.workflow_sandbox_id:
+    pk = workflow_config_result.pk
+    if not pk:
         raise ValueError("No workflow sandbox ID found in project to pull from.")
 
     logger.info(f"Pulling workflow into {workflow_config.module}")
@@ -63,7 +111,7 @@ def pull_command(
         query_parameters["exclude_code"] = exclude_code
 
     response = client.workflows.pull(
-        workflow_config.workflow_sandbox_id,
+        pk,
         request_options={"additional_query_parameters": query_parameters},
     )
 

vellum_cli/tests/test_pull.py

@@ -164,6 +164,86 @@ def test_pull__sandbox_id_with_other_workflow_configured(vellum_client, mock_mod
         assert f.read() == "print('hello')"
 
 
+def test_pull__workflow_deployment_with_no_config(vellum_client):
+    # GIVEN a workflow deployment
+    workflow_deployment = "my-deployment"
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
+
+    # AND we are currently in a new directory
+    current_dir = os.getcwd()
+    temp_dir = tempfile.mkdtemp()
+    os.chdir(temp_dir)
+
+    # WHEN the user runs the pull command with the workflow deployment
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-deployment", workflow_deployment])
+    os.chdir(current_dir)
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0
+
+    # AND the pull api is called with the workflow deployment
+    vellum_client.workflows.pull.assert_called_once()
+    workflow_py = os.path.join(temp_dir, "my_deployment", "workflow.py")
+    assert os.path.exists(workflow_py)
+    with open(workflow_py) as f:
+        assert f.read() == "print('hello')"
+
+    # AND the vellum.lock.json file is created
+    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    assert os.path.exists(vellum_lock_json)
+    with open(vellum_lock_json) as f:
+        lock_data = json.loads(f.read())
+        assert lock_data == {
+            "version": "1.0",
+            "workflows": [
+                {
+                    "module": "my_deployment",
+                    "workflow_sandbox_id": None,
+                    "ignore": None,
+                    "deployments": [],
+                }
+            ],
+        }
+
+
+def test_pull__both_workflow_sandbox_id_and_deployment(vellum_client):
+    # GIVEN a workflow sandbox id
+    workflow_sandbox_id = "87654321-0000-0000-0000-000000000000"
+
+    # AND a workflow deployment
+    workflow_deployment = "my-deployment"
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
+
+    # AND we are currently in a new directory
+    current_dir = os.getcwd()
+    temp_dir = tempfile.mkdtemp()
+    os.chdir(temp_dir)
+
+    # WHEN the user runs the pull command with the workflow deployment
+    runner = CliRunner()
+    result = runner.invoke(
+        cli_main,
+        [
+            "workflows",
+            "pull",
+            "--workflow-sandbox-id",
+            workflow_sandbox_id,
+            "--workflow-deployment",
+            workflow_deployment,
+        ],
+    )
+    os.chdir(current_dir)
+
+    # THEN the command returns successfully
+    assert result.exit_code == 1
+    assert "Cannot specify both workflow_sandbox_id and workflow_deployment" == str(result.exception)
+
+
 def test_pull__remove_missing_files(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
     temp_dir = mock_module.temp_dir

vellum_ee/workflows/display/nodes/base_node_vellum_display.py

@@ -30,6 +30,15 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
     def get_target_handle_id(self) -> UUID:
         return self._get_node_display_uuid("target_handle_id")
 
+    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
+        """
+        In the vast majority of cases, nodes will only have a single target handle and can be retrieved independently
+        of the source node. However, in rare cases (such as legacy Merge nodes), this method can be overridden to
+        account for the case of retrieving one amongst multiple target handles on a node.
+        """
+
+        return self.get_target_handle_id()
+
     def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
         default_port = self._node.Ports.default
         default_port_display = port_displays[default_port]

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

@@ -30,7 +30,10 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
         node_id = self.node_id
 
         node_file_path = inspect.getfile(node)
-        code = read_file_from_path(node_filepath=node_file_path, script_filepath=(raise_if_descriptor(node.filepath)))
+        code = read_file_from_path(
+            node_filepath=node_file_path,
+            script_filepath=(raise_if_descriptor(node.filepath)),  # type: ignore
+        )
         code_inputs = raise_if_descriptor(node.code_inputs)
 
         inputs = [

vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -12,7 +12,6 @@ from vellum.workflows.references import WorkflowInputReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
-from vellum_ee.workflows.display.nodes import BaseMergeNodeDisplay
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.types import PortDisplay
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -369,10 +368,7 @@ class VellumWorkflowDisplay(
         target_node_id = target_node_display.node_id
 
         target_handle_id: UUID
-        if isinstance(target_node_display, BaseMergeNodeDisplay):
-            target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(source_node_id)
-        else:
-            target_handle_id = target_node_display.get_target_handle_id()
+        target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(source_node_id)
 
         return self._generate_edge_display_from_source(
             source_node_id, source_handle_id, target_node_id, target_handle_id, overrides