vellum-ai 0.12.4__py3-none-any.whl → 0.12.6__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.12.4",
+            "X-Fern-SDK-Version": "0.12.6",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/resources/workflows/client.py

@@ -27,7 +27,11 @@ class WorkflowsClient:
         self,
         id: str,
         *,
+        exclude_code: typing.Optional[bool] = None,
         format: typing.Optional[WorkflowsPullRequestFormat] = None,
+        include_json: typing.Optional[bool] = None,
+        include_sandbox: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> typing.Iterator[bytes]:
         """
@@ -38,8 +42,16 @@ class WorkflowsClient:
         id : str
             The ID of the Workflow to pull from
 
+        exclude_code : typing.Optional[bool]
+
         format : typing.Optional[WorkflowsPullRequestFormat]
 
+        include_json : typing.Optional[bool]
+
+        include_sandbox : typing.Optional[bool]
+
+        strict : typing.Optional[bool]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -53,7 +65,11 @@ class WorkflowsClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "exclude_code": exclude_code,
                 "format": format,
+                "include_json": include_json,
+                "include_sandbox": include_sandbox,
+                "strict": strict,
             },
             request_options=request_options,
         ) as _response:
@@ -164,7 +180,11 @@ class AsyncWorkflowsClient:
         self,
         id: str,
         *,
+        exclude_code: typing.Optional[bool] = None,
         format: typing.Optional[WorkflowsPullRequestFormat] = None,
+        include_json: typing.Optional[bool] = None,
+        include_sandbox: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> typing.AsyncIterator[bytes]:
         """
@@ -175,8 +195,16 @@ class AsyncWorkflowsClient:
         id : str
             The ID of the Workflow to pull from
 
+        exclude_code : typing.Optional[bool]
+
         format : typing.Optional[WorkflowsPullRequestFormat]
 
+        include_json : typing.Optional[bool]
+
+        include_sandbox : typing.Optional[bool]
+
+        strict : typing.Optional[bool]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -190,7 +218,11 @@ class AsyncWorkflowsClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "exclude_code": exclude_code,
                 "format": format,
+                "include_json": include_json,
+                "include_sandbox": include_sandbox,
+                "strict": strict,
             },
             request_options=request_options,
         ) as _response:

vellum/client/types/chat_message_prompt_block.py

@@ -16,9 +16,9 @@ class ChatMessagePromptBlock(UniversalBaseModel):
     A block that represents a chat message in a prompt template.
     """
 
+    block_type: typing.Literal["CHAT_MESSAGE"] = "CHAT_MESSAGE"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["CHAT_MESSAGE"] = "CHAT_MESSAGE"
     chat_role: ChatMessageRole
     chat_source: typing.Optional[str] = None
     chat_message_unterminated: typing.Optional[bool] = None

vellum/client/types/function_definition.py

@@ -4,22 +4,41 @@ from ..core.pydantic_utilities import UniversalBaseModel
 import typing
 from .prompt_block_state import PromptBlockState
 from .ephemeral_prompt_cache_config import EphemeralPromptCacheConfig
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
 
 class FunctionDefinition(UniversalBaseModel):
     """
-    A block that represents a function definition in a prompt template.
+    The definition of a Function (aka "Tool Call") that a Prompt/Model has access to.
     """
 
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    name: typing.Optional[str] = None
-    description: typing.Optional[str] = None
-    parameters: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
-    forced: typing.Optional[bool] = None
-    strict: typing.Optional[bool] = None
+    name: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The name identifying the function.
+    """
+
+    description: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    A description to help guide the model when to invoke this function.
+    """
+
+    parameters: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
+    """
+    An OpenAPI specification of parameters that are supported by this function.
+    """
+
+    forced: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Set this option to true to force the model to return a function call of this function.
+    """
+
+    strict: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Set this option to use strict schema decoding when available.
+    """
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/jinja_prompt_block.py

@@ -13,9 +13,9 @@ class JinjaPromptBlock(UniversalBaseModel):
     A block of Jinja template code that is used to generate a prompt
     """
 
+    block_type: typing.Literal["JINJA"] = "JINJA"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["JINJA"] = "JINJA"
     template: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/plain_text_prompt_block.py

@@ -13,9 +13,9 @@ class PlainTextPromptBlock(UniversalBaseModel):
     A block that holds a plain text string value.
     """
 
+    block_type: typing.Literal["PLAIN_TEXT"] = "PLAIN_TEXT"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["PLAIN_TEXT"] = "PLAIN_TEXT"
     text: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/rich_text_prompt_block.py

@@ -14,9 +14,9 @@ class RichTextPromptBlock(UniversalBaseModel):
     A block that includes a combination of plain text and variable blocks.
     """
 
+    block_type: typing.Literal["RICH_TEXT"] = "RICH_TEXT"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["RICH_TEXT"] = "RICH_TEXT"
     blocks: typing.List[RichTextChildBlock]
 
     if IS_PYDANTIC_V2:

vellum/client/types/variable_prompt_block.py

@@ -13,9 +13,9 @@ class VariablePromptBlock(UniversalBaseModel):
     A block that represents a variable in a prompt template.
     """
 
+    block_type: typing.Literal["VARIABLE"] = "VARIABLE"
     state: typing.Optional[PromptBlockState] = None
     cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
-    block_type: typing.Literal["VARIABLE"] = "VARIABLE"
     input_variable: str
 
     if IS_PYDANTIC_V2:

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

@@ -1,6 +1,6 @@
 import json
 from uuid import uuid4
-from typing import ClassVar, Generic, Iterator, List, Optional, Tuple, cast
+from typing import Callable, ClassVar, Generic, Iterator, List, Optional, Tuple, Union, cast
 
 from vellum import (
     AdHocExecutePromptEvent,
@@ -24,9 +24,10 @@ from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
 from vellum.workflows.nodes.displayable.bases.inline_prompt_node.constants import DEFAULT_PROMPT_PARAMETERS
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.functions import compile_function_definition
 
 
-class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
+class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
     """
     Used to execute a Prompt defined inline.
 
@@ -45,7 +46,7 @@ class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
     blocks: ClassVar[List[PromptBlock]]
 
     # The functions/tools that a Prompt has access to
-    functions: Optional[List[FunctionDefinition]] = OMIT
+    functions: Optional[List[Union[FunctionDefinition, Callable]]] = None
 
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
     expand_meta: Optional[AdHocExpandMeta] = OMIT
@@ -59,6 +60,14 @@ class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
             "execution_context": {"parent_context": parent_context},
             **request_options.get("additional_body_parameters", {}),
         }
+        normalized_functions = (
+            [
+                function if isinstance(function, FunctionDefinition) else compile_function_definition(function)
+                for function in self.functions
+            ]
+            if self.functions
+            else None
+        )
 
         return self._context.vellum_client.ad_hoc.adhoc_execute_prompt_stream(
             ml_model=self.ml_model,
@@ -66,7 +75,7 @@ class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
             input_variables=input_variables,
             parameters=self.parameters,
             blocks=self.blocks,
-            functions=self.functions,
+            functions=normalized_functions,
             expand_meta=self.expand_meta,
             request_options=self.request_options,
         )

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

