vellum-ai 0.14.66__py3-none-any.whl → 0.14.67__py3-none-any.whl

vellum/workflows/nodes/bases/base.py

@@ -10,6 +10,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
@@ -92,7 +93,7 @@ class BaseNodeMeta(ABCMeta):
                 if issubclass(base, BaseNode):
                     ports_dct = {p.name: Port(default=p.default) for p in base.Ports}
                     ports_dct["__module__"] = dct["__module__"]
-                    dct["Ports"] = type(f"{name}.Ports", (NodePorts,), ports_dct)
+                    dct["Ports"] = type(f"{name}.Ports", (base.Ports,), ports_dct)
                     break
 
         if "Execution" not in dct:
@@ -357,41 +358,15 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
                 state.meta.node_execution_cache._dependencies_invoked[execution_id].add(invoked_by)
                 return execution_id
 
-            # For AWAIT_ANY in workflows, we have two cases:
-            # 1. The node is being re-executed because of a fork
-            # 2. The node is being re-executed because of a loop
-            # For case 1, we need to remove the fork id from the node_to_fork_id mapping
-            # For case 2, we need to check if the node is in a loop
+            # For AWAIT_ANY in workflows, we need to detect if the node is in a loop
+            # If the node is in a loop, we can trigger the node again
             in_loop = False
-            # Default to true, will be set to false if the merged node has already been triggered
-            should_retrigger = True
             if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
-                # Get the node that triggered the current execution
-                invoked_by_node = state.meta.node_execution_cache.__node_execution_lookup__.get(invoked_by)
-
-                # Check if invoked by node is a forked node
-                if invoked_by_node is not None:
-                    fork_id = state.meta.node_execution_cache.__node_to_fork_id__.get(invoked_by_node, None)
-                    if fork_id:
-                        # If the invoked by node has a fork id and that fork id is in __all_fork_ids__
-                        #   We will
-                        #   1. remove the fork id from __all_fork_ids__
-                        #   2. remove the fork id from the __node_to_fork_id__ mapping
-                        # else (this mean the fork has already been triggered)
-                        #   remove the id from the node_to_fork_id mapping and not retrigger again
-                        all_fork_ids = state.meta.node_execution_cache.__all_fork_ids__
-                        if fork_id in all_fork_ids:
-                            # When the next forked node merge, it will not trigger the node again
-                            # We should consider adding a lock here to prevent race condition
-                            all_fork_ids.remove(fork_id)
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(invoked_by_node, None)
-                        else:
-                            should_retrigger = False
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(invoked_by_node, None)
-
-                # If should_retrigger is false, then we will not trigger the node already
-                # So we don't need to check loop behavior
-                if should_retrigger:
+                # Get the latest fulfilled execution ID of current node
+                fulfilled_stack = state.meta.node_execution_cache._node_executions_fulfilled[cls.node_class]
+                current_latest_fulfilled_id = fulfilled_stack.peek() if not fulfilled_stack.is_empty() else None
+                # If the current node has not been fulfilled yet, we don't need to check for loop
+                if current_latest_fulfilled_id is not None:
                     # Trace back through the dependency chain to detect if this node triggers itself
                     visited = set()
                     current_execution_id = invoked_by
@@ -417,15 +392,18 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
                             current_execution_id
                         )
 
-                        # If we've found our target node class in the chain, we're in a loop
+                        # If we've found our target node class in the chain
                         if current_node_class == cls.node_class:
-                            in_loop = True
+                            # Check if the execution id is the same as the latest fulfilled execution id
+                            # If yes, we're in a loop
+                            if current_execution_id == current_latest_fulfilled_id:
+                                in_loop = True
+                            # If not, current node has been triggered by other node,
+                            # we can break out of the loop
                             break
 
             for queued_node_execution_id in state.meta.node_execution_cache._node_executions_queued[cls.node_class]:
-                # When should_retrigger is false, it means the merged node has already been triggered
-                # So we don't need to trigger the node again
-                if not should_retrigger or (
+                if (
                     invoked_by not in state.meta.node_execution_cache._dependencies_invoked[queued_node_execution_id]
                     and not in_loop
                 ):
@@ -509,3 +487,16 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
+
+    __simulates_workflow_output__ = False
+
+    def __directly_emit_workflow_output__(
+        self, event: NodeExecutionStreamingEvent, workflow_output_descriptor: OutputReference
+    ) -> bool:
+        """
+        In the legacy workflow runner, there was support for emitting streaming workflow outputs for prompt nodes
+        connected to terminal nodes. These two private methods provides a hacky, intentionally short-lived workaround
+        for us to enable this until we can directly reference prompt outputs from the UI.
+        """
+
+        return False

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -1,6 +1,6 @@
 import pytest
 from uuid import UUID
-from typing import Optional
+from typing import Optional, Set
 
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.core.pydantic_utilities import UniversalBaseModel
@@ -9,7 +9,9 @@ from vellum.workflows.descriptors.tests.test_utils import FixtureState
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import FinalOutputNode
 from vellum.workflows.nodes.bases.base import BaseNode
-from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.ports.port import Port
+from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState, StateMeta
@@ -333,3 +335,47 @@ def test_base_node__node_reference_of_inherited_annotation():
     # THEN the node reference is of the correct type
     assert isinstance(node_reference, NodeReference)
     assert node_reference.name == "foo"
+
+
+def test_base_node__ports_inheritance():
+    # GIVEN a node with one port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference(True))
+
+            def __lt__(self, output: BaseOutput) -> Set[Port]:
+                return {self.foo}
+
+    # AND a node that inherits from MyNode
+    class InheritedNode(MyNode):
+        pass
+
+    # WHEN we collect the ports
+    ports = [port.name for port in InheritedNode.Ports]
+
+    # THEN the inheritance is correct
+    inherited_ports = InheritedNode.Ports()
+    assert inherited_ports.__lt__(BaseOutput(name="foo")) == {InheritedNode.Ports.foo}
+
+    # AND the ports are correct
+    assert ports == ["foo"]
+
+
+def test_base_node__ports_inheritance__cumulative_ports():
+    # GIVEN a node with one port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference(True))
+
+    # AND a node that inherits from MyNode with another port
+    class InheritedNode(MyNode):
+        class Ports(MyNode.Ports):
+            bar = Port.on_if(ConstantValueReference(True))
+
+    # WHEN we collect the ports
+    ports = [port.name for port in InheritedNode.Ports]
+
+    # THEN the ports are correct
+    # Potentially in the future, we support inheriting ports from multiple parents.
+    # For now, we take only the declared ports, so that not all nodes have the default port.
+    assert ports == ["bar"]

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

@@ -51,7 +51,9 @@ class APINode(BaseAPINode):
         final_headers = {**headers, **header_overrides}
 
         vellum_client_wrapper = self._context.vellum_client._client_wrapper
-        if self.url.startswith(vellum_client_wrapper._environment.default) and "X-API-Key" not in final_headers:
+        if self.url.startswith(vellum_client_wrapper._environment.default) and (
+            "X-API-Key" not in final_headers and "X_API_KEY" not in final_headers
+        ):
             final_headers["X-API-Key"] = vellum_client_wrapper.api_key
 
         return self._run(

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -158,3 +158,35 @@ def test_api_node__detects_client_environment_urls__does_not_override_headers(
     # AND the vellum API should have been called with the correct headers
     assert mock_response.last_request
     assert mock_response.last_request.headers["X-API-Key"] == "vellum-api-key-5678"
+
+
+def test_api_node__detects_client_environment_urls__legacy_does_not_override_headers(
+    mock_httpx_transport, mock_requests, monkeypatch
+):
+    # GIVEN an API node with a URL pointing back to Vellum
+    class SimpleAPINodeToVellum(APINode):
+        url = "https://api.vellum.ai"
+        headers = {
+            "X_API_KEY": "vellum-api-key-5678",
+        }
+
+    # AND a mock request sent to the Vellum API would return a 200
+    mock_response = mock_requests.get(
+        "https://api.vellum.ai",
+        status_code=200,
+        json={"data": [1, 2, 3]},
+    )
+
+    # AND an api key is set
+    monkeypatch.setenv("VELLUM_API_KEY", "vellum-api-key-1234")
+
+    # WHEN we run the node
+    node = SimpleAPINodeToVellum()
+    node.run()
+
+    # THEN the execute_api method should not have been called
+    mock_httpx_transport.handle_request.assert_not_called()
+
+    # AND the vellum API should have been called with the correct headers
+    assert mock_response.last_request
+    assert mock_response.last_request.headers["X_API_KEY"] == "vellum-api-key-5678"

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

@@ -5,9 +5,11 @@ from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
 from vellum.client.core.api_error import ApiError
 from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode, vellum_error_to_workflow_error
+from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -85,3 +87,29 @@ class BasePromptNode(BaseNode, Generic[StateType]):
             message="Failed to execute Prompt",
             code=WorkflowErrorCode.INTERNAL_ERROR,
         ) from e
+
+    def __directly_emit_workflow_output__(
+        self,
+        event: NodeExecutionStreamingEvent,
+        workflow_output_descriptor: OutputReference,
+    ) -> bool:
+        if event.output.name != "results":
+            return False
+
+        if not isinstance(event.output.delta, str) and not event.output.is_initiated:
+            return False
+
+        target_nodes = [e.to_node for e in self.Ports.default.edges if e.to_node.__simulates_workflow_output__]
+        target_node_output = next(
+            (
+                o
+                for target_node in target_nodes
+                for o in target_node.Outputs
+                if o == workflow_output_descriptor.instance
+            ),
+            None,
+        )
+        if not target_node_output:
+            return False
+
+        return True

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

@@ -2,7 +2,6 @@ from typing import Set
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
-from vellum.workflows.ports.node_ports import NodePorts
 from vellum.workflows.ports.port import Port
 from vellum.workflows.ports.utils import validate_ports
 from vellum.workflows.state.base import BaseState
@@ -18,7 +17,7 @@ class ConditionalNode(BaseNode):
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
-    class Ports(NodePorts):
+    class Ports(BaseNode.Ports):
         def __call__(self, outputs: BaseOutputs, state: BaseState) -> Set[Port]:
             all_ports = [port for port in self.__class__]
             enforce_single_invoked_port = validate_ports(all_ports)

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

@@ -61,3 +61,5 @@ class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], meta
                 self.__class__.get_output_type(),
             )
         )
