vellum-ai 0.14.50__py3-none-any.whl → 0.14.52__py3-none-any.whl

vellum/client/__init__.py

@@ -133,11 +133,15 @@ class Vellum:
         self._client_wrapper = SyncClientWrapper(
             environment=environment,
             api_key=api_key,
-            httpx_client=httpx_client
-            if httpx_client is not None
-            else httpx.Client(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
-            if follow_redirects is not None
-            else httpx.Client(timeout=_defaulted_timeout),
+            httpx_client=(
+                httpx_client
+                if httpx_client is not None
+                else (
+                    httpx.Client(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+                    if follow_redirects is not None
+                    else httpx.Client(timeout=_defaulted_timeout)
+                )
+            ),
             timeout=_defaulted_timeout,
         )
         self.ad_hoc = AdHocClient(client_wrapper=self._client_wrapper)
@@ -1442,7 +1446,9 @@ class Vellum:
             method="POST",
             json={
                 "actuals": convert_and_respect_annotation_metadata(
-                    object_=actuals, annotation=typing.Sequence[SubmitWorkflowExecutionActualRequest], direction="write"
+                    object_=actuals,
+                    annotation=typing.Sequence[SubmitWorkflowExecutionActualRequest],
+                    direction="write",
                 ),
                 "execution_id": execution_id,
                 "external_id": external_id,
@@ -1509,11 +1515,15 @@ class AsyncVellum:
         self._client_wrapper = AsyncClientWrapper(
             environment=environment,
             api_key=api_key,
-            httpx_client=httpx_client
-            if httpx_client is not None
-            else httpx.AsyncClient(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
-            if follow_redirects is not None
-            else httpx.AsyncClient(timeout=_defaulted_timeout),
+            httpx_client=(
+                httpx_client
+                if httpx_client is not None
+                else (
+                    httpx.AsyncClient(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+                    if follow_redirects is not None
+                    else httpx.AsyncClient(timeout=_defaulted_timeout)
+                )
+            ),
             timeout=_defaulted_timeout,
         )
         self.ad_hoc = AsyncAdHocClient(client_wrapper=self._client_wrapper)
@@ -2906,7 +2916,9 @@ class AsyncVellum:
             method="POST",
             json={
                 "actuals": convert_and_respect_annotation_metadata(
-                    object_=actuals, annotation=typing.Sequence[SubmitWorkflowExecutionActualRequest], direction="write"
+                    object_=actuals,
+                    annotation=typing.Sequence[SubmitWorkflowExecutionActualRequest],
+                    direction="write",
                 ),
                 "execution_id": execution_id,
                 "external_id": external_id,

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.50",
+            "X-Fern-SDK-Version": "0.14.52",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/client/resources/workflows/client.py

@@ -69,8 +69,7 @@ class WorkflowsClient:
             try:
                 if 200 <= _response.status_code < 300:
                     _chunk_size = request_options.get("chunk_size", None) if request_options is not None else None
-                    for _chunk in _response.iter_bytes(chunk_size=_chunk_size):
-                        yield _chunk
+                    yield from _response.iter_bytes(chunk_size=_chunk_size)
                     return
                 _response.read()
                 if _response.status_code == 400:

vellum/client/types/ml_model_usage_wrapper.py

@@ -8,8 +8,8 @@ import pydantic
 
 
 class MlModelUsageWrapper(UniversalBaseModel):
-    ml_model_usage: MlModelUsage
     ml_model_name: str
+    ml_model_usage: MlModelUsage
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

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

@@ -194,7 +194,7 @@ def test_map_node_parallel_execution_with_workflow():
             thread_ids[self.item] = current_thread_id
 
             # Simulate work
-            time.sleep(0.01)
+            time.sleep(0.1)
 
             end = time.time()
             end_str = datetime.datetime.fromtimestamp(end).strftime("%Y-%m-%d %H:%M:%S.%f")

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -18,9 +18,9 @@ from vellum import (
 )
 from vellum.client import ApiError, RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
+from vellum.client.types.prompt_exec_config import PromptExecConfig
 from vellum.client.types.prompt_settings import PromptSettings
 from vellum.client.types.rich_text_child_block import RichTextChildBlock
-from vellum.workflows.constants import OMIT
 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
@@ -56,7 +56,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
     functions: Optional[List[Union[FunctionDefinition, Callable]]] = None
 
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
-    expand_meta: Optional[AdHocExpandMeta] = OMIT
+    expand_meta: Optional[AdHocExpandMeta] = None
 
     settings: Optional[PromptSettings] = None
 
@@ -135,6 +135,23 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
             )
 
     def _process_prompt_event_stream(self) -> Generator[BaseOutput, None, Optional[List[PromptOutput]]]:
+        try:
+            # Compile dict blocks into PromptBlocks
+            exec_config = PromptExecConfig.model_validate(
+                {
+                    "ml_model": "",
+                    "input_variables": [],
+                    "parameters": {},
+                    "blocks": self.blocks,
+                }
+            )
+            self.blocks = exec_config.blocks  # type: ignore
+        except Exception:
+            raise NodeException(
+                message="Failed to compile blocks",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
         self._validate()
         try:
             prompt_event_stream = self._get_prompt_event_stream()

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -270,7 +270,7 @@ def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -350,7 +350,7 @@ def test_inline_prompt_node__streaming_disabled(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -444,7 +444,7 @@ def test_inline_prompt_node__json_output_with_streaming_disabled(vellum_adhoc_pr
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],
@@ -473,3 +473,149 @@ def test_inline_prompt_node__json_output_with_streaming_disabled(vellum_adhoc_pr
         request_options=mock.ANY,
         settings=PromptSettings(stream_enabled=False),
     )
+
+
+def test_inline_prompt_node__dict_blocks(vellum_adhoc_prompt_client):
+    # GIVEN a node that has dict blocks
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [
+            {  # type: ignore
+                "state": None,
+                "blocks": [
+                    {
+                        "state": None,
+                        "blocks": [
+                            {
+                                "text": "You are a weather expert",
+                                "state": None,
+                                "block_type": "PLAIN_TEXT",
+                                "cache_config": None,
+                            }
+                        ],
+                        "block_type": "RICH_TEXT",
+                        "cache_config": None,
+                    }
+                ],
+                "chat_role": "SYSTEM",
+                "block_type": "CHAT_MESSAGE",
+                "chat_source": None,
+                "cache_config": None,
+                "chat_message_unterminated": None,
+            },
+            {  # type: ignore
+                "state": None,
+                "blocks": [
+                    {
+                        "state": None,
+                        "blocks": [
+                            {
+                                "state": None,
+                                "block_type": "VARIABLE",
+                                "cache_config": None,
+                                "input_variable": "question",
+                            }
+                        ],
+                        "block_type": "RICH_TEXT",
+                        "cache_config": None,
+                    }
+                ],
+                "chat_role": "USER",
+                "block_type": "CHAT_MESSAGE",
+                "chat_source": None,
+                "cache_config": None,
+                "chat_message_unterminated": None,
+            },
+            VariablePromptBlock(block_type="VARIABLE", state=None, cache_config=None, input_variable="chat_history"),
+        ]
+        prompt_inputs = {
+            "question": "What is the weather in Tokyo?",
+            "chat_history": "You are a weather expert",
+        }
+        settings = PromptSettings(stream_enabled=False)
+
+    # AND a known JSON response from invoking an inline prompt
+    expected_json = {"result": "Hello, world!"}
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value=json.dumps(expected_json)),
+    ]
+
+    def generate_prompt_event(*args: Any, **kwargs: Any) -> AdHocExecutePromptEvent:
+        execution_id = str(uuid4())
+        return FulfilledAdHocExecutePromptEvent(
+            execution_id=execution_id,
+            outputs=expected_outputs,
+        )
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt.side_effect = generate_prompt_event
+
+    # WHEN the node is run
+    node = MyInlinePromptNode()
+    outputs = [o for o in node.run()]
+
+    # THEN the node should have produced the outputs we expect
+    results_output = outputs[0]
+    assert results_output.name == "results"
+    assert results_output.value == expected_outputs
+
+    text_output = outputs[1]
+    assert text_output.name == "text"
+    assert text_output.value == '{"result": "Hello, world!"}'
+
+
+def test_inline_prompt_node__dict_blocks_error(vellum_adhoc_prompt_client):
+    # GIVEN a node that has an error (wrong block type)
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [
+            {  # type: ignore
+                "state": None,
+                "blocks": [
+                    {
+                        "state": None,
+                        "blocks": [
+                            {
+                                "text": "You are a weather expert",
+                                "state": None,
+                                "block_type": "PLAIN_TEXT",
+                                "cache_config": None,
+                            }
+                        ],
+                        "block_type": "WRONG_BLOCK_TYPE",
+                        "cache_config": None,
+                    }
+                ],
+                "chat_role": "SYSTEM",
+                "block_type": "CHAT_MESSAGE",
+                "chat_source": None,
+                "cache_config": None,
+                "chat_message_unterminated": None,
+            },
+        ]
+        prompt_inputs = {
+            "question": "What is the weather in Tokyo?",
+        }
+        settings = PromptSettings(stream_enabled=False)
+
+    # AND a known JSON response from invoking an inline prompt
+    expected_json = {"result": "Hello, world!"}
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value=json.dumps(expected_json)),
+    ]
+
+    def generate_prompt_event(*args: Any, **kwargs: Any) -> AdHocExecutePromptEvent:
+        execution_id = str(uuid4())
+        return FulfilledAdHocExecutePromptEvent(
+            execution_id=execution_id,
+            outputs=expected_outputs,
+        )
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt.side_effect = generate_prompt_event
+
+    node = MyInlinePromptNode()
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # THEN the node should raise the correct NodeException
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Failed to compile blocks" == str(excinfo.value)

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

@@ -1,6 +1,8 @@
+import json
 from typing import ClassVar
 
 from vellum.workflows.nodes.displayable.bases import BaseSearchNode as BaseSearchNode
+from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -33,6 +35,9 @@ class SearchNode(BaseSearchNode[StateType]):
         text: str
 
     def run(self) -> Outputs:
+        if not isinstance(self.query, str):
+            self.query = json.dumps(self.query, cls=DefaultStateEncoder)
+
         results = self._perform_search().results
         text = self.chunk_separator.join([r.text for r in results])
         return self.Outputs(results=results, text=text)

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

@@ -1,4 +1,7 @@
+import json
+
 from vellum import SearchResponse, SearchResult, SearchResultDocument
+from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.json_vellum_value_request import JsonVellumValueRequest
 from vellum.client.types.search_filters_request import SearchFiltersRequest
 from vellum.client.types.search_request_options_request import SearchRequestOptionsRequest
@@ -13,6 +16,7 @@ from vellum.workflows.nodes.displayable.bases.types import (
     SearchFilters,
 )
 from vellum.workflows.nodes.displayable.search_node.node import SearchNode
+from vellum.workflows.state.base import BaseState
 
 
 def test_run_workflow__happy_path(vellum_client):
@@ -172,3 +176,42 @@ def test_run_workflow__happy_path__options_attribute(vellum_client):
             ),
         ),
     )
