vellum-ai 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.7.2",
+            "User-Agent": "vellum-ai/1.7.4",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.2",
+            "X-Fern-SDK-Version": "1.7.4",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/client/core/pydantic_utilities.py

@@ -158,7 +158,14 @@ class UniversalBaseModel(pydantic.BaseModel):
 
             dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
 
-        return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
+        # Skip expensive annotation metadata conversion for types that don't require it.
+        # This optimization dramatically improves serialization performance for large nested
+        # structures by avoiding repeated typing.get_origin checks on every element.
+        if self.__class__.__name__ in annotated_types:
+            return convert_and_respect_annotation_metadata(
+                object_=dict_dump, annotation=self.__class__, direction="write"
+            )
+        return dict_dump
 
 
 def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:

vellum/plugins/pydantic.py

@@ -48,6 +48,7 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
         from_attributes: Optional[bool] = None,
         context: Optional[Dict[str, Any]] = None,
         self_instance: Optional[Any] = None,
+        extra: Optional[Literal["allow", "ignore", "forbid"]] = None,
         allow_partial: Union[bool, Literal["off", "on", "trailing-strings"]] = False,
         by_alias: Optional[bool] = None,
         by_name: Optional[bool] = None,

vellum/workflows/errors/types.py

@@ -33,6 +33,7 @@ class WorkflowError:
     message: str
     code: WorkflowErrorCode
     raw_data: Optional[Dict[str, Any]] = None
+    stacktrace: Optional[str] = None
 
     def __contains__(self, item: Any) -> bool:
         return item in self.message
@@ -43,6 +44,7 @@ _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErr
     "INVALID_INPUTS": WorkflowErrorCode.INVALID_INPUTS,
     "PROVIDER_ERROR": WorkflowErrorCode.PROVIDER_ERROR,
     "PROVIDER_CREDENTIALS_UNAVAILABLE": WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+    "INTEGRATION_CREDENTIALS_UNAVAILABLE": WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE,
     "REQUEST_TIMEOUT": WorkflowErrorCode.PROVIDER_ERROR,
     "INTERNAL_SERVER_ERROR": WorkflowErrorCode.INTERNAL_ERROR,
     "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,
@@ -81,6 +83,8 @@ def workflow_event_error_to_workflow_error(error: WorkflowEventError) -> Workflo
     return WorkflowError(
         message=error.message,
         code=_WORKFLOW_EVENT_ERROR_CODE_TO_WORKFLOW_ERROR_CODE.get(error.code, WorkflowErrorCode.INTERNAL_ERROR),
+        raw_data=error.raw_data,
+        stacktrace=error.stacktrace,
     )
 
 
@@ -95,7 +99,7 @@ _WORKFLOW_ERROR_CODE_TO_VELLUM_ERROR_CODE: Dict[WorkflowErrorCode, VellumErrorCo
     WorkflowErrorCode.NODE_EXECUTION: "USER_DEFINED_ERROR",
     WorkflowErrorCode.PROVIDER_ERROR: "PROVIDER_ERROR",
     WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE: "PROVIDER_CREDENTIALS_UNAVAILABLE",
-    WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE: "PROVIDER_CREDENTIALS_UNAVAILABLE",
+    WorkflowErrorCode.INTEGRATION_CREDENTIALS_UNAVAILABLE: "INTEGRATION_CREDENTIALS_UNAVAILABLE",
     WorkflowErrorCode.USER_DEFINED_ERROR: "USER_DEFINED_ERROR",
     WorkflowErrorCode.WORKFLOW_CANCELLED: "REQUEST_TIMEOUT",
 }

vellum/workflows/events/tests/test_event.py

@@ -263,6 +263,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                         "message": "Workflow failed",
                         "code": "USER_DEFINED_ERROR",
                         "raw_data": None,
+                        "stacktrace": None,
                     },
                     "stacktrace": None,
                 },

vellum/workflows/exceptions.py

@@ -25,10 +25,12 @@ class NodeException(Exception):
         message: str,
         code: WorkflowErrorCode = WorkflowErrorCode.INTERNAL_ERROR,
         raw_data: Optional[Dict[str, Any]] = None,
+        stacktrace: Optional[str] = None,
     ):
         self.message = message
         self.code = code
         self.raw_data = raw_data
+        self.stacktrace = stacktrace
         super().__init__(message)
 
     @property