@@ -5,10 +5,14 @@ from typing import Any, Iterator, List
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.function_call import FunctionCall
+from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
+from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
 from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
 from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows.nodes.displayable.bases.inline_prompt_node.node import BaseInlinePromptNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 
 
@@ -62,3 +66,54 @@ def test_inline_prompt_node__json_inputs(vellum_adhoc_prompt_client):
         PromptRequestJsonInput(key="a_pydantic", type="JSON", value={"example": "example"}),
     ]
     assert len(mock_api.call_args.kwargs["input_variables"]) == 4
+
+
+def test_inline_prompt_node__function_definitions(vellum_adhoc_prompt_client):
+    # GIVEN a function definition
+    def my_function(foo: str, bar: int) -> None:
+        pass
+
+    # AND a prompt node with a accepting that function definition
+    class MyNode(BaseInlinePromptNode):
+        ml_model = "gpt-4o"
+        functions = [my_function]
+        prompt_inputs = {}
+        blocks = []
+
+    # AND a known response from invoking an inline prompt
+    expected_outputs: List[PromptOutput] = [
+        FunctionCallVellumValue(value=FunctionCall(name="my_function", arguments={"foo": "hello", "bar": 1})),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    list(MyNode().run())
+
+    # THEN the prompt is executed with the correct inputs
+    mock_api = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream
+    assert mock_api.call_count == 1
+    assert mock_api.call_args.kwargs["functions"] == [
+        FunctionDefinition(
+            name="my_function",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "foo": {"type": "string"},
+                    "bar": {"type": "integer"},
+                },
+                "required": ["foo", "bar"],
+            },
+        ),
+    ]

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

@@ -75,7 +75,7 @@ def test_inline_text_prompt_node__basic(vellum_adhoc_prompt_client):
     vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
         blocks=[],
         expand_meta=Ellipsis,
-        functions=Ellipsis,
+        functions=None,
         input_values=[],
         input_variables=[],
         ml_model="gpt-4o",

vellum/workflows/sandbox.py

@@ -0,0 +1,51 @@
+from typing import Generic, Sequence, Type
+
+import dotenv
+
+from vellum.workflows.events.workflow import WorkflowEventStream
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.logging import load_logger
+from vellum.workflows.types.generics import WorkflowType
+from vellum.workflows.workflows.event_filters import root_workflow_event_filter
+
+
+class SandboxRunner(Generic[WorkflowType]):
+    def __init__(self, workflow: Type[WorkflowType], inputs: Sequence[BaseInputs]):
+        if not inputs:
+            raise ValueError("Inputs are required to have at least one defined inputs")
+
+        self._workflow = workflow
+        self._inputs = inputs
+
+        dotenv.load_dotenv()
+        self._logger = load_logger()
+
+    def run(self, index: int = 0):
+        if index < 0:
+            self._logger.warning("Index is less than 0, running first input")
+            index = 0
+        elif index >= len(self._inputs):
+            self._logger.warning("Index is greater than the number of provided inputs, running last input")
+            index = len(self._inputs) - 1
+
+        selected_inputs = self._inputs[index]
+
+        workflow = self._workflow()
+        events = workflow.stream(
+            inputs=selected_inputs,
+            event_filter=root_workflow_event_filter,
+        )
+
+        self._process_events(events)
+
+    def _process_events(self, events: WorkflowEventStream):
+        for event in events:
+            if event.name == "workflow.execution.fulfilled":
+                self._logger.info("Workflow fulfilled!")
+                for output_reference, value in event.outputs:
+                    self._logger.info("----------------------------------")
+                    self._logger.info(f"{output_reference.name}: {value}")
+            elif event.name == "node.execution.initiated":
+                self._logger.info(f"Just started Node: {event.node_definition.__name__}")
+            elif event.name == "node.execution.fulfilled":
+                self._logger.info(f"Just finished Node: {event.node_definition.__name__}")

vellum/workflows/tests/test_sandbox.py

@@ -0,0 +1,62 @@
+import pytest
+from typing import List
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.sandbox import SandboxRunner
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+@pytest.fixture
+def mock_logger(mocker):
+    return mocker.patch("vellum.workflows.sandbox.load_logger")
+
+
+@pytest.mark.parametrize(
+    ["run_kwargs", "expected_last_log"],
+    [
+        ({}, "final_results: first"),
+        ({"index": 1}, "final_results: second"),
+        ({"index": -4}, "final_results: first"),
+        ({"index": 100}, "final_results: second"),
+    ],
+    ids=["default", "specific", "negative", "out_of_bounds"],
+)
+def test_sandbox_runner__happy_path(mock_logger, run_kwargs, expected_last_log):
+    # GIVEN we capture the logs to stdout
+    logs = []
+    mock_logger.return_value.info.side_effect = lambda msg: logs.append(msg)
+
+    # AND an example workflow
+    class Inputs(BaseInputs):
+        foo: str
+
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            bar = Inputs.foo
+
+    class Workflow(BaseWorkflow[Inputs, BaseState]):
+        graph = StartNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_results = StartNode.Outputs.bar
+
+    # AND a dataset for this workflow
+    inputs: List[Inputs] = [
+        Inputs(foo="first"),
+        Inputs(foo="second"),
+    ]
+
+    # WHEN we run the sandbox
+    runner = SandboxRunner(workflow=Workflow, inputs=inputs)
+    runner.run(**run_kwargs)
+
+    # THEN we see the logs
+    assert logs == [
+        "Just started Node: StartNode",
+        "Just finished Node: StartNode",
+        "Workflow fulfilled!",
+        "----------------------------------",
+        expected_last_log,
+    ]

vellum/workflows/utils/functions.py

@@ -1,6 +1,9 @@
 import dataclasses
 import inspect
-from typing import Any, Callable, Union, get_args, get_origin
+from typing import Any, Callable, Optional, Union, get_args, get_origin
+
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
 
 from vellum.client.types.function_definition import FunctionDefinition
 
@@ -16,7 +19,10 @@ type_map = {
 }
 
 
-def _compile_annotation(annotation: Any, defs: dict[str, Any]) -> dict:
+def _compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
+    if annotation is None:
+        return {"type": "null"}
+
     if get_origin(annotation) is Union:
         return {"anyOf": [_compile_annotation(a, defs) for a in get_args(annotation)]}
 
@@ -37,13 +43,44 @@ def _compile_annotation(annotation: Any, defs: dict[str, Any]) -> dict:
                 if field.default is dataclasses.MISSING:
                     required.append(field.name)
                 else:
-                    properties[field.name]["default"] = field.default
+                    properties[field.name]["default"] = _compile_default_value(field.default)
+            defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
+        return {"$ref": f"#/$defs/{annotation.__name__}"}
+
+    if issubclass(annotation, BaseModel):
+        if annotation.__name__ not in defs:
+            properties = {}
+            required = []
+            for field_name, field in annotation.model_fields.items():
+                # Mypy is incorrect here, the `annotation` attribute is defined on `FieldInfo`
+                field_annotation = field.annotation  # type: ignore[attr-defined]
+                properties[field_name] = _compile_annotation(field_annotation, defs)
+                if field.default is PydanticUndefined:
+                    required.append(field_name)
+                else:
+                    properties[field_name]["default"] = _compile_default_value(field.default)
             defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
+
         return {"$ref": f"#/$defs/{annotation.__name__}"}
 
     return {"type": type_map[annotation]}
 
 
+def _compile_default_value(default: Any) -> Any:
+    if dataclasses.is_dataclass(default):
+        return {
+            field.name: _compile_default_value(getattr(default, field.name)) for field in dataclasses.fields(default)
+        }
+
+    if isinstance(default, BaseModel):
+        return {
+            field_name: _compile_default_value(getattr(default, field_name))
+            for field_name in default.model_fields.keys()
+        }
+
+    return default
+
+
 def compile_function_definition(function: Callable) -> FunctionDefinition:
     """
     Converts a Python function into our Vellum-native FunctionDefinition type.
@@ -62,7 +99,7 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
         if param.default is inspect.Parameter.empty:
             required.append(param.name)
         else:
-            properties[param.name]["default"] = param.default
+            properties[param.name]["default"] = _compile_default_value(param.default)
 
     parameters = {"type": "object", "properties": properties, "required": required}
     if defs:

vellum/workflows/utils/tests/test_functions.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass
 from typing import Dict, List, Optional, Union
 
+from pydantic import BaseModel
+
 from vellum.client.types.function_definition import FunctionDefinition
 from vellum.workflows.utils.functions import compile_function_definition
 
@@ -169,3 +171,94 @@ def test_compile_function_definition__dataclasses():
             },
         },
     )
+
+
+def test_compile_function_definition__pydantic():
+    # GIVEN a function with a pydantic model
+    class MyPydanticModel(BaseModel):
+        a: int
+        b: str
+
+    def my_function(c: MyPydanticModel):
+        pass
+
+    # WHEN compiling the function
+    compiled_function = compile_function_definition(my_function)
+
+    # THEN it should return the compiled function definition
+    assert compiled_function == FunctionDefinition(
+        name="my_function",
+        parameters={
+            "type": "object",
+            "properties": {"c": {"$ref": "#/$defs/MyPydanticModel"}},
+            "required": ["c"],
+            "$defs": {
+                "MyPydanticModel": {
+                    "type": "object",
+                    "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
+                    "required": ["a", "b"],
+                }
+            },
+        },
+    )
+
+
+def test_compile_function_definition__default_dataclass():
+    # GIVEN a function with a dataclass
+    @dataclass
+    class MyDataClass:
+        a: int
+        b: str
+
+    def my_function(c: MyDataClass = MyDataClass(a=1, b="hello")):
+        pass
+
+    # WHEN compiling the function
+    compiled_function = compile_function_definition(my_function)
+
+    # THEN it should return the compiled function definition
+    assert compiled_function == FunctionDefinition(
+        name="my_function",
+        parameters={
+            "type": "object",
+            "properties": {"c": {"$ref": "#/$defs/MyDataClass", "default": {"a": 1, "b": "hello"}}},
+            "required": [],
+            "$defs": {
+                "MyDataClass": {
+                    "type": "object",
+                    "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
+                    "required": ["a", "b"],
+                }
+            },
+        },
+    )
+
+
+def test_compile_function_definition__default_pydantic():
+    # GIVEN a function with a pydantic model as the default value
+    class MyPydanticModel(BaseModel):
+        a: int
+        b: str
+
+    def my_function(c: MyPydanticModel = MyPydanticModel(a=1, b="hello")):
+        pass
+
+    # WHEN compiling the function
+    compiled_function = compile_function_definition(my_function)
+
+    # THEN it should return the compiled function definition
+    assert compiled_function == FunctionDefinition(
+        name="my_function",
+        parameters={
+            "type": "object",
+            "properties": {"c": {"$ref": "#/$defs/MyPydanticModel", "default": {"a": 1, "b": "hello"}}},
+            "required": [],
+            "$defs": {
+                "MyPydanticModel": {
+                    "type": "object",
+                    "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
+                    "required": ["a", "b"],
+                }
+            },
+        },
+    )

{vellum_ai-0.12.4.dist-info → vellum_ai-0.12.6.dist-info}/METADATA

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

{vellum_ai-0.12.4.dist-info → vellum_ai-0.12.6.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=XG6aC1NSPfBjNFzqiy9Lbk4DnELCKO8lpIZ3jeJR0r0,6990
+vellum_cli/__init__.py,sha256=A9uo9OE7xQACNEtX4k0c-rxypDqS5V8kA8u4BNN0azM,7402
 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=EkQirsTe0KCpJ8oHTE3S9_M2XHSrb2wrXNq4hTkMZng,5770
+vellum_cli/pull.py,sha256=q68fr1o5H9l8Dvc8BTY1GARJYjAV1i6Fg-Lg4Oo4FDw,6155
 vellum_cli/push.py,sha256=gcYhIogeYejZIhNm5Cjp0VBECaXLmVQEvZjrPH0-TSU,5337
 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=pGqpBkahC360UITDE8BlcJ7LPd9DyRPn4NrCNdkQmAQ,15907
+vellum_cli/tests/test_pull.py,sha256=P2JFNHU1hE6iydYl7rW35h7c8_DSrLiAS7gNsFMy1JU,17829
 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=23PLqcpMe_mYkYdug9PDb6Br7o64Thx9-IhcviKGvGo,6662
-vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=7F4zQnZQBOTp9turUUS41RaO40Z14m851WOLJHgmHPU,2234
+vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=BxA-YVUJvB36NM-Q5DNCwckeqymwLKMp9DVCaTyrPbs,2253
 vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=vyKeJAevAXvEAEtWeTEdBZXD3eJQYW_DEXLKVZ5KmYc,1325
 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=QqR3Ly0RNrXwOeLdW5nERDFt0gRPf76n1bPES6o5UN4,1093
@@ -28,8 +28,8 @@ 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=_sdLmmOa1ZqZQZXzw0GMoUpgnV1sdOfc_19LJCBS_Xc,4288
-vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=TP7ItMeEXbVbkGr5Qwjv8vl9V0Fi9QBE04d3kdJH4JE,13666
+vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=XqizRn5bLwT8LMwgyvfbln8inhCxzTi1EkD22Fx-5-U,4222
+vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=EtdqJfhYw03PuT2iyJ6mSAZK4RsQqDie_2AnJAtMelk,13625
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=ygTjSjYDI4DtkxADWub5rhBnRWItMKWF6fezBrgpOKA,1979
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=t5iJQVoRT5g-v2IiUb4kFYdvUVKch0zn27016pzDZoo,2761
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=3TJvHX_Uuf_gr94VkYc_zmNH8I5p71ChIeoAbJZ3ddY,2158
@@ -39,13 +39,13 @@ vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=AqUlItgSZij12qRKguKV
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=jzO63B9KiEAncnBqmz2ZTcxjmEHozMEe7WnfpcpsQYg,3195
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=9VpC3h0RYOxJuRbjDwidBYlLKakkmlEnDMBh2C7lHcY,1107
 vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=gLRkizwyw21-Z12IyDbdOJpXayiZZd4HWd6qgZQg8sc,3106
-vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=I4_ENFWEhHUDYFUWF67-EyToCwmJynAXcbNpqw6Cpio,8681
+vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=laNWcDt62VRM5hLfcOi-ouAyNhYiFRsD0PWbVGLwlLI,9035
 vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=zOp4voBSgB3MR1R93wTOrsiiara_hxEAYFupLl_SvTA,2657
-vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=UNYxoE-89agE8ugK0aWg_uN61jPqlC2VSxWHk568sN4,3324
+vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=IHumtFFZSanRizU3-0ATFgUnDuSFZMScZce8YTDJiGU,3373
 vellum_ee/workflows/display/nodes/vellum/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py,sha256=aJfQnIvlrRHVKgQid_gg6VQKkJyPgFnzbvWt9_t0Vz0,3860
 vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=hB8dcGMGkuC95kk9hmZUgHsCLwEA37fHTFXj0JzbRjM,4692
-vellum_ee/workflows/display/nodes/vellum/utils.py,sha256=3QsKS5Kht2Nod4A18T0bb4filK9AkyK5oImVlViK3l8,4643
+vellum_ee/workflows/display/nodes/vellum/utils.py,sha256=6mPg9QilJfLw9Sgk_h9LRSyKZpKgRu06mr3X1AmmDCA,4691
 vellum_ee/workflows/display/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=TEg3QbdE7rLbEhml9pMWmay--phsekGlfGVhTblxCGE,1727
 vellum_ee/workflows/display/tests/workflow_serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -76,7 +76,7 @@ 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=Txk5jgvpOyeOcWKUtrs-1p5HZ-zPxTysTZVwMYsX3-A,1868
+vellum/client/core/client_wrapper.py,sha256=Djd_7GxqAd6z6spaztPvuwOWM8nCLYHOM1pxOFHfmrc,1868
 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
@@ -130,7 +130,7 @@ vellum/client/resources/workflow_deployments/types/workflow_deployments_list_req
 vellum/client/resources/workflow_sandboxes/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 vellum/client/resources/workflow_sandboxes/client.py,sha256=3wVQxkjrJ5bIS8fB5FpKXCP2dX38299ghWrJ8YmXxwQ,7435
 vellum/client/resources/workflows/__init__.py,sha256=Z4xi8Nxd9U4t35FQSepTt1p-ns0X1xtdNs168kUcuBk,153
-vellum/client/resources/workflows/client.py,sha256=5wqDiO1xYnYxNmbaEE1OTnUn3YXKpruYqF3taCjLRDI,10263
+vellum/client/resources/workflows/client.py,sha256=1X9KKRIr-Jwxbkd2a43DYfukKRKgNL1IXkGb9VC15a0,11391
 vellum/client/resources/workflows/types/__init__.py,sha256=-uFca4ypncAOvfsg6sjD-5C9zWdA5qNvU6m675GphVg,177
 vellum/client/resources/workflows/types/workflows_pull_request_format.py,sha256=dOWE_jnDnniIJLoeseeCms23aklghyBkoPmBFzcqqZk,165
 vellum/client/resources/workspace_secrets/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
@@ -173,7 +173,7 @@ vellum/client/types/chat_history_vellum_value_request.py,sha256=HzAiysncG5unJ-tl
 vellum/client/types/chat_message.py,sha256=EOA8v5Ebx2KS9BtwBBGbuvSK-pn4xWYZiioHuuPWvzw,916
 vellum/client/types/chat_message_content.py,sha256=DQLB5rG40qLRLsmKWWo-XKa4rhk9TGQs_eFTFow2zEM,607
 vellum/client/types/chat_message_content_request.py,sha256=iFT_PmN6sUjeN1_fZXr2ePJEbSq_GZcClBvtu8SdVmQ,724
-vellum/client/types/chat_message_prompt_block.py,sha256=K0D42GPIgJYfYYigXU6ggCUbwHcB1LwMNDjXDybh3MQ,1351
+vellum/client/types/chat_message_prompt_block.py,sha256=b6WmJqAc6r15XhHKsq3VmZBP-uoKV4jCSO-_xrDY5Qw,1351
 vellum/client/types/chat_message_request.py,sha256=r2EW1pfnvNYx2fo6mBqU5HQrUzp67WXuE5G-XK281E4,945
 vellum/client/types/chat_message_role.py,sha256=-i0Jrcbwf72MkMoaFTGyxRduvlN7f5Y9ULhCXR5KNdA,182
 vellum/client/types/code_execution_node_array_result.py,sha256=KCdbmjXjReO-hPPpBsSR17h_roDUpc4R-92cmIn59ck,952
@@ -271,7 +271,7 @@ vellum/client/types/function_call_request.py,sha256=eJBIN-wLkkkDUIwAy1nMeWHu3MZ5
 vellum/client/types/function_call_variable_value.py,sha256=VQKCiEtJsmIK3i7CtFV_2ZpxeX70rqpUViXIvAci8L0,702
 vellum/client/types/function_call_vellum_value.py,sha256=lLJb-S_-S_UXm6una1BMyCbqLpMhbbMcaVIYNO45h5o,759
 vellum/client/types/function_call_vellum_value_request.py,sha256=oUteuCfWcj7UJbSE_Vywmmva9kyTaeL9iv5WJHabDVs,788
-vellum/client/types/function_definition.py,sha256=D6uZTIndSeTT4O6FQjU7jVB6Tn1VWOqlAjCa92qX5cE,1127
+vellum/client/types/function_definition.py,sha256=UzlrrBtdWe7RMStfc1UVdcnr4s8N4mOhsM306p6x_CE,1693
 vellum/client/types/generate_options_request.py,sha256=TUDqsH0tiPWDZH4T-p5gsvKvwVHEVZ_k6oI3qsjlsk4,782
 vellum/client/types/generate_request.py,sha256=gL6ywAJe6YCJ5oKbtYwL2H_TMdC_6PJZAI7-P3UOF3I,1286
 vellum/client/types/generate_response.py,sha256=QjbBGFGRE1tHcyDodM6Avzq0YHI4gsprkAWpdqZRrh4,1135
@@ -304,7 +304,7 @@ vellum/client/types/initiated_workflow_node_result_event.py,sha256=Nu1J4iQYsW2HH
 vellum/client/types/instructor_vectorizer_config.py,sha256=7udlosXv4CUWTW_Q9m0mz3VRi1FKSbBhDIOhtxRd0-U,731
 vellum/client/types/instructor_vectorizer_config_request.py,sha256=6LGFFQKntMfX7bdetUqEMVdr3KJHEps0oDp2bNmqWbM,738
 vellum/client/types/iteration_state_enum.py,sha256=83JSh842OJgQiLtNn1KMimy6RlEYRVH3mDmYWS6Ewzo,180
-vellum/client/types/jinja_prompt_block.py,sha256=Q2aIQh8a-i09kL1ISM-kzTq7TZoyaafDDlmCkUmLnVw,939
+vellum/client/types/jinja_prompt_block.py,sha256=-wukO4TaDvGlrbkg9ZtDOPEfoLmaoX7830ktLGHRrvI,939
 vellum/client/types/json_input.py,sha256=ZUA2O9YueBCx0IMMdB8uYNSWJiSDZxMm5ogwbwCmz_g,761
 vellum/client/types/json_input_request.py,sha256=x5sA-VXxF4QH-98xRcIKPZhsMVbnJNUQofiUQqyfGk4,768
 vellum/client/types/json_variable_value.py,sha256=X7eBEWxuozfvIdqD5sIZ5L-L77Ou6IIsZaQVNXh5G2k,634
@@ -392,7 +392,7 @@ vellum/client/types/paginated_test_suite_test_case_list.py,sha256=9KrCCQKy0egMmV
 vellum/client/types/paginated_workflow_release_tag_read_list.py,sha256=dH24ESWyAMVtyHsBkxG8kJ9oORY04Wn3IN-7jvV7Lu4,818
 vellum/client/types/pdf_search_result_meta_source.py,sha256=EMVhqdN1bwE6Ujdx4VhlmKQtJvitN-57kY8oZPxh9dI,1126
 vellum/client/types/pdf_search_result_meta_source_request.py,sha256=nUhaD2Kw1paGC6O_ICVNu3R0e1SVgTshRTkGNgmcjXo,1133
-vellum/client/types/plain_text_prompt_block.py,sha256=GlzovdRbT6mhunMvIpF94_0apjh_0SZtkdlx5HFrE0k,930
+vellum/client/types/plain_text_prompt_block.py,sha256=cqEN-B4mcvMw_9lBN7FQG8pk9b5LBJ9xpM6PTgkGiqs,930
 vellum/client/types/price.py,sha256=ewzXDBVLaleuXMVQ-gQ3G1Nl5J2OWOVEMEFfnQIpiTk,610
 vellum/client/types/processing_failure_reason_enum.py,sha256=R_KIW7TcQejhc-vLhtNf9SdkYADgoZCn4ch4_RRIvsI,195
 vellum/client/types/prompt_block.py,sha256=MIsxxmAmuT0thkkG12xm3THO5dlRLbFeMZBVTSvb788,493
@@ -424,7 +424,7 @@ vellum/client/types/rejected_workflow_node_result_event.py,sha256=o9AUc9hT60F8ck
 vellum/client/types/release_tag_source.py,sha256=YavosOXZ976yfXTNWRTZwh2HhRiYmSDk0bQCkl-jCoQ,158
 vellum/client/types/replace_test_suite_test_case_request.py,sha256=c1GT1RUCei1yWxyZy4Gv40PkXYisvK5OkzlqQ6WeBYA,1906
 vellum/client/types/rich_text_child_block.py,sha256=X_ACKFKSUx5SXT1cLp0Y5-7VrNxcGOggPm67Lk2442U,270
-vellum/client/types/rich_text_prompt_block.py,sha256=60Bg_1wuXAd5eBiO9xiN8NjMvYE67ZLTtAb1A3N-7oI,1036
+vellum/client/types/rich_text_prompt_block.py,sha256=_Y2tRnSDtOUYHcq7zNfYbgqcLZab-Zd-Yh6UKdybVIY,1036
 vellum/client/types/sandbox_scenario.py,sha256=f4S0tDxmPYHIrD_BMjRL3XZGcGxlWy9apfI64hV7MBE,844
 vellum/client/types/scenario_input.py,sha256=caC8p5ZnuXhv2ZiHvzTvKL3Ebtr4NXP9Q8UcJEVB8-U,476
 vellum/client/types/scenario_input_chat_history_variable_value.py,sha256=ihgJktmZpz_12wx2yPtyrSrBjcBcSg9fby7h_eLoXgI,835
@@ -566,7 +566,7 @@ vellum/client/types/token_overlapping_window_chunking_request.py,sha256=IjCs9UDr
 vellum/client/types/unit_enum.py,sha256=BKWRVp2WfHtGK4D6TsolhNJHGHfExzrRHkFn8H8QkwQ,113
 vellum/client/types/upload_document_response.py,sha256=6_5Cm4yBPq5nD-rEql6GsmrAtSVVtNRczOL5YwsBVMI,649
 vellum/client/types/upsert_test_suite_test_case_request.py,sha256=iB38vx4mo4yNLV5XTeXMGR-PJLOQPloWQOAAi7PDpM0,2079
-vellum/client/types/variable_prompt_block.py,sha256=TnFQpfulqvbO-Ogs0u_IqQ6TPMMRC_Grz5uzd9-gMTs,946
+vellum/client/types/variable_prompt_block.py,sha256=PZxTq_zu7wa5r2eTBbwCRL7hwDKaLaBT3URB1RR2WKw,946
 vellum/client/types/vellum_audio.py,sha256=oPm1bcxk7fTfWfHWOPSLvrZrRBjCyPDVDRMACPoWmMI,721
 vellum/client/types/vellum_audio_request.py,sha256=y9CZgQ1TteW0AHNk8GuAZLNVFa981rh7P9vyV8bfgys,728
 vellum/client/types/vellum_error.py,sha256=jCKfuCkDTiyFb1-QyP2cg0wReja6wMuooKPAjNhBA0M,643
@@ -1297,7 +1297,7 @@ vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=EvylK1rGKpd4iiooEW9O5A9Q8DMTtBwETe_GtQT8M-E,2139
 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=H1AVDnitwIkwya12oV68Qj2tyb786pfRHHz5qxtubD4,5935
+vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=fypgmZHgaDtGqSBC8rjYiyryJ0H58LPt_CafLfAprO0,6341
 vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=zdpNJoawB5PedsCCfgOGDDoWuif0jNtlV-K9sFL6cNQ,4968
 vellum/workflows/nodes/displayable/bases/search_node.py,sha256=pqiui8G6l_9FLE1HH4rCdFC73Bl7_AIBAmQQMjqe190,3570
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
@@ -1316,7 +1316,7 @@ vellum/workflows/nodes/displayable/guardrail_node/node.py,sha256=7Ep7Ff7FtFry3Jw
 vellum/workflows/nodes/displayable/inline_prompt_node/__init__.py,sha256=gSUOoEZLlrx35-tQhSAd3An8WDwBqyiQh-sIebLU9wU,74
 vellum/workflows/nodes/displayable/inline_prompt_node/node.py,sha256=dTnP1yH1P0NqMw3noxt9XwaDCpX8ZOhuvVYNAn_DdCQ,2119
 vellum/workflows/nodes/displayable/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py,sha256=189Oo66QDYJS8vCcyLe9ErJBGpWZVmPePFHta8wzdeM,2615
+vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py,sha256=P1DUL0wIG-cyA5dqGv7242cFWJXysmombdujKrJtl7k,4669
 vellum/workflows/nodes/displayable/merge_node/__init__.py,sha256=J8IC08dSH7P76wKlNuxe1sn7toNGtSQdFirUbtPDEs0,60
 vellum/workflows/nodes/displayable/merge_node/node.py,sha256=ZyPvcTgfPOneOm5Dc2kUOoPkwNJqwRPZSj232akXynA,324
 vellum/workflows/nodes/displayable/note_node/__init__.py,sha256=KWA3P4fyYJ-fOTky8qNGlcOotQ-HeHJ9AjZt6mRQmCE,58
@@ -1328,7 +1328,7 @@ vellum/workflows/nodes/displayable/search_node/node.py,sha256=yhFWulbNmSQoDAwtTS
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py,sha256=9yYM6001YZeqI1VOk1QuEM_yrffk_EdsO7qaPzINKds,92
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=pnbRCgdzWXrXhm5jDkDDASl5xu5w3DxskC34yJVmWUs,7147
 vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=lLnXKAUYtgvQ6MpT4GoTrqLtdlyDlUt1pPHrmu-Gf00,4705
+vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=UI_RMmXn9qwB-StnFPvkDd9FctBQAg43wrfouqvPepk,4701
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=4CMwDtXwTaEvFfDpA6j2iLqc7S6IICSkvVZOobEpeps,6954
 vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=KqKJtJ0vuNoPuUPMdILmBTt4a2fBBxxun-nmOI7T8jo,2585
 vellum/workflows/nodes/utils.py,sha256=EZt7CzJmgQBR_GWFpZr8d-oaoti3tolTd2Cv9wm7dKo,1087
@@ -1353,6 +1353,7 @@ vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPyc
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
 vellum/workflows/runner/runner.py,sha256=RXnLEmSJFbp0u4vKF7rvD2fscuYfcRYkspIJINnvFAI,27607
+vellum/workflows/sandbox.py,sha256=wNyOfd3gb6-O85EQcBIHNCnSYPH7Oufh2z4hQnR2HFU,2059
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=jpSzF1OQd3-fqi6dMGlNsQl-7JnJxCdzWIigmX8Wz-I,14425
 vellum/workflows/state/context.py,sha256=oXiEdNsWJi1coRB85IreTgUeR6_CrWWBXndtLff9S7M,1272
@@ -1360,6 +1361,8 @@ vellum/workflows/state/encoder.py,sha256=kRrqwD0vFCiSRZR3rg8Sjkh8sDEerQQhlvmdSYQ
 vellum/workflows/state/store.py,sha256=VYGBQgN1bpd1as5eGiouV_7scg8QsRs4_1aqZAGIsRQ,793
 vellum/workflows/state/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/state/tests/test_state.py,sha256=BQjcdREIK1MPuGhivRUgpynVJLftjEpH9RG3cRKxQEY,3310
+vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/tests/test_sandbox.py,sha256=OMN15LuFUV58-XnAhtBiLcEjNt-Pj6bZgetDr8miCiw,1808
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
 vellum/workflows/types/core.py,sha256=D2NcSBwGgWj_mtXZqe3KnEQcb5qd5HzqAwnxwmlCfCw,899
 vellum/workflows/types/generics.py,sha256=ZkfoRhWs042i5IjA99v2wIhmh1u-Wieo3LzosgGWJVk,600
@@ -1368,10 +1371,10 @@ vellum/workflows/types/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 vellum/workflows/types/tests/test_utils.py,sha256=t6eqTSZqw2oVkIw6lP393qVmuyzjZZ62Ls1iELwZg_o,2434
 vellum/workflows/types/utils.py,sha256=Vk_itjV8YrfoT_Pm_x7QMvBdpCTr_XBTlszqZkQQJLw,5587
 vellum/workflows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/functions.py,sha256=udPTz1yFuSbHIQ6UeOUXro_hj4c8XdAb00_bH-Bf9N0,2529
+vellum/workflows/utils/functions.py,sha256=7A4BImhtY__qQpNrF5uPiwLfkj6PSUxYvF7ITigIkxY,4051
 vellum/workflows/utils/names.py,sha256=QLUqfJ1tmSEeUwBKTTiv_Qk3QGbInC2RSmlXfGXc8Wo,380
 vellum/workflows/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/tests/test_functions.py,sha256=68OdrS1Gf3incmRd4g3a7-nylqQbJdQjl7AyfVUJg5I,5223
+vellum/workflows/utils/tests/test_functions.py,sha256=ytdruS55aO2egsb5sAv8_9jf68L1cJoZu2uKV2iamrg,8083
 vellum/workflows/utils/tests/test_names.py,sha256=aOqpyvMsOEK_9mg_-yaNxQDW7QQfwqsYs37PseyLhxw,402
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
 vellum/workflows/utils/tests/test_vellum_variables.py,sha256=0ISy1xjY7_rci0Mt_naK0xrmurE1REZLMCgPOCLFKRM,776
@@ -1381,8 +1384,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=zpspOEdO5Ye_0ZvN-Wkzv9iQSiF1sD201ba8lhbnPbs,17086
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
-vellum_ai-0.12.4.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.12.4.dist-info/METADATA,sha256=NGdP3b6at6hPyXJWKWlyXKb0dSLEnYSUy3yIy1pVJIc,5128
-vellum_ai-0.12.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.12.4.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.12.4.dist-info/RECORD,,
+vellum_ai-0.12.6.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.12.6.dist-info/METADATA,sha256=C1VU1fn4OEzUUW4pv7NTqN6hMP4XCwxUZldj2hAtths,5128
+vellum_ai-0.12.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.12.6.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.12.6.dist-info/RECORD,,

vellum_cli/__init__.py

@@ -125,10 +125,16 @@ Should only be used for debugging purposes.""",
     help="""Exclude the code definition of each Resource from the pull response. \
 Should only be used for debugging purposes.""",
 )
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="""Raises an error immediately if there are any issues with the pulling of the Resource.""",
+)
 def pull(
     ctx: click.Context,
     include_json: Optional[bool],
     exclude_code: Optional[bool],
+    strict: Optional[bool],
 ) -> None:
     """Pull Resources from Vellum"""
 