+
+
+def test_run_workflow__chat_history_as_query(vellum_client):
+    """
+    Confirm that we can successfully invoke a Search node with a chat history as the query param,
+    backwards compatible with original workflows
+    """
+
+    # GIVEN a state definition with a chat history
+    class MyState(BaseState):
+        chat_history: list[ChatMessage]
+
+    # AND a Search Node that uses the chat history as the query param
+    class MySearchNode(SearchNode[MyState]):
+        query = MyState.chat_history  # type: ignore[assignment]
+        document_index = "document_index"
+        limit = 1
+
+    # AND a Search request that will return a 200 ok resposne
+    search_response = SearchResponse(
+        results=[
+            SearchResult(
+                text="Search query", score="0.0", keywords=["keywords"], document=SearchResultDocument(label="label")
+            )
+        ]
+    )
+
+    vellum_client.search.return_value = search_response
+
+    # WHEN we run the workflow
+    outputs = MySearchNode(state=MyState(chat_history=[ChatMessage(role="USER", text="Hello, world!")])).run()
+
+    # THEN the workflow should have completed successfully
+    assert outputs.text == "Search query"
+
+    # AND the options should be as expected
+    assert json.loads(vellum_client.search.call_args.kwargs["query"]) == [
+        {"role": "USER", "text": "Hello, world!", "source": None, "content": None}
+    ]

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