@@ -37,11 +39,17 @@ class NodeException(Exception):
             message=self.message,
             code=self.code,
             raw_data=self.raw_data,
+            stacktrace=self.stacktrace,
         )
 
     @staticmethod
     def of(workflow_error: WorkflowError) -> "NodeException":
-        return NodeException(message=workflow_error.message, code=workflow_error.code, raw_data=workflow_error.raw_data)
+        return NodeException(
+            message=workflow_error.message,
+            code=workflow_error.code,
+            raw_data=workflow_error.raw_data,
+            stacktrace=workflow_error.stacktrace,
+        )
 
 
 class WorkflowInitializationException(Exception):

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

@@ -21,7 +21,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
 from vellum.workflows.events.types import default_serializer
 from vellum.workflows.events.workflow import is_workflow_event
-from vellum.workflows.exceptions import NodeException
+from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
@@ -164,6 +164,16 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                 node_output_mocks=self._context._get_all_node_output_mocks(),
             )
 
+        try:
+            next(subworkflow_stream)
+        except WorkflowInitializationException as e:
+            hashed_module = e.definition.__module__
+            raise NodeException(
+                message=e.message,
+                code=e.code,
+                raw_data={"hashed_module": hashed_module},
+            ) from e
+
         outputs = None
         exception = None
         fulfilled_output_names: Set[str] = set()

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

@@ -24,6 +24,7 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_tool_prompt_node,
 )
 from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.ports.utils import validate_ports
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.definition import DeploymentDefinition
@@ -38,6 +39,55 @@ def second_function() -> str:
     return "second_function"
 
 
