vellum-ai 0.14.83__py3-none-any.whl → 0.14.85__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -16,10 +16,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/0.14.83",
+            "User-Agent": "vellum-ai/0.14.85",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.83",
+            "X-Fern-SDK-Version": "0.14.85",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

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

@@ -84,10 +84,13 @@ class InlineSubworkflowNode(
             )
 
         outputs: Optional[BaseOutputs] = None
+        exception: Optional[NodeException] = None
         fulfilled_output_names: Set[str] = set()
 
         for event in subworkflow_stream:
             self._context._emit_subworkflow_event(event)
+            if exception:
+                continue
 
             if not is_workflow_event(event):
                 continue
@@ -101,7 +104,15 @@ class InlineSubworkflowNode(
             elif event.name == "workflow.execution.fulfilled":
                 outputs = event.outputs
             elif event.name == "workflow.execution.rejected":
-                raise NodeException.of(event.error)
+                exception = NodeException.of(event.error)
+            elif event.name == "workflow.execution.paused":
+                exception = NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message="Subworkflow unexpectedly paused",
+                )
+
+        if exception:
+            raise exception
 
         if outputs is None:
             raise NodeException(

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

@@ -1,8 +1,9 @@
-from typing import ClassVar, List, Optional
+from typing import ClassVar, Iterator, List, Optional, Set
 
 from vellum import ChatMessage, PromptBlock
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
@@ -12,10 +13,11 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_tool_router_node,
     get_function_name,
 )
-from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface, Tool
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 class ToolCallingNode(BaseNode):
@@ -47,12 +49,12 @@ class ToolCallingNode(BaseNode):
         text: str
         chat_history: List[ChatMessage]
 
-    def run(self) -> Outputs:
+    def run(self) -> Iterator[BaseOutput]:
         """
-        Run the tool calling workflow.
+        Run the tool calling workflow with streaming support.
 
         This dynamically builds a graph with router and function nodes,
-        then executes the workflow.
+        then executes the workflow and streams chat_history updates.
         """
 
         self._build_graph()
@@ -77,24 +79,55 @@ class ToolCallingNode(BaseNode):
                 context=WorkflowContext.create_from(self._context),
             )
 
-            terminal_event = subworkflow.run()
-
-            if terminal_event.name == "workflow.execution.paused":
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message="Subworkflow unexpectedly paused",
-                )
-            elif terminal_event.name == "workflow.execution.fulfilled":
-                node_outputs = self.Outputs(
-                    text=terminal_event.outputs.text,
-                    chat_history=terminal_event.outputs.chat_history,
-                )
+            subworkflow_stream = subworkflow.stream(
+                event_filter=all_workflow_event_filter,
+                node_output_mocks=self._context._get_all_node_output_mocks(),
+            )
 
-                return node_outputs
-            elif terminal_event.name == "workflow.execution.rejected":
-                raise NodeException(message=terminal_event.error.message, code=terminal_event.error.code)
+        outputs: Optional[BaseOutputs] = None
+        exception: Optional[NodeException] = None
+        fulfilled_output_names: Set[str] = set()
+
+        # Yield initiated event for chat_history
+        yield BaseOutput(name="chat_history")
+
+        for event in subworkflow_stream:
+            self._context._emit_subworkflow_event(event)
+
+            if not is_workflow_event(event):
+                continue
+            if event.workflow_definition != ToolCallingWorkflow:
+                continue
+
+            if event.name == "workflow.execution.streaming":
+                if event.output.name == "chat_history":
+                    if event.output.is_fulfilled:
+                        fulfilled_output_names.add(event.output.name)
+                    yield event.output
+                elif event.output.name == "text":
+                    if event.output.is_fulfilled:
+                        fulfilled_output_names.add(event.output.name)
+                    yield event.output
+            elif event.name == "workflow.execution.fulfilled":
+                outputs = event.outputs
+            elif event.name == "workflow.execution.rejected":
+                exception = NodeException.of(event.error)
+
+        if exception:
+            raise exception
+
+        if outputs is None:
+            raise NodeException(
+                message="Expected to receive outputs from Tool Calling Workflow",
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+            )
 