+
+    __simulates_workflow_output__ = True

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

@@ -1,6 +1,8 @@
 import json
 from typing import ClassVar
 
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseSearchNode as BaseSearchNode
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types import MergeBehavior
@@ -35,6 +37,12 @@ class SearchNode(BaseSearchNode[StateType]):
         text: str
 
     def run(self) -> Outputs:
+        if self.query is None or self.query == "":
+            raise NodeException(
+                message="Search query is required but was not provided",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
         if not isinstance(self.query, str):
             self.query = json.dumps(self.query, cls=DefaultStateEncoder)
 

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

@@ -1,3 +1,4 @@
+import pytest
 import json
 
 from vellum import SearchResponse, SearchResult, SearchResultDocument
@@ -10,6 +11,8 @@ from vellum.client.types.search_weights_request import SearchWeightsRequest
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.client.types.vellum_value_logical_condition_group_request import VellumValueLogicalConditionGroupRequest
 from vellum.client.types.vellum_value_logical_condition_request import VellumValueLogicalConditionRequest
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.types import (
     MetadataLogicalCondition,
     MetadataLogicalConditionGroup,
@@ -215,3 +218,19 @@ def test_run_workflow__chat_history_as_query(vellum_client):
     assert json.loads(vellum_client.search.call_args.kwargs["query"]) == [
         {"role": "USER", "text": "Hello, world!", "source": None, "content": None}
     ]
+
+
+@pytest.mark.parametrize("invalid_query", [None, ""])
+def test_run_workflow__invalid_query_raises_validation_error(invalid_query):
+    """Confirm that missing/None/empty query raises proper user-facing validation error"""
+
+    class MySearchNode(SearchNode):
+        query = invalid_query  # type: ignore[assignment]
+        document_index = "document_index"
+
+    with pytest.raises(NodeException) as exc_info:
+        MySearchNode().run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "query" in exc_info.value.message.lower()
+    assert "required" in exc_info.value.message.lower() or "missing" in exc_info.value.message.lower()

vellum/workflows/runner/runner.py

@@ -398,9 +398,7 @@ class WorkflowRunner(Generic[StateType]):
             return
 
         for port in ports:
-            nodes_to_fork = []
             for edge in port.edges:
-                nodes_to_fork.append(edge.to_node)
                 if port.fork_state:
                     next_state = deepcopy(state)
                     self._state_forks.add(next_state)
@@ -411,21 +409,6 @@ class WorkflowRunner(Generic[StateType]):
                     self._concurrency_queue.put((next_state, edge.to_node, invoked_by))
                 else:
                     self._run_node_if_ready(next_state, edge.to_node, invoked_by)
-                if invoked_by:
-                    previous_node = state.meta.node_execution_cache.__node_execution_lookup__.get(invoked_by)
-                    if previous_node:
-                        previous_node_fork_id = state.meta.node_execution_cache.__node_to_fork_id__.get(previous_node)
-                        if previous_node_fork_id:
-                            state.meta.node_execution_cache.__node_to_fork_id__[edge.to_node] = previous_node_fork_id
-                            # Remove previous node fork in __node_to_fork_id__
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(previous_node, None)
-
-            # If there are multiple edges, we need to create a fork ID
-            if len(nodes_to_fork) > 1:
-                fork_id = uuid4()
-                state.meta.node_execution_cache.__all_fork_ids__.add(fork_id)
-                for node in nodes_to_fork:
-                    state.meta.node_execution_cache.__node_to_fork_id__[node] = fork_id
 
         if self._max_concurrency:
             num_nodes_to_run = self._max_concurrency - len(self._active_nodes_by_execution_id)
@@ -484,6 +467,19 @@ class WorkflowRunner(Generic[StateType]):
 
         if event.name == "node.execution.streaming":
             for workflow_output_descriptor in self.workflow.Outputs:
+                if node.__directly_emit_workflow_output__(event, workflow_output_descriptor):
+                    active_node.was_outputs_streamed = True
+                    self._workflow_event_outer_queue.put(
+                        self._stream_workflow_event(
+                            BaseOutput(
+                                name=workflow_output_descriptor.name,
+                                value=event.output.value,
+                                delta=event.output.delta,
+                            )
+                        )
+                    )
+                    return None
+
                 node_output_descriptor = workflow_output_descriptor.instance
                 if not isinstance(node_output_descriptor, OutputReference):
                     continue

vellum/workflows/state/base.py

@@ -105,8 +105,6 @@ class NodeExecutionCache:
 
     # Derived fields - no need to serialize
     __node_execution_lookup__: NodeExecutionLookup  # execution_id -> node_class
-    __node_to_fork_id__: Dict[Type["BaseNode"], UUID]  # node_class -> fork_id
-    __all_fork_ids__: Set[UUID]
 
     def __init__(self) -> None:
         self._dependencies_invoked = defaultdict(set)
@@ -114,8 +112,6 @@ class NodeExecutionCache:
         self._node_executions_initiated = defaultdict(set)
         self._node_executions_queued = defaultdict(list)
         self.__node_execution_lookup__ = {}
-        self.__node_to_fork_id__ = {}
-        self.__all_fork_ids__ = set()
 
     @classmethod
     def deserialize(cls, raw_data: dict, nodes: Dict[Union[str, UUID], Type["BaseNode"]]):

{vellum_ai-0.14.66.dist-info → vellum_ai-0.14.67.dist-info}/METADATA

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

{vellum_ai-0.14.66.dist-info → vellum_ai-0.14.67.dist-info}/RECORD

@@ -17,7 +17,7 @@ vellum_cli/tests/test_image_push_error_handling.py,sha256=_Wjfkn1orI2K4Ahzqz4u8T
 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=91aOAYNzYcJuIrTwRvGX_Qa1_UOmdCfVAfvZVfwCKZ4,49902
+vellum_cli/tests/test_pull.py,sha256=hxMbW_j0weDDrkzVGpvLpFcwNQdn-fxTv4wBHeYizzc,49904
 vellum_cli/tests/test_push.py,sha256=I8XICg3pUb3yxAFLXziVHHf5CRm354LO-uUfwtca3bU,33897
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -91,13 +91,14 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=KkYZc_bZuq1lmDcvUz3QxIqJLpQPCZioD1FHUNsMJY8,11211
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=aZaqRDrkO3ytcmdM2eKJqHSt60MF070NMj6M2vgzOKc,7711
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=r748dpS13HtwY7t_KQFExFssxRy0xI2d-wxmhiUHRe0,3850
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py,sha256=DzoDdmAwabMTuNu2gCgAyO0KjZxFr9JlkQRz2koUAJ8,46504
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=Cx3oY6vPVap0xm_mChqfQw4zzR4pqV36o_SyD8g6jPY,8727
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=EL5kfakuoEcwD85dGjhMta-J-PpCHRSDoc80SdbBrQk,2769
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=RmFUDx8dYdfsOE2CGLvdXqNNRtLLpVzXDN8dqZyMcZ8,5822
 vellum_ee/workflows/display/types.py,sha256=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=7gWOsow_fkayY7GnByv1cN_XhbI24dJT-VQ5-WP46FU,12894
+vellum_ee/workflows/display/utils/expressions.py,sha256=Y0WMn0V3GjVTJShMSWIe3Z75NzrRfs4_qPytUTiqbhQ,13489
 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
@@ -135,7 +136,7 @@ vellum/client/README.md,sha256=CuGUYnaE0Imt0KqQ4sIPaUghCjLHkF3DdEvZWu14-8s,4807
 vellum/client/__init__.py,sha256=AYopGv2ZRVn3zsU8_km6KOvEHDbXiTPCVuYVI7bWvdA,120166
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=gluL9LJQaydz9m87P7bWACAysxbElOZWqF6JrbjOjDw,1869
+vellum/client/core/client_wrapper.py,sha256=UG87pjP1tGHRW2I49o0n-MZgePLXL1Ay39COyiMKCSQ,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
@@ -151,7 +152,7 @@ vellum/client/errors/bad_request_error.py,sha256=_EbO8mWqN9kFZPvIap8qa1lL_EWkRcs
 vellum/client/errors/forbidden_error.py,sha256=QO1kKlhClAPES6zsEK7g9pglWnxn3KWaOCAawWOg6Aw,263
 vellum/client/errors/internal_server_error.py,sha256=8USCagXyJJ1MOm9snpcXIUt6eNXvrd_aq7Gfcu1vlOI,268
 vellum/client/errors/not_found_error.py,sha256=tBVCeBC8n3C811WHRj_n-hs3h8MqwR5gp0vLiobk7W8,262
-vellum/client/reference.md,sha256=8JwIEywKFcq7r6YmD8fpb4hG8qq9xTZgjLbVkzDoADQ,53008
+vellum/client/reference.md,sha256=I-z_aZGJKDQh443ywv92ezeI9w_XsiLh-vHULu8RsDg,91011
 vellum/client/resources/__init__.py,sha256=XgQao4rJxyYu71j64RFIsshz4op9GE8-i-C5GCv-KVE,1555
 vellum/client/resources/ad_hoc/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 vellum/client/resources/ad_hoc/client.py,sha256=rtpiGR6j8CcXSnN6UW_jYwLLdfJ9dwkTm_nta9oRzno,25933
@@ -1550,11 +1551,11 @@ vellum/workflows/inputs/tests/test_inputs.py,sha256=lioA8917mFLYq7Ml69UNkqUjcWbb
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=TtvfbGnAB8fYfQlhBM-sF3fwZLYn_Nq-dqU9m1fAbBU,21923
+vellum/workflows/nodes/bases/base.py,sha256=FHZ5_pzN9NJ5Vpj1uo2QP-BzxCtVCUvcDo-taoqmasw,21095
 vellum/workflows/nodes/bases/base_adornment_node.py,sha256=hrgzuTetM4ynPd9YGHoK8Vwwn4XITi3aZZ_OCnQrq4Y,3433
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_adornment_node.py,sha256=fXZI9KqpS4XMBrBnIEkK3foHaBVvyHwYcQWWDKay7ic,1148
-vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=KRrgjXfzxf1ecE55-jwbQqPnOlNii-i2iaHJUW6oWcI,9358
+vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=Qk54NIuNa-eAtkq2AVeyl1AjZbotWlqdxTXrlZ3pIe0,10935
 vellum/workflows/nodes/core/__init__.py,sha256=5zDMCmyt1v0HTJzlUBwq3U9L825yZGZhT9JL18-mRR4,455
 vellum/workflows/nodes/core/error_node/__init__.py,sha256=g7RRnlHhqu4qByfLjBwCunmgGA8dI5gNsjS3h6TwlSI,60
 vellum/workflows/nodes/core/error_node/node.py,sha256=MFHU5vITYSK-L9CuMZ49In2ZeNLWnhZD0f8r5dWvb5Y,1270
@@ -1579,14 +1580,14 @@ vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW
 vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=h6eUc3SggvhzBWlOD0PrPUlkoCSQHwjqYn81VkxSIxU,4948
 vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDXl0Nmz4QzJV2PYe5RI,1023
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
-vellum/workflows/nodes/displayable/api_node/node.py,sha256=KOSEicUQScliWEnKyQdfuB-5Lw5ScG9PUd3WFP2nlSQ,2835
+vellum/workflows/nodes/displayable/api_node/node.py,sha256=CjbQJp9tGRgS-ebQqm3eoxmEeeSzrxousIawo3woUYw,2896
 vellum/workflows/nodes/displayable/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=CDoFRRCOYwmoLU5Kvv9pRrxYYuk29Lm4DBt_bKYZHcE,5677
+vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=s7-r3oGKeoQUaJ5w6FY8SXwuiafNpE6nvNT1gNJIBnM,6734
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
 vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=70pLGU0UzWvSbKwNkx3YlUYrDSkl7MmhVHoI8bzN79c,4343
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
-vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=amBXi7Tv50AbGLhfWbwX83PlOdV1XyYRyQmpa6_afE4,3511
+vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=ZW3tm5Ka_q39Tp70nMLl1L9aJymbeakxaeuxPwm8bKc,4450
 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=cD2RzOX9WE6xTKgm09dsEw4xHATZbOjeGyYCSdl8fjU,11785
@@ -1606,10 +1607,10 @@ vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/main.py,sh
 vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py,sha256=DRd-nOC04RGjXz-ctxADVq7b-hgdiFN3ZfhK6Ld7J8I,36634
 vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=VRTKms59vrSR9mDk99cojParZVAP4lzjEeDwDNXU1tk,3837
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
-vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
+vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=71ZUNfTiD7t2Kai2ypw0tmv1lSf1brQaHAQD-SeUrGE,1101
 vellum/workflows/nodes/displayable/conftest.py,sha256=K2kLM2JGAfcrmmd92u8DXInUO5klFdggPWblg5RVcx4,5729
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
-vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=PuQ0RvtAmoSIZ5En_92tym7gpSMEoiHgwu20-UDbC7o,2368
+vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=AfonKXEoT5kpTo4kVyhgZs0kf-7x7zyg2H2CGlj9eMQ,2410
 vellum/workflows/nodes/displayable/final_output_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py,sha256=E6LQ74qZjY4Xi4avx2qdOCgGhF8pEcNLBh8cqYRkzMI,709
 vellum/workflows/nodes/displayable/guardrail_node/__init__.py,sha256=Ab5eXmOoBhyV4dMWdzh32HLUmnPIBEK_zFCT38C4Fng,68
@@ -1630,9 +1631,9 @@ 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=vUTDyurYKw6KLABuVml_N_fbnNBDv5dBtejdoj82hWs,1646
+vellum/workflows/nodes/displayable/search_node/node.py,sha256=1dGCB1kb7MvX3fUJ5zP__Bh02mdPdRRsx_vwGyQFBVc,1981
 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=OserVd6jPe6t49MQF0cxphI2irBLaC_GceMr0acFqoY,8075
+vellum/workflows/nodes/displayable/search_node/tests/test_node.py,sha256=WVZR3BI_CvxBG9hulv0-tcAc_gW5ozs0nH4uVNRJa2U,8863
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py,sha256=9yYM6001YZeqI1VOk1QuEM_yrffk_EdsO7qaPzINKds,92
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=lq8_USZkNiYktH0oJSW2jOuXyRtVwVoq1CKFdCek5-M,9719
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1676,10 +1677,10 @@ vellum/workflows/references/workflow_input.py,sha256=W3rOK1EPd2gYHb04WJwmNm1CUSd
 vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPycOQevJxQnI,82
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=F-FIioGcWOXwl93id4QkcSwoYgSW_XnTZd7FDICWRvk,34129
+vellum/workflows/runner/runner.py,sha256=j2LGHb4fDWR1pB__C1efIMxptq_C49fcOpz893bQHVQ,33645
 vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2235
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
-vellum/workflows/state/base.py,sha256=mYldAAUxWBGhXW-dWCljkfabBtNsh_qNj1XGJq22PSg,22376
+vellum/workflows/state/base.py,sha256=WIMJYyuHUrP4zt0Nudk66HAK1L6GgGmsU_GQp7BGE2U,22189
 vellum/workflows/state/context.py,sha256=KOAI1wEGn8dGmhmAemJaf4SZbitP3jpIBcwKfznQaRE,3076
 vellum/workflows/state/encoder.py,sha256=8NPQ8iz5qJeT5fafnZ2Pko98b-FtTjsgMNV4Zi3g2bE,2438
 vellum/workflows/state/store.py,sha256=uVe-oN73KwGV6M6YLhwZMMUQhzTQomsVfVnb8V91gVo,1147
@@ -1714,8 +1715,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=fROqff6AZpCIzaSwOKSdtYy4XR0UZQ6ejxL3RJOSJVs,20447
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.66.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.66.dist-info/METADATA,sha256=bkr1Oj0n0HAwEiTLSb4lZEiDQQM_mtpz1uXZ1Lt7VQM,5556
-vellum_ai-0.14.66.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.66.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.66.dist-info/RECORD,,
+vellum_ai-0.14.67.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.67.dist-info/METADATA,sha256=Db8ryoXbUKuF3JFftIoP1q6KRkDfnDJfmBGl1tg5nUA,5556
+vellum_ai-0.14.67.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.67.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.67.dist-info/RECORD,,

vellum_cli/tests/test_pull.py

@@ -745,7 +745,7 @@ def test_pull__same_pull_twice__one_entry_in_lockfile(vellum_client, mock_module
     zip_contents = _zip_file_map({"workflow.py": "print('hello')"})
     responses = iter([zip_contents, zip_contents])
 
-    def workflows_pull_side_effect(*args, **kwargs):
+    def workflows_pull_side_effect(*_args, **_kwargs):
         return iter([next(responses)])
 
     vellum_client.workflows.pull.side_effect = workflows_pull_side_effect