@@ -74,7 +74,7 @@ def test_inline_text_prompt_node__basic(vellum_adhoc_prompt_client):
     # AND we should have made the expected call to Vellum search
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
-        expand_meta=Ellipsis,
+        expand_meta=None,
         functions=None,
         input_values=[],
         input_variables=[],

vellum/workflows/nodes/experimental/__init__.py

@@ -0,0 +1,3 @@
+from .tool_calling_node import ToolCallingNode
+
+__all__ = ["ToolCallingNode"]

vellum/workflows/nodes/experimental/tool_calling_node/tests/test_tool_calling_node.py

@@ -0,0 +1,53 @@
+from vellum.client.types.function_call import FunctionCall
+from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
+from vellum.workflows.nodes.experimental.tool_calling_node.utils import create_tool_router_node
+from vellum.workflows.state.base import BaseState, StateMeta
+
+
+def first_function() -> str:
+    return "first_function"
+
+
+def second_function() -> str:
+    return "second_function"
+
+
+def test_port_condition_match_function_name():
+    """
+    Test that the port condition correctly matches the function name.
+    """
+    # GIVEN a tool router node
+    router_node = create_tool_router_node(
+        ml_model="test-model",
+        blocks=[],
+        functions=[first_function, second_function],
+        prompt_inputs=None,
+    )
+
+    # AND a state with a function call to the first function
+    state = BaseState(
+        meta=StateMeta(
+            node_outputs={
+                router_node.Outputs.results: [
+                    FunctionCallVellumValue(
+                        value=FunctionCall(
+                            arguments={}, id="call_zp7pBQjGAOBCr7lo0AbR1HXT", name="first_function", state="FULFILLED"
+                        ),
+                    )
+                ],
+            },
+        )
+    )
+
+    # WHEN the port condition is resolved
+    # THEN the first function port should be true
+    first_function_port = getattr(router_node.Ports, "first_function")
+    assert first_function_port.resolve_condition(state) is True
+
+    # AND the second function port should be false
+    second_function_port = getattr(router_node.Ports, "second_function")
+    assert second_function_port.resolve_condition(state) is False
+
+    # AND the default port should be false
+    default_port = getattr(router_node.Ports, "default")
+    assert default_port.resolve_condition(state) is False

vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -57,12 +57,19 @@ def create_tool_router_node(
     Ports = type("Ports", (), {})
     for function in functions:
         function_name = function.__name__
-        port_condition = LazyReference(
-            lambda: (
-                node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
-                & node.Outputs.results[0]["value"]["name"].equals(function_name)
+
+        # Avoid using lambda to capture function_name
+        # lambda will capture the function_name by reference,
+        # and if the function_name is changed, the port_condition will also change.
+        def create_port_condition(fn_name):
+            return LazyReference(
+                lambda: (
+                    node.Outputs.results[0]["type"].equals("FUNCTION_CALL")
+                    & node.Outputs.results[0]["value"]["name"].equals(fn_name)
+                )
             )
-        )
+
+        port_condition = create_port_condition(function_name)
         port = Port.on_if(port_condition)
         setattr(Ports, function_name, port)
 

{vellum_ai-0.14.50.dist-info → vellum_ai-0.14.52.dist-info}/METADATA

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

{vellum_ai-0.14.50.dist-info → vellum_ai-0.14.52.dist-info}/RECORD

@@ -1,14 +1,14 @@
 vellum_cli/CONTRIBUTING.md,sha256=FtDC7BGxSeMnwCXAUssFsAIElXtmJE-O5Z7BpolcgvI,2935
 vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
-vellum_cli/__init__.py,sha256=sCNP_hmFCexEWp1oQdpj8QsIUiAbo4MIlTalZEFruD8,12398
+vellum_cli/__init__.py,sha256=2_6oGoVcLFUh4L63Kz4SBL4Y6XevJ70oYbg7BJ3cb5Q,12569
 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=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
-vellum_cli/pull.py,sha256=2hSJGeqooevMb--mcvRLQ1GYT-9290cI7VdSRifzmTg,12561
-vellum_cli/push.py,sha256=nWHLDi_w0LXycNkVv00CiNwY469BcTNBn7NphWpCA7E,9711
+vellum_cli/pull.py,sha256=M50yXzA_35N35gk1Y8KjLbXrzdRG86--XFQvEukxGtA,13371
+vellum_cli/push.py,sha256=9oYmYhIWln3U0g7AstWEOA6ng5W_RthUA-Fie8FalFE,9846
 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
@@ -16,8 +16,8 @@ vellum_cli/tests/test_image_push.py,sha256=QM-JlR_aJappvwbCLteQZZf76sd7SE1sRj3ar
 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
-vellum_cli/tests/test_pull.py,sha256=iTxVbJGuehvgNt8Vp9W3Y5Bvaocfws8bl8LMGEbc_qQ,47508
-vellum_cli/tests/test_push.py,sha256=uNMmPG9Z0uRN6xYYMzBGZaCXJZkAHWcbcSJRJ4eQk70,31182
+vellum_cli/tests/test_pull.py,sha256=7HRAhIdkVW5mR2VckEaNDjp4rt-MlIxOWMMI2XNUPE8,49814
+vellum_cli/tests/test_push.py,sha256=K-TaOjU4mc-x0-ee1DNXT7yZBC0pEM-R9VY57kdMdmY,32849
 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
@@ -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=mzODbbNfrjOi7rVQb6FFCEjQHZkTs76nAc8L-Q5yCnQ,16491
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=2VyAk9SjBpt_b2fp81KlFxS5ddk2JhcldEI1S4crPj0,16921
 vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=jI_kUi9LnNLDpY63QtlC4TfN8P571VN4LpzH0I1ZtLk,1149
 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
@@ -40,7 +40,7 @@ vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=MrvyiYD0qgQf
 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=gVwQwycEPNtCs8tWbFyIMLpCA7zXnqcmuuhFqRWNxZM,10368
+vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=-6Ru9W_vfNdLKLStB40qicMx6WvdejPM3PE54Onqk5w,10943
 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
@@ -55,7 +55,7 @@ vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py,sha25
 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=RPpromm0y9y-MukL8cmxpl9hYaw-JuNo8vFDOcLI4V4,8801
+vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py,sha256=7GGbGhcaXkWqLoOU9dWWKFnjVVE_dId9vcKFYzpIHKg,9945
 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
@@ -95,7 +95,7 @@ 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=qsKRgxm9zKFgAgjc9LqKEWP1rtdzXA1NDsXu9kyhf60,12416
+vellum_ee/workflows/display/utils/expressions.py,sha256=8rwEsT99kSiCemIR7oFjlmphHoNqE5-7Fft5NdkWJ98,12419
 vellum_ee/workflows/display/utils/registry.py,sha256=fWIm5Jj-10gNFjgn34iBu4RWv3Vd15ijtSN0V97bpW8,1513
 vellum_ee/workflows/display/utils/vellum.py,sha256=mtoXmSYwR7rvrq-d6CzCW_auaJXTct0Mi1F0xpRCiNQ,5627
 vellum_ee/workflows/display/vellum.py,sha256=o7mq_vk2Yapu9DDKRz5l76h8EmCAypWGQYe6pryrbB8,3576
@@ -130,10 +130,10 @@ vellum_ee/workflows/tests/test_server.py,sha256=SsOkS6sGO7uGC4mxvk4iv8AtcXs058P9
 vellum_ee/workflows/tests/test_virtual_files.py,sha256=TJEcMR0v2S8CkloXNmCHA0QW0K6pYNGaIjraJz7sFvY,2762
 vellum/__init__.py,sha256=Hqfl49WZJzzqOKzVsTGi-j9twIqFOoRmACJsrEsjL44,41918
 vellum/client/README.md,sha256=qmaVIP42MnxAu8jV7u-CsgVFfs3-pHQODrXdZdFxtaw,4749
-vellum/client/__init__.py,sha256=PEnFl7LbXQcvAi3bVN2qyt5xm2FtVtq7xWKkcWM3Tg4,120166
+vellum/client/__init__.py,sha256=nv_MItkRFOTsTDcray01bea7NvO-P9bAj8lnUfTbxOo,120440
 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=0Uo8ifbV1rC2jIjuU95Td5DeLVDs0xqQP3DETAbhbEU,1869
+vellum/client/core/client_wrapper.py,sha256=P667a77GUeHTNshBFAxTS1VkSHNO_joyM4HtqkCS-8o,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
@@ -196,7 +196,7 @@ vellum/client/resources/workflow_sandboxes/client.py,sha256=XfMcbvSTF1_iTGIXsk1F
 vellum/client/resources/workflow_sandboxes/types/__init__.py,sha256=EaGVRU1w6kJiiHrbZOeEa0c3ggjfgv_jBqsyOkCRWOI,212
 vellum/client/resources/workflow_sandboxes/types/list_workflow_sandbox_examples_request_tag.py,sha256=TEwWit20W3X-zWPPLAhmUG05UudG9gaBSJ4Q4-rNJws,188
 vellum/client/resources/workflows/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
-vellum/client/resources/workflows/client.py,sha256=uDC61aybVmgxPiLKuLpAB-fK3sagnFFX06zzmQngInA,11285
+vellum/client/resources/workflows/client.py,sha256=OwpMojUEZ6DdtqW5Q-165SCthYFbzt3IBVKHR5-4h-0,11244
 vellum/client/resources/workspace_secrets/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 vellum/client/resources/workspace_secrets/client.py,sha256=zlBdbeTP6sqvtyl_DlrpfG-W5hSP7tJ1NYLSygi4CLU,8205
 vellum/client/resources/workspaces/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
@@ -404,7 +404,7 @@ vellum/client/types/metric_definition_input.py,sha256=4nmwpPqbeNQYCzLkXCkc-FGV5K
 vellum/client/types/metric_node_result.py,sha256=YdKq1DZiBD1RBtjyMejImylv3BqrwY8B_UF4Ij-6_64,660
 vellum/client/types/ml_model_read.py,sha256=Vr5KjaS2Tca0GXsltfSYQpuyGYpgIahPEFfS6HfFGSo,706
 vellum/client/types/ml_model_usage.py,sha256=WcZ2F1hfxyTwe-spOVwv-qJYDjs4hf9sn7BF2abawPo,910
-vellum/client/types/ml_model_usage_wrapper.py,sha256=K0V5O-NqB12FAKUcBb9r3b25u4x-4jFcef2-V1PQhMU,645
+vellum/client/types/ml_model_usage_wrapper.py,sha256=Vi7urVmTn1E_aZV6TxnW-qjDayRv7A_6JDk84KqAIa0,645
 vellum/client/types/named_scenario_input_chat_history_variable_value_request.py,sha256=aVZmAxu-47c34NyhSkfi9tQqIPy29cdJ7Pb4MIgKeNw,862
 vellum/client/types/named_scenario_input_json_variable_value_request.py,sha256=UgnKv70zFviv1kl4nM7aM7IFA-7xyDOtglW4Y3GBZ28,757
 vellum/client/types/named_scenario_input_request.py,sha256=Pi8l377OHvKBwvPu9slZ1omf_NJ9S1mCQ5Wr-Ux5KVg,611
@@ -1558,7 +1558,7 @@ vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=kU
 vellum/workflows/nodes/core/map_node/__init__.py,sha256=MXpZYmGfhsMJHqqlpd64WiJRtbAtAMQz-_3fCU_cLV0,56
 vellum/workflows/nodes/core/map_node/node.py,sha256=rbF7fLAU0vUDEpgtWqeQTZFlhWOhJw38tgxWJ6exud8,9313
 vellum/workflows/nodes/core/map_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=f3lSPYAU1vJUCLCujNOo0EAeBbOM9hnY5A1Wy58korc,6905
+vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=rf7CCDtjHxoPKeEtm9a8v_MNvkvu5UThH4xRXYrdEl8,6904
 vellum/workflows/nodes/core/retry_node/__init__.py,sha256=lN2bIy5a3Uzhs_FYCrooADyYU6ZGShtvLKFWpelwPvo,60
 vellum/workflows/nodes/core/retry_node/node.py,sha256=abtGvinLfi1tKqYIsWQKZtBUisF2Qw2yT1YoPw9cVk4,5297
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1582,9 +1582,9 @@ vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=amBXi7Tv50AbGLhfWbwX83PlOdV1XyYRyQmpa6_afE4,3511
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/constants.py,sha256=fnjiRWLoRlC4Puo5oQcpZD5Hd-EesxsAo9l5tGAkpZQ,270
-vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=wqN1EjyjTL6McUmlkHWu3GXVzcNaqDjavvmKUHDaVqg,10623
+vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=87Z4n1gsI3LMm0C4TaJ7nfykY8zKaKigOg7Da65E8YQ,11223
 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/inline_prompt_node/tests/test_inline_prompt_node.py,sha256=5CNag1_aEFZbCL0nrOC5e1L-t90-4rp2xDwh0h52hVI,21407
 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
@@ -1623,24 +1623,25 @@ vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=eUiQYdq
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py,sha256=c_nuuqrwiIjgj4qIbVypfDuOc-3TlgO6CbXFqQl2Nqw,19725
 vellum/workflows/nodes/displayable/search_node/__init__.py,sha256=hpBpvbrDYf43DElRZFLzieSn8weXiwNiiNOJurERQbs,62
-vellum/workflows/nodes/displayable/search_node/node.py,sha256=_VHHuTNN4icZBgc7O5U9SVKrv1zgKipU72fOtxTyrQU,1453
+vellum/workflows/nodes/displayable/search_node/node.py,sha256=vUTDyurYKw6KLABuVml_N_fbnNBDv5dBtejdoj82hWs,1646
 vellum/workflows/nodes/displayable/search_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/search_node/tests/test_node.py,sha256=2-QCV7Vk_-YMls33p0GOUtCv3f2uPNZCjkB2CRjek7o,6562
+vellum/workflows/nodes/displayable/search_node/tests/test_node.py,sha256=OserVd6jPe6t49MQF0cxphI2irBLaC_GceMr0acFqoY,8075
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py,sha256=9yYM6001YZeqI1VOk1QuEM_yrffk_EdsO7qaPzINKds,92
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=biv1H4gIX4B4VMFJ3Rp82NjE65GhmzLq7pREL0ozB2E,9484
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py,sha256=2KdPh1TeIeW_3xJq4QzAwfcuqL6PmMTLNPz4nSaDLmY,18030
 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_inline_text_prompt_node.py,sha256=MHuIolSsrY9ziwoXWsye3XOODncL9DLZOkNYzQMLhRw,4696
 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=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/__init__.py,sha256=_tpZGWAZLydcKxfrj1-plrZeTajskVhUr1A6mHoSaWM,78
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
 vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=cKI2Ls25L-JVt4z4a2ozQa-YBeVy21Z7BQ32Sj7iBPE,10460
 vellum/workflows/nodes/experimental/tool_calling_node/__init__.py,sha256=S7OzT3I4cyOU5Beoz87nPwCejCMP2FsHBFL8OcVmxJ4,118
 vellum/workflows/nodes/experimental/tool_calling_node/node.py,sha256=NUC7VZj2D86IDQzjCq_a3-Xeqj_b3BE8T1kOMIfN7V8,4878
-vellum/workflows/nodes/experimental/tool_calling_node/utils.py,sha256=_b4xqs2jEQY9aWCCJsFvZZrvXo74NeYiIkD7uJ9RHeU,4781
+vellum/workflows/nodes/experimental/tool_calling_node/tests/test_tool_calling_node.py,sha256=sxG26mOwt4N36RLoPJ-ngginPqC5qFzD_kGj9izdCFI,1833
+vellum/workflows/nodes/experimental/tool_calling_node/utils.py,sha256=cdFR0yeb0mDl5CmH27cYQWIb4STg-ZfqtuI6rW66AHo,5097
 vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWlyc,10455
 vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
@@ -1706,8 +1707,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.50.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.50.dist-info/METADATA,sha256=E3j3kzjmM-9HAa1xAKCgCf5JsoBVzbm7vadnxywpahY,5484
-vellum_ai-0.14.50.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.50.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.50.dist-info/RECORD,,
+vellum_ai-0.14.52.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.52.dist-info/METADATA,sha256=-vGzZDBmw_wd9r-qwKB7WAO8eJvsTB0_OGcEFjPwVU0,5484
+vellum_ai-0.14.52.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.52.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.52.dist-info/RECORD,,

vellum_cli/__init__.py

@@ -259,6 +259,11 @@ Helpful for running and debugging workflows locally.""",
     help="""Directory to pull the workflow into. If not specified, \
 the workflow will be pulled into the current working directory.""",
 )
+@click.option(
+    "--workspace",
+    type=str,
+    help="The specific Workspace config to use when pulling",
+)
 def workflows_pull(
     module: Optional[str],
     include_json: Optional[bool],
@@ -268,6 +273,7 @@ def workflows_pull(
     strict: Optional[bool],
     include_sandbox: Optional[bool],
     target_directory: Optional[str],
+    workspace: Optional[str],
 ) -> None:
     """
     Pull Workflows from Vellum. If a module is provided, only the Workflow for that module will be pulled.
@@ -283,6 +289,7 @@ def workflows_pull(
         strict=strict,
         include_sandbox=include_sandbox,
         target_directory=target_directory,
+        workspace=workspace,
     )
 
 

vellum_cli/pull.py

@@ -13,7 +13,13 @@ from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.vellum_client import create_vellum_client
-from vellum_cli.config import VellumCliConfig, WorkflowConfig, WorkflowDeploymentConfig, load_vellum_cli_config
+from vellum_cli.config import (
+    DEFAULT_WORKSPACE_CONFIG,
+    VellumCliConfig,
+    WorkflowConfig,
+    WorkflowDeploymentConfig,
+    load_vellum_cli_config,
+)
 from vellum_cli.logger import load_cli_logger
 
 ERROR_LOG_FILE_NAME = "error.log"
@@ -43,6 +49,7 @@ def _resolve_workflow_config(
     module: Optional[str] = None,
     workflow_sandbox_id: Optional[str] = None,
     workflow_deployment: Optional[str] = None,
+    workspace: Optional[str] = None,
 ) -> WorkflowConfigResolutionResult:
     if workflow_sandbox_id and workflow_deployment:
         raise ValueError("Cannot specify both workflow_sandbox_id and workflow_deployment")
@@ -53,6 +60,7 @@ def _resolve_workflow_config(
             workflow_config = WorkflowConfig(
                 workflow_sandbox_id=workflow_sandbox_id,
                 module=module,
+                workspace=workspace or DEFAULT_WORKSPACE_CONFIG.name,
             )
             config.workflows.append(workflow_config)
             return WorkflowConfigResolutionResult(
@@ -132,8 +140,9 @@ def pull_command(
     strict: Optional[bool] = None,
     include_sandbox: Optional[bool] = None,
     target_directory: Optional[str] = None,
+    workspace: Optional[str] = None,
 ) -> None:
-    load_dotenv()
+    load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
     logger = load_cli_logger()
     config = load_vellum_cli_config()
 
@@ -142,6 +151,7 @@ def pull_command(
         module=module,
         workflow_sandbox_id=workflow_sandbox_id,
         workflow_deployment=workflow_deployment,
+        workspace=workspace,
     )
 
     workflow_config = workflow_config_result.workflow_config
@@ -157,7 +167,20 @@ def pull_command(
     else:
         logger.info(f"Pulling workflow from {pk}...")
 
-    client = create_vellum_client()
+    resolved_workspace = workspace or workflow_config.workspace or DEFAULT_WORKSPACE_CONFIG.name
+    workspace_config = (
+        next((w for w in config.workspaces if w.name == resolved_workspace), DEFAULT_WORKSPACE_CONFIG)
+        if workspace
+        else DEFAULT_WORKSPACE_CONFIG
+    )
+    api_key = os.getenv(workspace_config.api_key)
+    if not api_key:
+        raise ValueError(f"No API key value found in environment for workspace '{workspace_config.name}'.")
+
+    client = create_vellum_client(
+        api_key=api_key,
+        api_url=workspace_config.api_url,
+    )
     query_parameters = {}
 
     if include_json:

vellum_cli/push.py

@@ -45,8 +45,11 @@ def push_command(
         else config.workflows
     )
 
-    if len(workflow_configs) > 1 and workspace:
-        workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
+    if len(workflow_configs) > 1:
+        if workspace:
+            workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
+        else:
+            workflow_configs = [w for w in workflow_configs if w.workspace == DEFAULT_WORKSPACE_CONFIG.name]
 
     if len(workflow_configs) == 0:
         if module and module_exists(module):

vellum_cli/tests/test_pull.py

@@ -3,6 +3,7 @@ import io
 import json
 import os
 import tempfile
+from unittest import mock
 from uuid import uuid4
 import zipfile
 
@@ -1284,3 +1285,74 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
         assert lock_data["workflows"][0]["deployments"][0]["label"] == deployment_label
 
     os.chdir(current_dir)
+
+
+def test_pull__workspace_option__uses_different_api_key(mock_module, vellum_client_class):
+    # GIVEN a module and workflow_sandbox_id
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    set_pyproject_toml = mock_module.set_pyproject_toml
+    workflow_sandbox_id = str(uuid4())
+
+    # AND a different workspace is set in the pyproject.toml
+    set_pyproject_toml(
+        {
+            "workflows": [],
+            "workspaces": [
+                {
+                    "name": "my_other_workspace",
+                    "api_key": "MY_OTHER_VELLUM_API_KEY",
+                }
+            ],
+        }
+    )
+
+    # 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_KEY=aaabbbcccddd
+"""
+        )
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client_class.return_value.workflows.pull.return_value = iter(
+        [_zip_file_map({"workflow.py": "print('hello')"})]
+    )
+
+    # WHEN calling `vellum pull` with --workspace
+    runner = CliRunner()
+    result = runner.invoke(
+        cli_main,
+        [
+            "workflows",
+            "pull",
+            module,
+            "--workflow-sandbox-id",
+            workflow_sandbox_id,
+            "--workspace",
+            "my_other_workspace",
+        ],
+    )
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the vellum client with the correct api key
+    vellum_client_class.assert_called_once_with(
+        api_key="aaabbbcccddd",
+        environment=mock.ANY,
+    )
+
+    # 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"][0]["workspace"] == "my_other_workspace"
+        assert lock_file_content["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id
+
+    # AND the workflow.py file is written as expected
+    workflow_py = os.path.join(temp_dir, *module.split("."), "workflow.py")
+    assert os.path.exists(workflow_py)
+    with open(workflow_py) as f:
+        assert f.read() == "print('hello')"

vellum_cli/tests/test_push.py

@@ -870,3 +870,45 @@ def test_push__create_new_config_for_existing_module(mock_module, vellum_client)
         new_config = new_configs[0]
         assert new_config["workflow_sandbox_id"] == new_workflow_sandbox_id
         assert new_config["workspace"] == "default"
+
+
+def test_push__use_default_workspace_if_not_specified__multiple_workflows_configured(mock_module, vellum_client):
+    # GIVEN a config with a workspace configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = str(uuid4())
+    mock_module.set_pyproject_toml(
+        {
+            "workspaces": [
+                {"name": "my_other_workspace"},
+            ],
+            "workflows": [
+                {"module": module, "workflow_sandbox_id": workflow_sandbox_id, "workspace": "default"},
+                {"module": module, "workflow_sandbox_id": str(uuid4()), "workspace": "my_other_workspace"},
+            ],
+        }
+    )
+
+    # AND a workflow exists in the module successfully
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=workflow_sandbox_id,
+    )
+
+    # WHEN calling `vellum push` with a module without a workspace specified
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "push", module])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND check that lockfile should maintain that this workflow is using the default workspace
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        configs = [w for w in lock_file_content["workflows"] if w["module"] == module]
+        assert len(configs) == 2
+        config = configs[0]
+        assert config["workflow_sandbox_id"] == workflow_sandbox_id
+        assert config["workspace"] == "default"

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -133,6 +133,10 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     # Used by each class extending BaseNodeDisplay to specify which attributes are meant to be serialized
     # as the former `"inputs"` field
     __serializable_inputs__: Set[NodeReference] = set()
+    # Used by each class extending BaseNodeDisplay to specify which attributes are meant to be opted out
+    # of serialization. It's possible that we keep this one as a user facing api in the future, but
+    # don't want to commit to that decision just yet
+    __unserializable_attributes__: Set[NodeReference] = set()
     # END: Attributes for backwards compatible serialization
 
     def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
@@ -145,9 +149,12 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 # We don't need to serialize generic node attributes containing a subworkflow
                 continue
 
+            if attribute in self.__unserializable_attributes__:
+                continue
+
             id = (
                 str(self.attribute_ids_by_name[attribute.name])
-                if self.attribute_ids_by_name
+                if self.attribute_ids_by_name.get(attribute.name)
                 else str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
             )
             try:

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

@@ -19,6 +19,14 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
     __serializable_inputs__ = {InlinePromptNode.prompt_inputs}
+    __unserializable_attributes__ = {
+        InlinePromptNode.blocks,
+        InlinePromptNode.functions,
+        InlinePromptNode.parameters,
+        InlinePromptNode.settings,
+        InlinePromptNode.expand_meta,
+        InlinePromptNode.request_options,
+    }
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
@@ -219,16 +227,25 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         return block
 
     def _serialize_attributes(self, display_context: "WorkflowDisplayContext"):
-        attribute_instances_by_name = {}
+        attributes = []
         for attribute in self._node:
-            if attribute.name in self.attribute_ids_by_name:
-                attribute_instances_by_name[attribute.name] = attribute.instance
-
-        return [
-            {
-                "id": str(attr_id),
-                "name": attr_name,
-                "value": serialize_value(display_context, attribute_instances_by_name[attr_name]),
-            }
-            for attr_name, attr_id in self.attribute_ids_by_name.items()
-        ]
+            if attribute in self.__unserializable_attributes__:
+                continue
+
+            id = (
+                str(self.attribute_ids_by_name[attribute.name])
+                if self.attribute_ids_by_name.get(attribute.name)
+                else str(uuid4_from_hash(f"{self.node_id}|{attribute.name}"))
+            )
+            try:
+                attributes.append(
+                    {
+                        "id": id,
+                        "name": attribute.name,
+                        "value": serialize_value(display_context, attribute.instance),
+                    }
+                )
+            except ValueError as e:
+                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
+
+        return attributes

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

@@ -4,6 +4,7 @@ from typing import Type
 
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.ports.port import Port
@@ -145,7 +146,7 @@ def test_serialize_node__prompt_inputs__state_reference():
         ml_model = "gpt-4o"
 
     # AND a workflow with the prompt node
-    class Workflow(BaseWorkflow):
+    class Workflow(BaseWorkflow[BaseInputs, MyState]):
         graph = MyPromptNode
 
     # WHEN the workflow is serialized
@@ -184,6 +185,37 @@ def test_serialize_node__prompt_inputs__state_reference():
         },
     ]
 
+    # AND the prompt attributes should include a dictionary reference with the state reference
+    prompt_inputs_attribute = next(
+        attribute for attribute in my_prompt_node["attributes"] if attribute["name"] == "prompt_inputs"
+    )
+    assert prompt_inputs_attribute == {
+        "id": "3b6e1363-e41b-458e-ad28-95a61fdedac1",
+        "name": "prompt_inputs",
+        "value": {
+            "type": "DICTIONARY_REFERENCE",
+            "entries": [
+                {
+                    "key": "foo",
+                    "value": {
+                        "type": "WORKFLOW_STATE",
+                        "state_variable_id": "45649791-c642-4405-aff9-a1fafd780ea1",
+                    },
+                },
+                {
+                    "key": "bar",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "STRING",
+                            "value": "baz",
+                        },
+                    },
+                },
+            ],
+        },
+    }
+
 
 def test_serialize_node__unreferenced_variable_block__still_serializes():
     # GIVEN a prompt node with an unreferenced variable block

vellum_ee/workflows/display/utils/expressions.py

@@ -207,7 +207,7 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
     if isinstance(value, StateValueReference):
         state_value_display = display_context.global_state_value_displays[value]
         return {
-            "type": "STATE_VALUE",
+            "type": "WORKFLOW_STATE",
             "state_variable_id": str(state_value_display.id),
         }