-            raise Exception(f"Unexpected workflow event: {terminal_event.name}")
+        for output_descriptor, output_value in outputs:
+            if output_descriptor.name not in fulfilled_output_names:
+                yield BaseOutput(
+                    name=output_descriptor.name,
+                    value=output_value,
+                )
 
     def _build_graph(self) -> None:
         self.tool_router_node = create_tool_router_node(

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

@@ -114,7 +114,7 @@ def test_tool_calling_node_inline_workflow_context():
     function_node.state = TestState(meta=StateMeta(node_outputs={tool_router_node.Outputs.text: '{"arguments": {}}'}))
 
     # WHEN the function node runs
-    outputs = function_node.run()
+    outputs = list(function_node.run())
 
     # THEN the workflow should have run successfully
     assert outputs is not None

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

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

vellum/workflows/runner/runner.py

@@ -15,6 +15,7 @@ from typing import (
     Generic,
     Iterable,
     Iterator,
+    List,
     Optional,
     Sequence,
     Set,
@@ -67,7 +68,9 @@ from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference, OutputReference
+from vellum.workflows.references.state_value import StateValueReference
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.state.delta import StateDelta
 from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 if TYPE_CHECKING:
@@ -175,12 +178,16 @@ class WorkflowRunner(Generic[StateType]):
         setattr(
             self._initial_state,
             "__snapshot_callback__",
-            lambda s: self._snapshot_state(s),
+            lambda s, d: self._snapshot_state(s, d),
         )
         self.workflow.context._register_event_queue(self._workflow_event_inner_queue)
         self.workflow.context._register_node_output_mocks(node_output_mocks or [])
 
-    def _snapshot_state(self, state: StateType) -> StateType:
+        self._outputs_listening_to_state = [
+            descriptor for descriptor in self.workflow.Outputs if isinstance(descriptor.instance, StateValueReference)
+        ]
+
+    def _snapshot_state(self, state: StateType, deltas: List[StateDelta]) -> StateType:
         self._workflow_event_inner_queue.put(
             WorkflowExecutionSnapshottedEvent(
                 trace_id=self._execution_context.trace_id,
@@ -192,6 +199,31 @@ class WorkflowRunner(Generic[StateType]):
                 parent=self._execution_context.parent_context,
             )
         )
+
+        delta_names = [d.name for d in deltas]
+        for descriptor in self._outputs_listening_to_state:
+            if not isinstance(descriptor.instance, StateValueReference):
+                continue
+
+            if descriptor.instance.name not in delta_names:
+                continue
+
+            resolved_delta = descriptor.instance.resolve(state)
+            if resolved_delta is undefined:
+                continue
+
+            self._workflow_event_outer_queue.put(
+                self._stream_workflow_event(
+                    BaseOutput(
+                        name=descriptor.name,
+                        # We may want to switch this to using the delta from the state delta
+                        # instead of the state value. In the short term, we need to show
+                        # the full conversation of the tool calling node's delta's.
+                        delta=resolved_delta,
+                    )
+                )
+            )
+
         self.workflow._store.append_state_snapshot(state)
         self._background_thread_queue.put(state)
         return state

vellum/workflows/state/base.py

@@ -7,7 +7,21 @@ import logging
 from queue import Queue
 from threading import Lock
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    SupportsIndex,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler, ValidationInfo, field_serializer, field_validator
@@ -18,6 +32,7 @@ from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.references import ExternalInputReference, OutputReference, StateValueReference
+from vellum.workflows.state.delta import AppendStateDelta, SetStateDelta, StateDelta
 from vellum.workflows.types.definition import CodeResourceDefinition, serialize_type_encoder_with_id
 from vellum.workflows.types.generics import StateType, import_workflow_class, is_workflow_class
 from vellum.workflows.types.stack import Stack
@@ -31,16 +46,12 @@ logger = logging.getLogger(__name__)
 
 
 class _Snapshottable:
-    _snapshot_callback: Callable[[], None]
+    _snapshot_callback: Callable[[Optional[StateDelta]], None]
+    _path: str
 
-    def __deepcopy__(self, memo: Any) -> "_Snapshottable":
-        return deepcopy_with_exclusions(
-            self,
-            memo=memo,
-            exclusions={
-                "_snapshot_callback": self._snapshot_callback,
-            },
-        )
+    def __bind__(self, path: str, snapshot_callback: Callable[[Optional[StateDelta]], None]) -> None:
+        self._snapshot_callback = snapshot_callback
+        self._path = path
 
 
 @dataclass_transform(kw_only_default=True)
@@ -71,10 +82,44 @@ class _BaseStateMeta(type):
 class _SnapshottableDict(dict, _Snapshottable):
     def __setitem__(self, key: Any, value: Any) -> None:
         super().__setitem__(key, value)
-        self._snapshot_callback()
+        self._snapshot_callback(SetStateDelta(name=f"{self._path}.{key}", delta=value))
+
+    def __deepcopy__(self, memo: Any) -> "_SnapshottableDict":
+        y: dict = {}
+        memo[id(self)] = y
+        for key, value in self.items():
+            y[deepcopy(key, memo)] = deepcopy(value, memo)
+
+        y = _SnapshottableDict(y)
+        y.__bind__(self._path, self._snapshot_callback)
+        memo[id(self)] = y
+        return y
+
+
+class _SnapshottableList(list, _Snapshottable):
+    def __setitem__(self, index: Union[SupportsIndex, slice], value: Any) -> None:
+        super().__setitem__(index, value)
+        if isinstance(index, int):
+            self._snapshot_callback(SetStateDelta(name=f"{self._path}.{index}", delta=value))
+
+    def append(self, value: Any) -> None:
+        super().append(value)
+        self._snapshot_callback(AppendStateDelta(name=self._path, delta=value))
+
+    def __deepcopy__(self, memo: Any) -> "_SnapshottableList":
+        y: list = []
+        memo[id(self)] = y
+        append = y.append
+        for a in self:
+            append(deepcopy(a, memo))
 
+        y = _SnapshottableList(y)
+        y.__bind__(self._path, self._snapshot_callback)
+        memo[id(self)] = y
+        return y
 
-def _make_snapshottable(value: Any, snapshot_callback: Callable[[], None]) -> Any:
+
+def _make_snapshottable(path: str, value: Any, snapshot_callback: Callable[[Optional[StateDelta]], None]) -> Any:
     """
     Edits any value to make it snapshottable on edit. Made as a separate function from `BaseState` to
     avoid namespace conflicts with subclasses.
@@ -84,9 +129,14 @@ def _make_snapshottable(value: Any, snapshot_callback: Callable[[], None]) -> An
 
     if isinstance(value, dict):
         snapshottable_dict = _SnapshottableDict(value)
-        snapshottable_dict._snapshot_callback = snapshot_callback
+        snapshottable_dict.__bind__(path, snapshot_callback)
         return snapshottable_dict
 
+    if isinstance(value, list):
+        snapshottable_list = _SnapshottableList(value)
+        snapshottable_list.__bind__(path, snapshot_callback)
+        return snapshottable_list
+
     return value
 
 
@@ -253,14 +303,14 @@ class StateMeta(UniversalBaseModel):
     node_outputs: Dict[OutputReference, Any] = field(default_factory=dict)
     node_execution_cache: NodeExecutionCache = field(default_factory=NodeExecutionCache)
     parent: Optional["BaseState"] = None
-    __snapshot_callback__: Optional[Callable[[], None]] = field(init=False, default=None)
+    __snapshot_callback__: Optional[Callable[[Optional[StateDelta]], None]] = field(init=False, default=None)
 
     def model_post_init(self, context: Any) -> None:
         self.__snapshot_callback__ = None
 
-    def add_snapshot_callback(self, callback: Callable[[], None]) -> None:
-        self.node_outputs = _make_snapshottable(self.node_outputs, callback)
-        self.external_inputs = _make_snapshottable(self.external_inputs, callback)
+    def add_snapshot_callback(self, callback: Callable[[Optional[StateDelta]], None]) -> None:
+        self.node_outputs = _make_snapshottable("meta.node_outputs", self.node_outputs, callback)
+        self.external_inputs = _make_snapshottable("meta.external_inputs", self.external_inputs, callback)
         self.__snapshot_callback__ = callback
 
     def __setattr__(self, name: str, value: Any) -> None:
@@ -270,7 +320,7 @@ class StateMeta(UniversalBaseModel):
 
         super().__setattr__(name, value)
         if callable(self.__snapshot_callback__):
-            self.__snapshot_callback__()
+            self.__snapshot_callback__(SetStateDelta(name=f"meta.{name}", delta=value))
 
     @field_serializer("workflow_definition")
     def serialize_workflow_definition(self, workflow_definition: Type["BaseWorkflow"], _info: Any) -> Dict[str, Any]:
@@ -428,11 +478,15 @@ class BaseState(metaclass=_BaseStateMeta):
 
     __lock__: Lock = field(init=False)
     __is_quiet__: bool = field(init=False)
-    __snapshot_callback__: Callable[["BaseState"], None] = field(init=False)
+    __is_atomic__: bool = field(init=False)
+    __snapshot_callback__: Callable[["BaseState", List[StateDelta]], None] = field(init=False)
+    __deltas__: List[StateDelta] = field(init=False)
 
     def __init__(self, meta: Optional[StateMeta] = None, **kwargs: Any) -> None:
         self.__is_quiet__ = True
-        self.__snapshot_callback__ = lambda state: None
+        self.__is_atomic__ = False
+        self.__snapshot_callback__ = lambda state, deltas: None
+        self.__deltas__ = []
         self.__lock__ = Lock()
 
         self.meta = meta or StateMeta()
@@ -442,7 +496,7 @@ class BaseState(metaclass=_BaseStateMeta):
         for name, value in self.__class__.__dict__.items():
             if not name.startswith("_") and name != "meta":
                 # Bypass __is_quiet__ instead of `setattr`
-                snapshottable_value = _make_snapshottable(value, self.__snapshot__)
+                snapshottable_value = _make_snapshottable(name, value, self.__snapshot__)
                 super().__setattr__(name, snapshottable_value)
 
         for name, value in kwargs.items():
@@ -494,15 +548,15 @@ class BaseState(metaclass=_BaseStateMeta):
     def __getitem__(self, key: str) -> Any:
         return self.__dict__[key]
 
-    def __setattr__(self, name: str, value: Any) -> None:
+    def __setattr__(self, name: str, delta: Any) -> None:
         if name.startswith("_"):
-            super().__setattr__(name, value)
+            super().__setattr__(name, delta)
             return
 
-        snapshottable_value = _make_snapshottable(value, self.__snapshot__)
+        snapshottable_value = _make_snapshottable(name, delta, self.__snapshot__)
         super().__setattr__(name, snapshottable_value)
         self.meta.updated_ts = datetime_now()
-        self.__snapshot__()
+        self.__snapshot__(SetStateDelta(name=name, delta=delta))
 
     def __add__(self, other: StateType) -> StateType:
         """
@@ -531,7 +585,7 @@ class BaseState(metaclass=_BaseStateMeta):
 
         return cast(StateType, latest_state)
 
-    def __snapshot__(self) -> None:
+    def __snapshot__(self, delta: Optional[StateDelta] = None) -> None:
         """
         Snapshots the current state to the workflow emitter. The invoked callback is overridden by the
         workflow runner.
@@ -539,11 +593,19 @@ class BaseState(metaclass=_BaseStateMeta):
         if self.__is_quiet__:
             return
 
+        if delta:
+            self.__deltas__.append(delta)
+
+        if self.__is_atomic__:
+            return
+
         try:
-            self.__snapshot_callback__(deepcopy(self))
+            self.__snapshot_callback__(deepcopy(self), self.__deltas__)
         except Exception:
             logger.exception("Failed to snapshot Workflow state.")
 
+        self.__deltas__.clear()
+
     @contextmanager
     def __quiet__(self):
         prev = self.__is_quiet__
@@ -555,12 +617,12 @@ class BaseState(metaclass=_BaseStateMeta):
 
     @contextmanager
     def __atomic__(self):
-        prev = self.__is_quiet__
-        self.__is_quiet__ = True
+        prev = self.__is_atomic__
+        self.__is_atomic__ = True
         try:
             yield
         finally:
-            self.__is_quiet__ = prev
+            self.__is_atomic__ = prev
             self.__snapshot__()
 
     @classmethod

vellum/workflows/state/delta.py

@@ -0,0 +1,20 @@
+from typing import Any, Literal, Union
+
+from vellum.core.pydantic_utilities import UniversalBaseModel
+
+
+class BaseStateDelta(UniversalBaseModel):
+    name: str
+
+
+class SetStateDelta(BaseStateDelta):
+    delta: Any
+    delta_type: Literal["SET_STATE"] = "SET_STATE"
+
+
+class AppendStateDelta(BaseStateDelta):
+    delta: Any
+    delta_type: Literal["APPEND_STATE"] = "APPEND_STATE"
+
+
+StateDelta = Union[SetStateDelta, AppendStateDelta]

vellum/workflows/state/tests/test_state.py

@@ -2,11 +2,12 @@ import pytest
 from copy import deepcopy
 import json
 from queue import Queue
-from typing import Dict, cast
+from typing import Dict, List, cast
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.state.delta import SetStateDelta, StateDelta
 from vellum.workflows.state.encoder import DefaultStateEncoder
 
 
@@ -28,7 +29,7 @@ class MockState(BaseState):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.__snapshot_callback__ = lambda _: self.__mock_snapshot__()
+        self.__snapshot_callback__ = lambda _, __: self.__mock_snapshot__()
 
     def __mock_snapshot__(self) -> None:
         self.__snapshot_count__ += 1
@@ -201,7 +202,7 @@ def test_state_snapshot__deepcopy_fails__logs_error(mock_deepcopy, mock_logger):
     # AND we have a snapshot callback that we are tracking
     snapshot_count = 0
 
-    def __snapshot_callback__(state: "BaseState") -> None:
+    def __snapshot_callback__(state: "BaseState", deltas: List[StateDelta]) -> None:
         nonlocal snapshot_count
         snapshot_count += 1
 
@@ -220,8 +221,8 @@ def test_state_snapshot__deepcopy_fails__logs_error(mock_deepcopy, mock_logger):
     mock_deepcopy.side_effect = side_effect
 
     # WHEN we snapshot the state twice
-    state.__snapshot__()
-    state.__snapshot__()
+    state.__snapshot__(SetStateDelta(name="foo", delta="bar"))
+    state.__snapshot__(SetStateDelta(name="foo", delta="baz"))
 
     # THEN we were able to invoke the callback once
     assert snapshot_count == 1

{vellum_ai-0.14.83.dist-info → vellum_ai-0.14.85.dist-info}/METADATA

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

{vellum_ai-0.14.83.dist-info → vellum_ai-0.14.85.dist-info}/RECORD

@@ -144,7 +144,7 @@ vellum/client/README.md,sha256=47bNYmRLSISR1ING58kXXZ88nFLPGFv0bAspBtuXG3g,4306
 vellum/client/__init__.py,sha256=tKLc-F8I8_62RSZg7J7Lvo1dUQ_or7DGsDhbMyhWfGA,120958
 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=gyJ24Al-cSBb6icVWcF_yAoQvYKVUbmtxfrRau6GtS8,1916
+vellum/client/core/client_wrapper.py,sha256=X9SbAOmZu48N8-Sgi-VoDoEM3tro2SNf1grdzvosVww,1916
 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=cKs2w0ybDBk1wHQf-fTALm_MmvaMe3cZKcYJxqmCxkE,19539
@@ -1595,7 +1595,7 @@ vellum/workflows/nodes/core/__init__.py,sha256=5zDMCmyt1v0HTJzlUBwq3U9L825yZGZhT
 vellum/workflows/nodes/core/error_node/__init__.py,sha256=g7RRnlHhqu4qByfLjBwCunmgGA8dI5gNsjS3h6TwlSI,60
 vellum/workflows/nodes/core/error_node/node.py,sha256=MFHU5vITYSK-L9CuMZ49In2ZeNLWnhZD0f8r5dWvb5Y,1270
 vellum/workflows/nodes/core/inline_subworkflow_node/__init__.py,sha256=nKNEH1QTl-1PcvmYoqSWEl0-t6gAur8GLTXHzklRQfM,84
-vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=rgcjc3gaCEX9uSfkLSErHjSnNQEeqREVZk-7TEr9hUo,6595
+vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=TCmO0wPbt7kc89K1iGqeeoZy-yn1z0iioYSSN6mErdY,6997
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=kUqwcRMMxjTHALbwGUXCJT_aJBrHS1bkg49oL8R0JO8,4337
 vellum/workflows/nodes/core/map_node/__init__.py,sha256=MXpZYmGfhsMJHqqlpd64WiJRtbAtAMQz-_3fCU_cLV0,56
@@ -1679,9 +1679,9 @@ vellum/workflows/nodes/displayable/tests/test_search_node_error_handling.py,sha2
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
 vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py,sha256=dc3EEn1sOICpr3GdS8eyeFtExaGwWWcw9eHSdkRhQJU,2584
 vellum/workflows/nodes/displayable/tool_calling_node/__init__.py,sha256=3n0-ysmFKsr40CVxPthc0rfJgqVJeZuUEsCmYudLVRg,117
-vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=PPu8JPDHUAHU95d73WDwq75sfsUH-I47BdnOuZXkIm8,4976
+vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=7MqEtw-RejpJ5Uer11tIFKRtklC4DfiWVx2-tpnA1Gg,6310
 vellum/workflows/nodes/displayable/tool_calling_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=X9kl8qntn0cQOOvyn0noDayhU0hXenqYJ0XO1FkOjAs,5071
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=ZWxicmEpBUAIudqUcKi1Li1f-Z2thYq8xI_Kf6YstMg,5077
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=eu6WTyENhGLg9pGp_j69rysZjf_qiQXske1YdZn9PzU,1718
 vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=f2hCLciTqjHXj9tVdnnTAVY0BLUCMBoH0emQeOJCB7I,11309
 vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrraiBHDLKTlnBa51ZiE,284
@@ -1689,6 +1689,7 @@ vellum/workflows/nodes/experimental/__init__.py,sha256=k7VQEyvgEdnrEZ-icXx3fiByP
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
 vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=cKI2Ls25L-JVt4z4a2ozQa-YBeVy21Z7BQ32Sj7iBPE,10460
 vellum/workflows/nodes/experimental/tool_calling_node/__init__.py,sha256=8R5HQtDDfo0hgFX6VdM45-FiyxK-IMTI9B9LL4TRUbw,112
+vellum/workflows/nodes/experimental/tool_calling_node/node.py,sha256=8R5HQtDDfo0hgFX6VdM45-FiyxK-IMTI9B9LL4TRUbw,112
 vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWlyc,10455
 vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
@@ -1716,15 +1717,16 @@ 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=U25YA1_vBgTDhOAxoVCRcNyFX2P5EraN7Mdsr4MX8p0,35031
+vellum/workflows/runner/runner.py,sha256=t9Y3k82YjeML-Z7f1W2sj_1nAjJEpsnJUComDBebagU,36339
 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=WIMJYyuHUrP4zt0Nudk66HAK1L6GgGmsU_GQp7BGE2U,22189
+vellum/workflows/state/base.py,sha256=F53r9n1tnipe6a7BmI4qcqgBRDkYzuEsN_mb-65Dazw,24276
 vellum/workflows/state/context.py,sha256=KOAI1wEGn8dGmhmAemJaf4SZbitP3jpIBcwKfznQaRE,3076
+vellum/workflows/state/delta.py,sha256=7p0jJ3wquaFPGktZZz1vLM1ydv4CI7kuYumIaNbiSF4,433
 vellum/workflows/state/encoder.py,sha256=sV80h-lAo66isD2ezK1_YLzj75Aa5dAtF2YA1c3BYKo,2883
 vellum/workflows/state/store.py,sha256=uVe-oN73KwGV6M6YLhwZMMUQhzTQomsVfVnb8V91gVo,1147
 vellum/workflows/state/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/state/tests/test_state.py,sha256=YOiC9qZAzkdiqb7nRarNWeDwxo7xHv3y3czlHl81ezg,6741
+vellum/workflows/state/tests/test_state.py,sha256=SjQZgovETrosPUeFohaPB9egAkSVe8ptJO5O4Fk2E04,6920
 vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVik6ZVTfVOA,1826
 vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83yc5FIM33zuo8,353
@@ -1756,8 +1758,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.83.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.83.dist-info/METADATA,sha256=TcabDwnkXTXEjJKHPtTdkNTgXrKrCA3L5_o-7KPgJkU,5556
-vellum_ai-0.14.83.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.83.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.83.dist-info/RECORD,,
+vellum_ai-0.14.85.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.85.dist-info/METADATA,sha256=YJsUjCnTdDuvxb-FOhV6litvxWf_owaPkWBUv8RXjq4,5556
+vellum_ai-0.14.85.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.85.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.85.dist-info/RECORD,,