+def test_router_node_port_ordering_with_multiple_tools():
+    """
+    Test that router node ports are created in the correct order: on_if, on_elif, ..., on_else.
+
+    This test validates the fix for the bug where multiple tools would create multiple on_if
+    ports instead of on_if followed by on_elif ports, which violates port validation rules.
+    """
+
+    # GIVEN three functions to ensure we test multiple elif cases
+    def third_function() -> str:
+        return "third_function"
+
+    # AND a tool prompt node
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="test-model",
+        blocks=[],
+        functions=[first_function, second_function, third_function],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+    )
+
+    # WHEN a router node is created with multiple functions
+    router_node = create_router_node(
+        functions=[first_function, second_function, third_function],
+        tool_prompt_node=tool_prompt_node,
+    )
+
+    # THEN the first function port should be an on_if port
+    first_function_port = getattr(router_node.Ports, "first_function")
+    assert first_function_port._condition_type.value == "IF"
+
+    # AND the second function port should be an on_elif port
+    second_function_port = getattr(router_node.Ports, "second_function")
+    assert second_function_port._condition_type.value == "ELIF"
+
+    # AND the third function port should also be an on_elif port
+    third_function_port = getattr(router_node.Ports, "third_function")
+    assert third_function_port._condition_type.value == "ELIF"
+
+    # AND the default port should be an on_else port
+    default_port = getattr(router_node.Ports, "default")
+    assert default_port._condition_type.value == "ELSE"
+
+    # AND the ports should pass validation
+    ports = [first_function_port, second_function_port, third_function_port, default_port]
+    # This should not raise an exception
+    validate_ports(ports)
+
+
 def test_port_condition_match_function_name():
     """
     Test that the port condition correctly matches the function name.

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

@@ -409,8 +409,8 @@ def create_router_node(
         # Avoid using lambda to capture function_name
         # lambda will capture the function_name by reference,
         # and if the function_name is changed, the port_condition will also change.
-        def create_port_condition(fn_name):
-            return Port.on_if(
+        def create_port_condition(fn_name, is_first):
+            condition = (
                 ToolCallingState.current_prompt_output_index.less_than(tool_prompt_node.Outputs.results.length())
                 & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
                     "FUNCTION_CALL"
@@ -419,26 +419,33 @@ def create_router_node(
                     "name"
                 ].equals(fn_name)
             )
+            # First port should be on_if, subsequent ports should be on_elif
+            return Port.on_if(condition) if is_first else Port.on_elif(condition)
 
+        is_first_port = True
         for function in functions:
             if isinstance(function, ComposioToolDefinition):
                 function_name = get_function_name(function)
-                port = create_port_condition(function_name)
+                port = create_port_condition(function_name, is_first_port)
                 setattr(Ports, function_name, port)
+                is_first_port = False
             elif isinstance(function, VellumIntegrationToolDefinition):
                 function_name = get_function_name(function)
-                port = create_port_condition(function_name)
+                port = create_port_condition(function_name, is_first_port)
                 setattr(Ports, function_name, port)
+                is_first_port = False
             elif isinstance(function, MCPServer):
                 tool_functions: List[MCPToolDefinition] = compile_mcp_tool_definition(function)
                 for tool_function in tool_functions:
                     name = get_mcp_tool_name(tool_function)
-                    port = create_port_condition(name)
+                    port = create_port_condition(name, is_first_port)
                     setattr(Ports, name, port)
+                    is_first_port = False
             else:
                 function_name = get_function_name(function)
-                port = create_port_condition(function_name)
+                port = create_port_condition(function_name, is_first_port)
                 setattr(Ports, function_name, port)
+                is_first_port = False
 
         # Add the else port for when no function conditions match
         setattr(Ports, "default", Port.on_else())

vellum/workflows/resolvers/resolver.py

@@ -52,15 +52,6 @@ class VellumResolver(BaseWorkflowResolver):
         if response.state is None:
             return None
 
-        if (
-            response.previous_trace_id is None
-            or response.root_trace_id is None
-            or response.previous_span_id is None
-            or response.root_span_id is None
-        ):
-            logger.warning("Could not find required execution events for state loading")
-            return None
-
         if "meta" in response.state:
             response.state.pop("meta")
 
@@ -71,6 +62,20 @@ class VellumResolver(BaseWorkflowResolver):
             logger.warning("No workflow class registered, falling back to BaseState")
             state = BaseState(**response.state)
 
+        if (
+            response.previous_trace_id is None
+            or response.root_trace_id is None
+            or response.previous_span_id is None
+            or response.root_span_id is None
+        ):
+            return LoadStateResult(
+                state=state,
+                previous_trace_id=response.trace_id,
+                previous_span_id=response.span_id,
+                root_trace_id=response.trace_id,
+                root_span_id=response.span_id,
+            )
+
         return LoadStateResult(
             state=state,
             previous_trace_id=response.previous_trace_id,

vellum/workflows/runner/runner.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from contextlib import contextmanager
 from copy import deepcopy
 from dataclasses import dataclass
 import logging
@@ -232,7 +233,33 @@ class WorkflowRunner(Generic[StateType]):
 
         self._background_thread: Optional[Thread] = None
         self._cancel_thread: Optional[Thread] = None
-        self._stream_thread: Optional[Thread] = None
+
+    @contextmanager
+    def _httpx_logger_with_span_id(self) -> Iterator[None]:
+        """
+        Context manager to append the current execution's span ID to httpx logger messages.
+
+        This is used when making API requests via the Vellum client to include
+        the execution's span ID in the httpx request logs for better traceability.
+        """
+        httpx_logger = logging.getLogger("httpx")
+
+        class SpanIdFilter(logging.Filter):
+            def filter(self, record: logging.LogRecord) -> bool:
+                if record.name == "httpx" and "[span_id=" not in record.msg:
+                    context = get_execution_context()
+                    if context.parent_context:
+                        span_id = str(context.parent_context.span_id)
+                        record.msg = f"{record.msg} [span_id={span_id}]"
+                return True
+
+        span_filter = SpanIdFilter()
+        httpx_logger.addFilter(span_filter)
+
+        try:
+            yield
+        finally:
+            httpx_logger.removeFilter(span_filter)
 
     def _snapshot_state(self, state: StateType, deltas: List[StateDelta]) -> StateType:
         self._workflow_event_inner_queue.put(
@@ -695,6 +722,36 @@ class WorkflowRunner(Generic[StateType]):
 
         return None
 
+    def _emit_node_cancellation_events(
+        self,
+        error_message: str,
+        parent_context: Optional[ParentContext],
+    ) -> None:
+        """
+        Emit node cancellation events for all active nodes.
+
+        Args:
+            error_message: The error message to include in the cancellation events
+            parent_context: The parent context for the cancellation events
+        """
+        captured_stacktrace = "".join(traceback.format_stack())
+        for span_id, active_node in list(self._active_nodes_by_execution_id.items()):
+            rejection_event = NodeExecutionRejectedEvent(
+                trace_id=self._execution_context.trace_id,
+                span_id=span_id,
+                body=NodeExecutionRejectedBody(
+                    node_definition=active_node.node.__class__,
+                    error=WorkflowError(
+                        code=WorkflowErrorCode.NODE_CANCELLED,
+                        message=error_message,
+                    ),
+                    stacktrace=captured_stacktrace,
+                ),
+                parent=parent_context,
+            )
+            self._workflow_event_outer_queue.put(rejection_event)
+            self._active_nodes_by_execution_id.pop(span_id)
+
     def _initiate_workflow_event(self) -> WorkflowExecutionInitiatedEvent:
         links: Optional[List[SpanLink]] = None
 
@@ -796,6 +853,11 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._execution_context.parent_context,
         )
 
+    def _wrapped_stream(self) -> None:
+        """Wrapper for _stream that adds httpx logger span ID context."""
+        with self._httpx_logger_with_span_id():
+            self._stream()
+
     def _stream(self) -> None:
         for edge in self.workflow.get_edges():
             self._dependencies[edge.to_node].add(edge.from_port.node_class)
@@ -848,21 +910,10 @@ class WorkflowRunner(Generic[StateType]):
 
             if rejection_event:
                 failed_node_name = rejection_event.body.node_definition.__name__
-                for active_span_id, active_node_data in list(self._active_nodes_by_execution_id.items()):
-                    cancellation_event = NodeExecutionRejectedEvent(
-                        trace_id=self._execution_context.trace_id,
-                        span_id=active_span_id,
-                        body=NodeExecutionRejectedBody(
-                            node_definition=active_node_data.node.__class__,
-                            error=WorkflowError(
-                                message=f"Node execution cancelled due to {failed_node_name} failure",
-                                code=WorkflowErrorCode.NODE_CANCELLED,
-                            ),
-                        ),
-                        parent=self._execution_context.parent_context,
-                    )
-                    self._workflow_event_outer_queue.put(cancellation_event)
-                    self._active_nodes_by_execution_id.pop(active_span_id)
+                self._emit_node_cancellation_events(
+                    error_message=f"Node execution cancelled due to {failed_node_name} failure",
+                    parent_context=self._execution_context.parent_context,
+                )
                 break
 
         # Handle any remaining events
@@ -932,12 +983,25 @@ class WorkflowRunner(Generic[StateType]):
 
         while not kill_switch.wait(timeout=0.1):
             if self._cancel_signal.is_set():
+                parent_context = WorkflowParentContext(
+                    span_id=self._initial_state.meta.span_id,
+                    workflow_definition=self.workflow.__class__,
+                    parent=self._execution_context.parent_context,
+                )
+
+                self._emit_node_cancellation_events(
+                    error_message="Workflow run cancelled",
+                    parent_context=parent_context,
+                )
+
+                captured_stacktrace = "".join(traceback.format_stack())
                 self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
                         WorkflowError(
                             code=WorkflowErrorCode.WORKFLOW_CANCELLED,
                             message="Workflow run cancelled",
-                        )
+                        ),
+                        captured_stacktrace,
                     )
                 )
                 return
@@ -977,7 +1041,7 @@ class WorkflowRunner(Generic[StateType]):
 
         # The extra level of indirection prevents the runner from waiting on the caller to consume the event stream
         self._stream_thread = Thread(
-            target=self._stream,
+            target=self._wrapped_stream,
             name=f"{self.workflow.__class__.__name__}.stream_thread",
         )
         self._stream_thread.start()

vellum/workflows/types/__init__.py

@@ -1,5 +1,6 @@
-from .core import MergeBehavior
+from .core import CancelSignal, MergeBehavior
 
 __all__ = [
+    "CancelSignal",
     "MergeBehavior",
 ]

vellum/workflows/types/core.py

@@ -1,4 +1,6 @@
 from enum import Enum
+from multiprocessing.synchronize import Event as MultiprocessingEvent
+from threading import Event as ThreadingEvent
 from typing import (  # type: ignore[attr-defined]
     Any,
     Dict,
@@ -15,6 +17,8 @@ JsonArray = List["Json"]
 JsonObject = Dict[str, "Json"]
 Json = Union[None, bool, int, float, str, JsonArray, JsonObject]
 
+CancelSignal = Union[ThreadingEvent, MultiprocessingEvent]
+
 # Unions and Generics inherit from `_GenericAlias` instead of `type`
 # In future versions of python, we'll see `_UnionGenericAlias`
 UnderGenericAlias = _GenericAlias

{vellum_ai-1.7.2.dist-info → vellum_ai-1.7.4.dist-info}/METADATA

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

{vellum_ai-1.7.2.dist-info → vellum_ai-1.7.4.dist-info}/RECORD

@@ -160,14 +160,14 @@ vellum/client/README.md,sha256=flqu57ubZNTfpq60CdLtJC9gp4WEkyjb_n_eZ4OYf9w,6497
 vellum/client/__init__.py,sha256=rMnKRqL5-356SBc-rfm56MkO87PuAi2mtcfBszcJU1M,74316
 vellum/client/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 vellum/client/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-vellum/client/core/client_wrapper.py,sha256=4Sfjvux7hceG2zs5IHHn9McKc2YE_WIb9ctx_HfCyzA,2840
+vellum/client/core/client_wrapper.py,sha256=l3m9Q8u_-eKF93ekwPZtf7Z2S1yy8YrttUS-JF-zwc8,2840
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/force_multipart.py,sha256=awxh5MtcRYe74ehY8U76jzv6fYM_w_D3Rur7KQQzSDk,429
 vellum/client/core/http_client.py,sha256=QurkBvCZZz2Z1d8znp4M2YbOXebBUPcPXRhPIS84Wvk,21214
 vellum/client/core/http_response.py,sha256=4uOAtXXFTyFXHLXeQWSfQST9PGcOCRAdHVgGTxdyg84,1334
 vellum/client/core/jsonable_encoder.py,sha256=hGgcEEeX11sqxxsll7h15pO3pTNVxk_n79Kcn0laoWA,3655
-vellum/client/core/pydantic_utilities.py,sha256=8evivb_gxrY5VwrEgid4u-HnSmVtkAO5y-B65qYcACU,11403
+vellum/client/core/pydantic_utilities.py,sha256=y9CLy3XanCrFf-pJL11IieMQ9ntPIJG45xnFjTLfVUs,11784
 vellum/client/core/query_encoder.py,sha256=ekulqNd0j8TgD7ox-Qbz7liqX8-KP9blvT9DsRCenYM,2144
 vellum/client/core/remove_none_from_dict.py,sha256=EU9SGgYidWq7SexuJbNs4-PZ-5Bl3Vppd864mS6vQZw,342
 vellum/client/core/request_options.py,sha256=h0QUNCFVdCW_7GclVySCAY2w4NhtXVBUCmHgmzaxpcg,1681
@@ -988,7 +988,7 @@ vellum/evaluations/utils/env.py,sha256=Xj_nxsoU5ox06EOTjRopR4lrigQI6Le6qbWGltYoE
 vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3qOsoOJUxfg,49
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/plugins/pydantic.py,sha256=SamPlRZ8V9kuxEfMkOPKjhMMLa5Q3wYJ3Z-F_IfKtvA,3911
+vellum/plugins/pydantic.py,sha256=-AV02TCdI3Uk4cgB2jO-YhQcRqvylb3g-h1ytKaRwvg,3981
 vellum/plugins/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/tests/test_pydantic.py,sha256=S6bLqs3Y5DGA012QV_7f6hk4e6Bz-iJ9py9DEKuo4fM,746
 vellum/plugins/utils.py,sha256=cPmxE9R2CK1bki2jKE8rB-G9zMf2pzHjSPDHFPXwd3Q,878
@@ -1804,7 +1804,7 @@ vellum/workflows/emitters/vellum_emitter.py,sha256=t4ixrN0NNXrydMP9PVKYvcOMxoMqs
 vellum/workflows/environment/__init__.py,sha256=TJz0m9dwIs6YOwCTeuN0HHsU-ecyjc1OJXx4AFy83EQ,121
 vellum/workflows/environment/environment.py,sha256=Ck3RPKXJvtMGx_toqYQQQF-ZwXm5ijVwJpEPTeIJ4_Q,471
 vellum/workflows/errors/__init__.py,sha256=tWGPu5xyAU8gRb8_bl0fL7OfU3wxQ9UH6qVwy4X4P_Q,113
-vellum/workflows/errors/types.py,sha256=dmIYCJl2OdQnU5CW_fgKcQy7tERAeddLQ1FSp7gIKeA,4541
+vellum/workflows/errors/types.py,sha256=N43BsnhnYZvuPql-Xu86Y6QQ07BxKv5ypD2lq4eugpk,4749
 vellum/workflows/events/__init__.py,sha256=V4mh766fyA70WvHelm9kfVZGrUgEKcJ9tJt8EepfQYU,832
 vellum/workflows/events/context.py,sha256=vCfMIPmz4j9Om36rRWa35A_JU_VccWWS52_mZkkqxak,3345
 vellum/workflows/events/exception_handling.py,sha256=2okFtCzrOzaCP-HEwBPMvHn-evlyyE1zRkmIYjR__jQ,1975
@@ -1813,10 +1813,10 @@ vellum/workflows/events/relational_threads.py,sha256=zmLrBCBYpdpQV0snKH3HleST-_h
 vellum/workflows/events/stream.py,sha256=xhXJTZirFi0xad5neAQNogrIQ4h47fpnKbVC3vCM5Js,889
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/events/tests/test_basic_workflow.py,sha256=Pj6orHsXz37jWC5FARi0Sx2Gjf99Owri2Cvr6Chb79k,1765
-vellum/workflows/events/tests/test_event.py,sha256=jsC8APdrddLs5ejk9NO0waPLLslsJlBMIvN0M_vpAHI,19692
+vellum/workflows/events/tests/test_event.py,sha256=rwbS8W1wriN6EDt_NlFA1HgSAqgBbEyCU63gfjCowrM,19736
 vellum/workflows/events/types.py,sha256=mVrqAH9Hs9SpXm08Hcxdyap_ImQPwGsxRr56rSNMP34,5043
 vellum/workflows/events/workflow.py,sha256=kLSWFXiDZH0TELWoDjQ_kHVomFnw8MVVUPDGIzgyosw,8997
-vellum/workflows/exceptions.py,sha256=nb05hAh-afzZ9hek7vhegq-zDtmHopv-4No3aZ-gKO4,1941
+vellum/workflows/exceptions.py,sha256=cizNaHgmGdIoYSV3Mn6_HlpUvs2Nq9KgpX1ewMZdBa0,2157
 vellum/workflows/executable.py,sha256=um-gLJMVYfGJwGJfZIPlCRHhHIYm6pn8PUEfeqrNx5k,218
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/accessor.py,sha256=3lu1-_-dBfZdJvtX-q66jbmRAZtqIfdsh_3_JNuzg1E,4462
@@ -1966,7 +1966,7 @@ vellum/workflows/nodes/displayable/search_node/node.py,sha256=1dGCB1kb7MvX3fUJ5z
 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=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=ZBGOuzAEeMFR7zhIOtXc3Vvv8I4TKZaCFzm_narFc18,13803
+vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=SZIdk7aBmKKFgPYsxZaHIjT6p5W9HBYT1lj5yE4oax8,14169
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py,sha256=c98nMPogZ6iN_pTvVUMTB3J72Hj--H-XVgvvRXhdSQE,19085
 vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1979,9 +1979,9 @@ vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=pwK9q1blgRv9
 vellum/workflows/nodes/displayable/tool_calling_node/state.py,sha256=CcBVb_YtwfSSka4ze678k6-qwmzMSfjfVP8_Y95feSo,302
 vellum/workflows/nodes/displayable/tool_calling_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_composio_service.py,sha256=in1fbEz5x1tx3uKv9YXdvOncsHucNL8Ro6Go7lBuuOQ,8962
-vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=GZoeybB9uM7ai8sBLAtUMHrMVgh-WrJDWrKZci6feDs,11892
+vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py,sha256=Idjtlly6GTotNa4isXJ23RxKzQA2oE10MOm793aipLA,13892
 vellum/workflows/nodes/displayable/tool_calling_node/tests/test_utils.py,sha256=EmKFA-ELdTzlK0xMqWnuSZPoGNLYCwk6b0amTqirZo0,11305
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=NDp2rEU-1QACxrSplocDKlPzILczzvPygkUOrysjU7Y,24109
+vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=yIo7xwI43M8wQO8UN4uYxWBWafgcC9e8Ucsp6PZDva4,24518
 vellum/workflows/nodes/displayable/web_search_node/__init__.py,sha256=8FOnEP-n-U68cvxTlJW9wphIAGHq5aqjzLM-DoSSXnU,61
 vellum/workflows/nodes/displayable/web_search_node/node.py,sha256=NQYux2bOtuBF5E4tn-fXi5y3btURPRrNqMSM9MAZYI4,5091
 vellum/workflows/nodes/displayable/web_search_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -2017,11 +2017,11 @@ vellum/workflows/references/vellum_secret.py,sha256=Od4d19a5yletWMqNfJR5d_mZQUkV
 vellum/workflows/references/workflow_input.py,sha256=W3rOK1EPd2gYHb04WJwmNm1CUSdvZ9LKrs8RMKxACBs,1751
 vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPycOQevJxQnI,82
 vellum/workflows/resolvers/base.py,sha256=wrQiSC02Bw4-dBwgFjJIHsjpe-4xz4rUJs_1RdErKA0,1164
-vellum/workflows/resolvers/resolver.py,sha256=EIIiA2OlaVUPiKiSh6egQZxPA6ny1GDMdPq1AuN-mV8,2961
+vellum/workflows/resolvers/resolver.py,sha256=3uEYscB_2PHTazc0Y9SzOe_yiQZhVLfey19hU1HzBaU,3127
 vellum/workflows/resolvers/tests/test_resolver.py,sha256=PnUGzsulo1It_LjjhHsRNiILvvl5G_IaK8ZX56zKC28,6204
 vellum/workflows/resolvers/types.py,sha256=Hndhlk69g6EKLh_LYg5ILepW5U_h_BYNllfzhS9k8p4,237
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=rwMZlQBkzK-EfewC6OysNCeuDeTCfpNuzaUlgYoFJMw,43329
+vellum/workflows/runner/runner.py,sha256=pmqz7zP_YYv7e4kU2WviqHo37SETNyp1FWPscmob8v4,45666
 vellum/workflows/sandbox.py,sha256=mezSZmilR_fwR8164n8CEfzlMeQ55IqfapHp4ftImvQ,3212
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=A8s0PC8UvFjPpkHDY6u-yIeb2KHjoAmu-GW-GYrDl0E,24654
@@ -2035,9 +2035,9 @@ vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 vellum/workflows/tests/test_dataset_row.py,sha256=S8aIiYU9TRzJ8GTl5qCjnJ-fuHdxatHJFGLlKTVHPr4,4174
 vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVik6ZVTfVOA,1826
 vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83yc5FIM33zuo8,353
-vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
+vellum/workflows/types/__init__.py,sha256=fZ3Xxly7YSsu4kCIYD5aYpYucNM97zTyInb9CA24mf0,102
 vellum/workflows/types/code_execution_node_wrappers.py,sha256=fewX9bqF_4TZuK-gZYIn12s31-k03vHMGRpvFAPm11Y,3206
-vellum/workflows/types/core.py,sha256=X8xNBLUhnea97t3qeeZJ2XyUwW_a38YiznXr73j_ppE,950
+vellum/workflows/types/core.py,sha256=R7snCd7ci4tiRuHi5ALGh_5DIIF0T9eze3sf6EnJN-c,1126
 vellum/workflows/types/definition.py,sha256=Qof2MAjSNB0AN2XkSKmk-owuY59YcxDVHYpno6-StPA,8058
 vellum/workflows/types/generics.py,sha256=8jptbEx1fnJV0Lhj0MpCJOT6yNiEWeTOYOwrEAb5CRU,1576
 vellum/workflows/types/stack.py,sha256=h7NE0vXR7l9DevFBIzIAk1Zh59K-kECQtDTKOUunwMY,1314
@@ -2065,8 +2065,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=Boa-_m9ii2Qsa1RvVM-VYniF7zCpzGgEGy-OnPZkrHg,23941
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.7.2.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.7.2.dist-info/METADATA,sha256=KyFKrTqcT-6Pvl5zTeo1EsEP0-uY4WREJPAr8Vdkh4A,5547
-vellum_ai-1.7.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.7.2.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
-vellum_ai-1.7.2.dist-info/RECORD,,
+vellum_ai-1.7.4.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.7.4.dist-info/METADATA,sha256=sc8YEMq91hq8swhNrwAMqtp-WdoC201YZ6iOf36PxI4,5547
+vellum_ai-1.7.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.7.4.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
+vellum_ai-1.7.4.dist-info/RECORD,,