@@ -136,6 +142,7 @@ def pull(
         pull_command(
             include_json=include_json,
             exclude_code=exclude_code,
+            strict=strict,
         )
 
 
@@ -159,12 +166,18 @@ Should only be used for debugging purposes.""",
     help="""Exclude the code definition of the Workflow from the pull response. \
 Should only be used for debugging purposes.""",
 )
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="""Raises an error immediately if there are any issues with the pulling of the Workflow.""",
+)
 def workflows_pull(
     module: Optional[str],
     include_json: Optional[bool],
     workflow_sandbox_id: Optional[str],
     workflow_deployment: Optional[str],
     exclude_code: Optional[bool],
+    strict: Optional[bool],
 ) -> None:
     """
     Pull Workflows from Vellum. If a module is provided, only the Workflow for that module will be pulled.
@@ -177,6 +190,7 @@ def workflows_pull(
         workflow_sandbox_id=workflow_sandbox_id,
         workflow_deployment=workflow_deployment,
         exclude_code=exclude_code,
+        strict=strict,
     )
 
 

vellum_cli/pull.py

@@ -13,6 +13,8 @@ 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
 
+ERROR_LOG_FILE_NAME = "error.log"
+
 
 def _is_valid_uuid(val: Union[str, UUID, None]) -> bool:
     try:
@@ -81,6 +83,7 @@ def pull_command(
     workflow_deployment: Optional[str] = None,
     include_json: Optional[bool] = None,
     exclude_code: Optional[bool] = None,
+    strict: Optional[bool] = None,
 ) -> None:
     load_dotenv()
     logger = load_cli_logger()
@@ -109,6 +112,8 @@ def pull_command(
         query_parameters["include_json"] = include_json
     if exclude_code:
         query_parameters["exclude_code"] = exclude_code
+    if strict:
+        query_parameters["strict"] = strict
 
     response = client.workflows.pull(
         pk,
@@ -119,6 +124,7 @@ def pull_command(
     zip_buffer = io.BytesIO(zip_bytes)
 
     target_dir = os.path.join(os.getcwd(), *workflow_config.module.split("."))
+    error_content = ""
     with zipfile.ZipFile(zip_buffer) as zip_file:
         # Delete files in target_dir that aren't in the zip file
         if os.path.exists(target_dir):
@@ -146,8 +152,13 @@ def pull_command(
             target_file = os.path.join(target_dir, file_name)
             os.makedirs(os.path.dirname(target_file), exist_ok=True)
             with zip_file.open(file_name) as source, open(target_file, "w") as target:
+                content = source.read().decode("utf-8")
+                if file_name == ERROR_LOG_FILE_NAME:
+                    error_content = content
+                    continue
+
                 logger.info(f"Writing to {target_file}...")
-                target.write(source.read().decode("utf-8"))
+                target.write(content)
 
     if include_json:
         logger.warning(
@@ -158,4 +169,7 @@ Its schema should be considered unstable and subject to change at any time."""
     if save_lock_file:
         config.save()
 
-    logger.info(f"Successfully pulled Workflow into {workflow_config.module}")
+    if error_content:
+        logger.error(error_content)
+    else:
+        logger.info(f"Successfully pulled Workflow into {workflow_config.module}")

vellum_cli/tests/test_pull.py

@@ -441,3 +441,48 @@ def test_pull__sandbox_id_with_other_workflow_deployment_in_lock(vellum_client,
                 "deployments": [],
             },
         ]
+
+
+def test_pull__handle_error_log(vellum_client, mock_module):
+    # GIVEN a pyproject.toml with a workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+
+    # AND the workflow pull API call returns a zip file with an error log
+    vellum_client.workflows.pull.return_value = iter(
+        [_zip_file_map({"workflow.py": "print('hello')", "error.log": "test error"})]
+    )
+
+    # WHEN the user runs the pull command with the new workflow sandbox id
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-sandbox-id", workflow_sandbox_id])
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0
+
+    # AND the error log file is not written to the module directory
+    assert not os.path.exists(os.path.join(temp_dir, *module.split("."), "error.log"))
+
+    # AND the error log is printed to the console
+    assert result.output.endswith("\x1b[31;20mtest error\x1b[0m\n")
+
+
+def test_pull__strict__with_error(vellum_client, mock_module):
+    # GIVEN a pyproject.toml with a workflow configured
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
+
+    # WHEN the user runs the pull command with the new workflow sandbox id
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "pull", "--strict", "--workflow-sandbox-id", workflow_sandbox_id])
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0
+
+    # AND the pull api is called with strict=True
+    vellum_client.workflows.pull.assert_called_once()
+    call_args = vellum_client.workflows.pull.call_args.kwargs
+    assert call_args["request_options"]["additional_query_parameters"] == {"strict": True}

vellum_ee/workflows/display/nodes/base_node_vellum_display.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Optional
+from typing import ClassVar, Dict, Optional, Union
 
 from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.ports import Port
@@ -18,7 +18,7 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
     target_handle_id: ClassVar[Optional[UUID]] = None
 
     # Used to explicitly set the node input ids by name for a node
-    node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
+    node_input_ids_by_name: ClassVar[Dict[str, Union[UUID, str]]] = {}
 
     def _get_node_display_uuid(self, attribute: str) -> UUID:
         explicit_value = self._get_explicit_node_display_attr(attribute, UUID)

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

@@ -1,6 +1,6 @@
 import inspect
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, Optional, TypeVar
+from typing import ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
 from vellum.workflows.nodes.displayable.code_execution_node.utils import read_file_from_path
@@ -21,8 +21,6 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
     output_id: ClassVar[Optional[UUID]] = None
     log_output_id: ClassVar[Optional[UUID]] = None
 
-    node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
-
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -40,17 +40,17 @@ _ConditionalNodeType = TypeVar("_ConditionalNodeType", bound=ConditionalNode)
 
 @dataclass
 class RuleIdMap:
-    id: UUID
+    id: str
     lhs: Optional["RuleIdMap"]
     rhs: Optional["RuleIdMap"]
-    field_node_input_id: Optional[UUID]
-    value_node_input_id: Optional[UUID]
+    field_node_input_id: Optional[str]
+    value_node_input_id: Optional[str]
 
 
 @dataclass
 class ConditionId:
-    id: UUID
-    rule_group_id: Optional[UUID]
+    id: str
+    rule_group_id: Optional[str]
 
 
 class BaseConditionalNodeDisplay(BaseNodeVellumDisplay[_ConditionalNodeType], Generic[_ConditionalNodeType]):
@@ -112,7 +112,7 @@ but the defined conditions have length {len(condition_ids)}"""
                     node_id, f"{current_id}.field", descriptor._expression, display_context, field_node_input_id
                 )
                 node_inputs.append(expression_node_input)
-                field_node_input_id = UUID(expression_node_input.id)
+                field_node_input_id = expression_node_input.id
                 operator = self._convert_descriptor_to_operator(descriptor)
 
             elif isinstance(descriptor, (BetweenExpression, NotBetweenExpression)):
@@ -128,8 +128,8 @@ but the defined conditions have length {len(condition_ids)}"""
                 )
                 node_inputs.extend([field_node_input, value_node_input])
                 operator = self._convert_descriptor_to_operator(descriptor)
-                field_node_input_id = UUID(field_node_input.id)
-                value_node_input_id = UUID(value_node_input.id)
+                field_node_input_id = field_node_input.id
+                value_node_input_id = value_node_input.id
 
             else:
                 lhs = descriptor._lhs  # type: ignore[attr-defined]
@@ -145,19 +145,19 @@ but the defined conditions have length {len(condition_ids)}"""
                         node_id, f"{current_id}.value", rhs, display_context, value_node_input_id
                     )
                     node_inputs.append(rhs_node_input)
-                    value_node_input_id = UUID(rhs_node_input.id)
+                    value_node_input_id = rhs_node_input.id
 
                 operator = self._convert_descriptor_to_operator(descriptor)
-                field_node_input_id = UUID(lhs_node_input.id)
+                field_node_input_id = lhs_node_input.id
 
             return {
-                "id": str(current_id),
+                "id": current_id,
                 "rules": None,
                 "combinator": None,
                 "negated": False,
-                "field_node_input_id": str(field_node_input_id),
+                "field_node_input_id": field_node_input_id,
                 "operator": operator,
-                "value_node_input_id": str(value_node_input_id),
+                "value_node_input_id": value_node_input_id,
             }
 
         conditions = []
@@ -263,7 +263,7 @@ but the defined conditions have length {len(condition_ids)}"""
 
     def get_nested_rule_details_by_path(
         self, rule_ids: List[RuleIdMap], path: List[int]
-    ) -> Union[Tuple[UUID, Optional[UUID], Optional[UUID]], None]:
+    ) -> Union[Tuple[str, Optional[str], Optional[str]], None]:
         current_rule = rule_ids[path[0]]
 
         for step in path[1:]:
@@ -284,11 +284,11 @@ but the defined conditions have length {len(condition_ids)}"""
 
         return None
 
-    def _generate_hash_for_rule_ids(self, node_id, rule_id) -> Tuple[UUID, UUID, UUID]:
+    def _generate_hash_for_rule_ids(self, node_id, rule_id) -> Tuple[str, str, str]:
         return (
-            uuid4_from_hash(f"{node_id}|{rule_id}|current"),
-            uuid4_from_hash(f"{node_id}|{rule_id}||field"),
-            uuid4_from_hash(f"{node_id}|{rule_id}||value"),
+            str(uuid4_from_hash(f"{node_id}|{rule_id}|current")),
+            str(uuid4_from_hash(f"{node_id}|{rule_id}||field")),
+            str(uuid4_from_hash(f"{node_id}|{rule_id}||value")),
         )
 
     def _get_source_handle_ids(self) -> Dict[int, UUID]:

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

@@ -28,7 +28,9 @@ class VariableIdMap:
 
 
 class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_SearchNodeType]):
-    input_variable_ids_by_logical_id: Optional[Dict[str, str]] = None
+    # A mapping between the id of the operand (e.g. "lhs_variable_id" or "rhs_variable_id") and the id of the node input
+    # that the operand is pointing to.
+    metadata_filter_input_id_by_operand_id: Dict[UUID, UUID] = {}
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
@@ -149,18 +151,20 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                 variables,
             )
         elif isinstance(logical_expression, VellumValueLogicalConditionRequest):
-            lhs_variable_id = str(logical_expression.lhs_variable.value)
-            rhs_variable_id = str(logical_expression.rhs_variable.value)
-            lhs_query_input_id = (
-                self.input_variable_ids_by_logical_id[lhs_variable_id]
-                if self.input_variable_ids_by_logical_id
-                else str(uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}"))
-            )
-            rhs_query_input_id = (
-                self.input_variable_ids_by_logical_id[rhs_variable_id]
-                if self.input_variable_ids_by_logical_id
-                else str(uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}"))
-            )
+            lhs_variable_id = logical_expression.lhs_variable.value
+            if not isinstance(lhs_variable_id, str):
+                raise TypeError(f"Expected lhs_variable_id to be a string, got {type(lhs_variable_id)}")
+
+            rhs_variable_id = logical_expression.rhs_variable.value
+            if not isinstance(rhs_variable_id, str):
+                raise TypeError(f"Expected rhs_variable_id to be a string, got {type(rhs_variable_id)}")
+
+            lhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
+                UUID(lhs_variable_id)
+            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+            rhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
+                UUID(rhs_variable_id)
+            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
 
             return (
                 {
@@ -173,7 +177,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                     create_node_input(
                         self.node_id,
                         f"vellum-query-builder-variable-{lhs_variable_id}",
-                        lhs_query_input_id,
+                        str(lhs_query_input_id),
                         display_context,
                         input_id=UUID(lhs_variable_id),
                         pointer_type=InputVariablePointer,
@@ -181,7 +185,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                     create_node_input(
                         self.node_id,
                         f"vellum-query-builder-variable-{rhs_variable_id}",
-                        rhs_query_input_id,
+                        str(rhs_query_input_id),
                         display_context,
                         input_id=UUID(rhs_variable_id),
                         pointer_type=InputVariablePointer,

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

@@ -25,7 +25,7 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
 
         template_input_id = self.template_input_id or next(
             (
-                input_id
+                UUID(input_id) if isinstance(input_id, str) else input_id
                 for input_name, input_id in self.node_input_ids_by_name.items()
                 if input_name == TEMPLATE_INPUT_NAME
             ),

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Any, List, Optional, Type, cast
+from typing import Any, List, Optional, Type, Union, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
@@ -27,10 +27,10 @@ def create_node_input(
     input_name: str,
     value: Any,
     display_context: WorkflowDisplayContext,
-    input_id: Optional[UUID],
+    input_id: Union[Optional[UUID], Optional[str]],
     pointer_type: Optional[Type[NodeInputValuePointerRule]] = ConstantValuePointer,
 ) -> NodeInput:
-    input_id = input_id or uuid4_from_hash(f"{node_id}|{input_name}")
+    input_id = str(input_id) if input_id else str(uuid4_from_hash(f"{node_id}|{input_name}"))
     if (
         isinstance(value, OutputReference)
         and value.outputs_class._node_class
@@ -42,7 +42,7 @@ def create_node_input(
 
     rules = create_node_input_value_pointer_rules(value, display_context, pointer_type=pointer_type)
     return NodeInput(
-        id=str(input_id),
+        id=input_id,
         key=input_name,
         value=NodeInputValuePointer(
             rules=rules,