vellum-ai 0.14.71__py3-none-any.whl → 0.14.72__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.71",
+            "X-Fern-SDK-Version": "0.14.72",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/plugins/vellum_mypy.py

@@ -573,7 +573,7 @@ class VellumMypyPlugin(Plugin):
         alias_target = alias.target
         if (
             not isinstance(alias_target, Instance)
-            or not _is_subclass(alias_target.type, "typing.Iterator")
+            or not _is_subclass(alias_target.type, "vellum.workflows.events.stream.WorkflowEventGenerator")
             or not alias_target.args
         ):
             return ctx.default_return_type

vellum/workflows/events/__init__.py

@@ -5,6 +5,7 @@ from .node import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
 )
+from .stream import WorkflowEventGenerator
 from .workflow import (
     WorkflowEvent,
     WorkflowEventStream,
@@ -26,4 +27,5 @@ __all__ = [
     "WorkflowExecutionStreamingEvent",
     "WorkflowEvent",
     "WorkflowEventStream",
+    "WorkflowEventGenerator",
 ]

vellum/workflows/events/stream.py

@@ -0,0 +1,28 @@
+from uuid import UUID
+from typing import Generator, Generic, Iterator, TypeVar
+
+EventType = TypeVar("EventType")
+
+
+class WorkflowEventGenerator(Generic[EventType]):
+    """
+    Generic wrapper for event streams that exposes span_id as a top-level property
+    while maintaining iterator compatibility.
+    """
+
+    def __init__(self, event_generator: Generator[EventType, None, None], span_id: UUID):
+        self._event_generator = event_generator
+        self._span_id = span_id
+
+    @property
+    def span_id(self) -> UUID:
+        """The span_id associated with this workflow stream."""
+        return self._span_id
+
+    def __iter__(self) -> Iterator[EventType]:
+        """Return self to make this object iterable."""
+        return self
+
+    def __next__(self) -> EventType:
+        """Get the next event from the underlying generator."""
+        return next(self._event_generator)

vellum/workflows/events/workflow.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Literal, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Literal, Optional, Type, Union
 from typing_extensions import TypeGuard
 
 from pydantic import field_serializer
@@ -19,6 +19,7 @@ from .node import (
     NodeExecutionResumedEvent,
     NodeExecutionStreamingEvent,
 )
+from .stream import WorkflowEventGenerator
 from .types import BaseEvent, default_serializer
 
 if TYPE_CHECKING:
@@ -193,7 +194,7 @@ WorkflowEvent = Union[
     WorkflowExecutionSnapshottedEvent,
 ]
 
-WorkflowEventStream = Generator[WorkflowEvent, None, None]
+WorkflowEventStream = WorkflowEventGenerator[WorkflowEvent]
 
 WorkflowExecutionEvent = Union[
     WorkflowExecutionInitiatedEvent,

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

@@ -110,7 +110,7 @@ class ToolCallingNode(BaseNode):
 
             # Get configuration for this function
             config = {}
-            if self.function_configs and function.__name__ in self.function_configs:
+            if callable(function) and self.function_configs and function.__name__ in self.function_configs:
                 config = self.function_configs[function.__name__]
 
             packages = config.get("packages", None)

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

@@ -145,7 +145,7 @@ def create_function_node(
     """
     if is_workflow_class(function):
         # Create a class-level wrapper that calls the original function
-        def execute_function(self) -> BaseNode.Outputs:
+        def execute_inline_workflow_function(self) -> BaseNode.Outputs:
             outputs = self.state.meta.node_outputs.get(tool_router_node.Outputs.text)
 
             outputs = json.loads(outputs)
@@ -181,7 +181,7 @@ def create_function_node(
             f"InlineWorkflowNode_{function.__name__}",
             (FunctionNode,),
             {
-                "run": execute_function,
+                "run": execute_inline_workflow_function,
                 "__module__": __name__,
             },
         )

vellum/workflows/runner/runner.py

@@ -5,7 +5,21 @@ import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Iterator, Optional, Sequence, Set, Tuple, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    Generic,
+    Iterable,
+    Iterator,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
@@ -17,7 +31,7 @@ from vellum.workflows.events import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
     WorkflowEvent,
-    WorkflowEventStream,
+    WorkflowEventGenerator,
     WorkflowExecutionFulfilledEvent,
     WorkflowExecutionInitiatedEvent,
     WorkflowExecutionRejectedEvent,
@@ -31,6 +45,7 @@ from vellum.workflows.events.node import (
 )
 from vellum.workflows.events.types import BaseEvent, NodeParentContext, ParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
+    WorkflowEventStream,
     WorkflowExecutionFulfilledBody,
     WorkflowExecutionInitiatedBody,
     WorkflowExecutionPausedBody,
@@ -730,7 +745,7 @@ class WorkflowRunner(Generic[StateType]):
             return event.workflow_definition == self.workflow.__class__
         return False
 
-    def stream(self) -> WorkflowEventStream:
+    def _generate_events(self) -> Generator[WorkflowEvent, None, None]:
         background_thread = Thread(
             target=self._run_background_thread,
             name=f"{self.workflow.__class__.__name__}.background_thread",
@@ -788,3 +803,6 @@ class WorkflowRunner(Generic[StateType]):
 
         self._background_thread_queue.put(None)
         cancel_thread_kill_switch.set()
+
+    def stream(self) -> WorkflowEventStream:
+        return WorkflowEventGenerator(self._generate_events(), self._initial_state.meta.span_id)

vellum/workflows/utils/functions.py

@@ -1,12 +1,14 @@
 import dataclasses
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Type, Union, get_args, get_origin
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 from pydash import snake_case
 
+from vellum import Vellum
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.workflows.utils.vellum_variables import vellum_variable_type_to_openapi_type
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -86,6 +88,19 @@ def _compile_default_value(default: Any) -> Any:
     return default
 
 
+def _compile_deployment_workflow_input(input_var: Any) -> dict[str, Any]:
+    """
+    Converts a deployment workflow input variable to a JSON schema type definition.
+    """
+    primitive_type = vellum_variable_type_to_openapi_type(input_var.type)
+    input_schema = {"type": primitive_type}
+
+    if input_var.default is not None:
+        input_schema["default"] = input_var.default.value
+
+    return input_schema
+
+
 def compile_function_definition(function: Callable) -> FunctionDefinition:
     """
     Converts a Python function into our Vellum-native FunctionDefinition type.
@@ -151,3 +166,42 @@ def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -
         description=workflow_class.__doc__,
         parameters=parameters,
     )
+
+
+def compile_deployment_workflow_function_definition(
+    deployment_config: Dict[str, str],
+    vellum_client: Vellum,
+) -> FunctionDefinition:
+    """
+    Converts a deployment workflow config into our Vellum-native FunctionDefinition type.
+
+    Args:
+        deployment_config: Dict with 'deployment' and 'release_tag' keys
+        vellum_client: Vellum client instance
+    """
+    deployment = deployment_config["deployment"]
+    release_tag = deployment_config["release_tag"]
+
+    workflow_deployment_release = vellum_client.release_reviews.retrieve_workflow_deployment_release(
+        deployment, release_tag
+    )
+
+    input_variables = workflow_deployment_release.workflow_version.input_variables
+    description = workflow_deployment_release.description
+
+    properties = {}
+    required = []
+
+    for input_var in input_variables:
+        properties[input_var.key] = _compile_deployment_workflow_input(input_var)
+
+        if input_var.required and input_var.default is None:
+            required.append(input_var.key)
+
+    parameters = {"type": "object", "properties": properties, "required": required}
+
+    return FunctionDefinition(
+        name=deployment,
+        description=description,
+        parameters=parameters,
+    )

vellum/workflows/utils/tests/test_functions.py

@@ -1,14 +1,21 @@
 from dataclasses import dataclass
+from unittest.mock import Mock
 from typing import Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.client.types.vellum_variable import VellumVariable
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.utils.functions import compile_function_definition, compile_workflow_function_definition
+from vellum.workflows.utils.functions import (
+    compile_deployment_workflow_function_definition,
+    compile_function_definition,
+    compile_workflow_function_definition,
+)
 
 
 def test_compile_function_definition__just_name():
@@ -431,3 +438,146 @@ def test_compile_workflow_function_definition__optionals():
             "required": ["a", "b", "c"],
         },
     )
+
+
+def test_compile_deployment_workflow_function_definition__just_name():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+    mock_release.workflow_version.input_variables = []
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition (same structure as function test)
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={"type": "object", "properties": {}, "required": []},
+    )
+
+
+def test_compile_deployment_workflow_function_definition__all_args():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+
+    mock_inputs = []
+    for key, vellum_type in [
+        ("a", "STRING"),
+        ("b", "NUMBER"),
+        ("c", "JSON"),
+        ("d", "CHAT_HISTORY"),
+        ("e", "SEARCH_RESULTS"),
+        ("f", "ERROR"),
+        ("g", "ARRAY"),
+        ("h", "FUNCTION_CALL"),
+        ("i", "IMAGE"),
+        ("j", "AUDIO"),
+        ("k", "DOCUMENT"),
+        ("l", "NULL"),
+    ]:
+        mock_input = VellumVariable(
+            id=f"input_{key}",
+            key=key,
+            type=vellum_type,
+            required=True,
+            default=None,
+        )
+        mock_inputs.append(mock_input)
+
+    mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={
+            "type": "object",
+            "properties": {
+                "a": {"type": "string"},
+                "b": {"type": "number"},
+                "c": {"type": "object"},
+                "d": {"type": "array"},
+                "e": {"type": "array"},
+                "f": {"type": "object"},
+                "g": {"type": "array"},
+                "h": {"type": "object"},
+                "i": {"type": "object"},
+                "j": {"type": "object"},
+                "k": {"type": "object"},
+                "l": {"type": "null"},
+            },
+            "required": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+        },
+    )
+
+
+def test_compile_deployment_workflow_function_definition__defaults():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+
+    mock_inputs = []
+
+    mock_input_no_default = VellumVariable(
+        id="no_default",
+        key="no_default",
+        type="STRING",
+        required=True,
+        default=None,
+    )
+    mock_inputs.append(mock_input_no_default)
+
+    mock_input_null_default = VellumVariable(
+        id="null_default",
+        key="null_default",
+        type="STRING",
+        required=False,
+        default=StringVellumValue(value=None),
+    )
+    mock_inputs.append(mock_input_null_default)
+
+    mock_input_actual_default = VellumVariable(
+        id="actual_default",
+        key="actual_default",
+        type="STRING",
+        required=False,
+        default=StringVellumValue(value="hello world"),
+    )
+    mock_inputs.append(mock_input_actual_default)
+
+    mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition with proper default handling
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={
+            "type": "object",
+            "properties": {
+                "no_default": {"type": "string"},
+                "null_default": {"type": "string", "default": None},
+                "actual_default": {"type": "string", "default": "hello world"},
+            },
+            "required": ["no_default"],
+        },
+    )

vellum/workflows/utils/tests/test_vellum_variables.py

@@ -3,7 +3,10 @@ from typing import List, Optional
 
 from vellum import ChatMessage, SearchResult, VellumAudio, VellumDocument, VellumImage
 from vellum.workflows.types.core import Json
-from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
+from vellum.workflows.utils.vellum_variables import (
+    primitive_type_to_vellum_variable_type,
+    vellum_variable_type_to_openapi_type,
+)
 
 
 @pytest.mark.parametrize(
@@ -31,3 +34,24 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
 )
 def test_primitive_type_to_vellum_variable_type(type_, expected):
     assert primitive_type_to_vellum_variable_type(type_) == expected
+
+
+@pytest.mark.parametrize(
+    "vellum_type, expected",
+    [
+        ("STRING", "string"),
+        ("NUMBER", "number"),
+        ("JSON", "object"),
+        ("CHAT_HISTORY", "array"),
+        ("SEARCH_RESULTS", "array"),
+        ("ERROR", "object"),
+        ("ARRAY", "array"),
+        ("FUNCTION_CALL", "object"),
+        ("IMAGE", "object"),
+        ("AUDIO", "object"),
+        ("DOCUMENT", "object"),
+        ("NULL", "null"),
+    ],
+)
+def test_vellum_variable_type_to_openapi_type(vellum_type, expected):
+    assert vellum_variable_type_to_openapi_type(vellum_type) == expected

vellum/workflows/utils/vellum_variables.py

@@ -78,6 +78,36 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
     return "JSON"
 
 
+def vellum_variable_type_to_openapi_type(vellum_type: VellumVariableType) -> str:
+    """Converts a VellumVariableType to a JSON schema primitive type string"""
+    if vellum_type == "STRING":
+        return "string"
+    elif vellum_type == "NUMBER":
+        return "number"
+    elif vellum_type == "JSON":
+        return "object"
+    elif vellum_type == "CHAT_HISTORY":
+        return "array"
+    elif vellum_type == "SEARCH_RESULTS":
+        return "array"
+    elif vellum_type == "ERROR":
+        return "object"
+    elif vellum_type == "ARRAY":
+        return "array"
+    elif vellum_type == "FUNCTION_CALL":
+        return "object"
+    elif vellum_type == "IMAGE":
+        return "object"
+    elif vellum_type == "AUDIO":
+        return "object"
+    elif vellum_type == "DOCUMENT":
+        return "object"
+    elif vellum_type == "NULL":
+        return "null"
+    else:
+        return "object"
+
+
 def _is_type_optionally_equal(type_: Type, target_type: Type) -> bool:
     if type_ == target_type:
         return True

vellum/workflows/workflows/base.py

@@ -42,6 +42,7 @@ from vellum.workflows.events.node import (
     NodeExecutionStreamingBody,
     NodeExecutionStreamingEvent,
 )
+from vellum.workflows.events.stream import WorkflowEventGenerator
 from vellum.workflows.events.workflow import (
     GenericWorkflowEvent,
     WorkflowExecutionFulfilledBody,
@@ -167,7 +168,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         WorkflowExecutionPausedEvent,
     ]
 
-    WorkflowEventStream = Generator[WorkflowEvent, None, None]
+    WorkflowEventStream = WorkflowEventGenerator[WorkflowEvent]
 
     def __init__(
         self,
@@ -444,7 +445,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         """
 
         should_yield = event_filter or workflow_event_filter
-        for event in WorkflowRunner(
+        runner_stream = WorkflowRunner(
             self,
             inputs=inputs,
             state=state,
@@ -454,9 +455,14 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
             node_output_mocks=node_output_mocks,
             max_concurrency=max_concurrency,
             init_execution_context=self._execution_context,
-        ).stream():
-            if should_yield(self.__class__, event):
-                yield event
+        ).stream()
+
+        def _generate_filtered_events() -> Generator[BaseWorkflow.WorkflowEvent, None, None]:
+            for event in runner_stream:
+                if should_yield(self.__class__, event):
+                    yield event
+
+        return WorkflowEventGenerator(_generate_filtered_events(), runner_stream.span_id)
 
     def validate(self) -> None:
         """

{vellum_ai-0.14.71.dist-info → vellum_ai-0.14.72.dist-info}/METADATA

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

{vellum_ai-0.14.71.dist-info → vellum_ai-0.14.72.dist-info}/RECORD

@@ -3,22 +3,22 @@ vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
 vellum_cli/__init__.py,sha256=oi-vvNVepu23IBBjhA5uUIDVYBPqQ3EzxWZAPn2S64c,12700
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
 vellum_cli/config.py,sha256=v5BmZ-t_v4Jmqd7KVuQMZF2pRI-rbMspSkVYXIRoTmI,9448
-vellum_cli/image_push.py,sha256=Xw_IlItZ27OM5XrWcaqRxXCx4rroV3IaUByl8Ela6U8,10730
+vellum_cli/image_push.py,sha256=rPeSfTlFpdTzwTdnXRL82OVd61qMoGFGLxnLjZLU98Q,10596
 vellum_cli/init.py,sha256=WpnMXPItPmh0f0bBGIer3p-e5gu8DUGwSArT_FuoMEw,5093
 vellum_cli/logger.py,sha256=dcM_OmgqXLo93vDYswO5ylyUQQcTfnA5GTd5tbIt3wM,1446
 vellum_cli/ping.py,sha256=p_BCCRjgPhng6JktuECtkDQLbhopt6JpmrtGoLnLJT8,1161
 vellum_cli/pull.py,sha256=udYyPlJ6VKDdh78rApNJOZgxHl82fcV6iGnRPSdX1LY,14750
-vellum_cli/push.py,sha256=wxRlFu2mYW9SvwODYxwajri1mDQ2be0n-9i0d9QAc30,10194
+vellum_cli/push.py,sha256=TqzaJrI_ty_1GuB3HX3EKfAnbMUF14FWfMMTD06vn2I,10428
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=AFYZryKA2qnUuCPBxBKmHLFoPiE0WhBFFej9tNwSHdc,1526
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
-vellum_cli/tests/test_image_push.py,sha256=QGbhCB2DhkepoBUdfhv_ovks-HQ164jmjKFuYvPmJt8,9141
+vellum_cli/tests/test_image_push.py,sha256=xXZjI-CDp166cmk5P1NTa-aogergeIbcdfK4_KBsoHc,9095
 vellum_cli/tests/test_image_push_error_handling.py,sha256=_Wjfkn1orI2K4Ahzqz4u8T13or7NOX01K4BtcTuTIOM,7107
 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=hxMbW_j0weDDrkzVGpvLpFcwNQdn-fxTv4wBHeYizzc,49904
-vellum_cli/tests/test_push.py,sha256=I8XICg3pUb3yxAFLXziVHHf5CRm354LO-uUfwtca3bU,33897
+vellum_cli/tests/test_push.py,sha256=uyWknZ1CBkxxfKVdwcyv7fkGSxvvSNRdJegp5cV-_V4,35167
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,7 +32,7 @@ vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=jI_kUi9LnNLDp
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/tests/test_base_node_display.py,sha256=Z4Mf7xLCNiblSbpKI0BrV5modQr-ZcFzhfir_OSyTTs,2997
 vellum_ee/workflows/display/nodes/types.py,sha256=St1BB6no528OyELGiyRabWao0GGw6mLhstQAvEACbGk,247
-vellum_ee/workflows/display/nodes/utils.py,sha256=gxiixuiJi6jrYTV2jmsPsyQfeuwKmrULRb-Lg9c0Aqw,975
+vellum_ee/workflows/display/nodes/utils.py,sha256=sloya5TpXsnot1HURc9L51INwflRqUzHxRVnCS9Cd-4,973
 vellum_ee/workflows/display/nodes/vellum/__init__.py,sha256=nUIgH2s0-7IbQRNrBhLPyRNe8YIrx3Yo9HeeW-aXXFk,1668
 vellum_ee/workflows/display/nodes/vellum/api_node.py,sha256=5Uq8x08F64yrBcqbfsVeuoGnTa9eoOPumYzZZrDPmr0,8847
 vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py,sha256=rJbHZBg9A_v2bjk-R6MfWzShcrS2gcKIOyYGoqwTx8s,6353
@@ -142,7 +142,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=3ZqkR_DngkaI-fY5PAgWW2c7RZ88oONDwDkWfxAKLBc,1869
+vellum/client/core/client_wrapper.py,sha256=TaQmB_GjRpi-KMiR3qBKQTy1uf4a2n9roQbenkHDwBQ,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
@@ -830,7 +830,7 @@ vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQ
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/pydantic.py,sha256=j4ApZ5WyaoCX6v54qNoShhMFyft_uKWTkyAFz5wbcgg,3619
 vellum/plugins/utils.py,sha256=cPmxE9R2CK1bki2jKE8rB-G9zMf2pzHjSPDHFPXwd3Q,878
-vellum/plugins/vellum_mypy.py,sha256=QTuMSq6PiZW1dyTUZ5Bf1d4XkgFj0TKAgZLP8f4UgL4,27914
+vellum/plugins/vellum_mypy.py,sha256=hfjC2rIxNdQuJa6fIN4PDgODnQ3YaUszyaV2eNbLJlE,27952
 vellum/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/prompts/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/prompts/blocks/compilation.py,sha256=qeC_4La5auQkm4EyzCMpN34F5R8mjiGcLV7IxKgVf3k,9973
@@ -1509,12 +1509,13 @@ vellum/workflows/environment/__init__.py,sha256=TJz0m9dwIs6YOwCTeuN0HHsU-ecyjc1O
 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=nUWuniEfrhdtb-_2GzoDGlYnSJ_yuNUGjVkaKLNr-rM,4049
-vellum/workflows/events/__init__.py,sha256=6pxxceJo2dcaRkWtkDAYlUQZ-PHBQSZytIoyuUK48Qw,759
+vellum/workflows/events/__init__.py,sha256=V4mh766fyA70WvHelm9kfVZGrUgEKcJ9tJt8EepfQYU,832
 vellum/workflows/events/node.py,sha256=TaawUxKaZG8cv_GkiKnJmjOmC4Ic0wMlsxUduF2Rbpw,5446
+vellum/workflows/events/stream.py,sha256=xhXJTZirFi0xad5neAQNogrIQ4h47fpnKbVC3vCM5Js,889
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/events/tests/test_event.py,sha256=elg5j3MOdWQe-JjshopqVwd716Jrvtr9P_V2JUGZC60,17866
 vellum/workflows/events/types.py,sha256=LwgFlMRbptJvdPtPO1POUtGtbhGw7BSuvgHxNSgS7N8,4652
-vellum/workflows/events/workflow.py,sha256=i9JSCANjAhf5uc57gYspdII2V2OLItbc0BfT8yB9mF0,7728
+vellum/workflows/events/workflow.py,sha256=7rb1evKsTCRUdCnisAM5Anc19ZKGxnsmzwOOv6jwWEI,7761
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/accessor.py,sha256=1kY0sYfednQ_u0kh1Df2WTsDREVIOzU7UuZc5jvj5xw,2861
@@ -1658,9 +1659,9 @@ vellum/workflows/nodes/experimental/__init__.py,sha256=_tpZGWAZLydcKxfrj1-plrZeT
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
 vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=cKI2Ls25L-JVt4z4a2ozQa-YBeVy21Z7BQ32Sj7iBPE,10460
 vellum/workflows/nodes/experimental/tool_calling_node/__init__.py,sha256=S7OzT3I4cyOU5Beoz87nPwCejCMP2FsHBFL8OcVmxJ4,118
-vellum/workflows/nodes/experimental/tool_calling_node/node.py,sha256=FkhaJccpCbx2be_IZ5V2v6Lo-jPJ0WgSC5tveLvAW4A,5774
+vellum/workflows/nodes/experimental/tool_calling_node/node.py,sha256=1Sp-Jnziz8lK5t7snBIwhMk_wKzsXu_aqW7xAeHKc_w,5797
 vellum/workflows/nodes/experimental/tool_calling_node/tests/test_node.py,sha256=7x_o81vT7gWtVw3zDppcWnlJbakgxx_oI1esqhs2gpI,4551
-vellum/workflows/nodes/experimental/tool_calling_node/utils.py,sha256=iiB_Tm3zvElispx_DhnW4eQH1MnK-Y9k44X_PSpp7p8,9923
+vellum/workflows/nodes/experimental/tool_calling_node/utils.py,sha256=UiQ1o2tDl7EYLHY9HRWLa-MeuYPYfXp8lo2qNFakh2Q,9955
 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
@@ -1688,7 +1689,7 @@ 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=j2LGHb4fDWR1pB__C1efIMxptq_C49fcOpz893bQHVQ,33645
+vellum/workflows/runner/runner.py,sha256=itKhjnJBIXrKcI3nKbKsAwcmeP4pn5BowX-LaTPu_VU,33911
 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
@@ -1710,24 +1711,24 @@ vellum/workflows/types/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 vellum/workflows/types/tests/test_utils.py,sha256=UnZog59tR577mVwqZRqqWn2fScoOU1H6up0EzS8zYhw,2536
 vellum/workflows/types/utils.py,sha256=axxHbPLsnjhEOnMZrc5YarFd-P2bnsacBDQGNCvY8OY,6367
 vellum/workflows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/functions.py,sha256=FmbOnwl8tLUzbssybZkWRHyUfuXarimYMMD3ZTiUcPE,5390
+vellum/workflows/utils/functions.py,sha256=Gw9akY-_xU_kJpbkYvQ-07hOOLJpqq0rtch_3FbgFQ0,7169
 vellum/workflows/utils/names.py,sha256=QLUqfJ1tmSEeUwBKTTiv_Qk3QGbInC2RSmlXfGXc8Wo,380
 vellum/workflows/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/tests/test_functions.py,sha256=kw-HaYo9JAigFj6sfnAFAbBTLUzPMxB1DeEUY-o10AU,13143
+vellum/workflows/utils/tests/test_functions.py,sha256=4mhIhZdlZdiboq1NUhJlOvDeRrpG-Oa_HrstvSbjg64,18368
 vellum/workflows/utils/tests/test_names.py,sha256=aOqpyvMsOEK_9mg_-yaNxQDW7QQfwqsYs37PseyLhxw,402
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
-vellum/workflows/utils/tests/test_vellum_variables.py,sha256=maI5e7Od7UlpMwlrOrcdlXqnFhonkXGnWq8G2-YQLi8,1155
+vellum/workflows/utils/tests/test_vellum_variables.py,sha256=vbnKgm41aB5OXlO-ZIPbhQ6xDiZkT8KMxCLqz4zocWY,1791
 vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrgTY,739
-vellum/workflows/utils/vellum_variables.py,sha256=UiGlUh0a8vel2FbW3w-xbHxSv_jNutkDdqMVtP_b42A,3385
+vellum/workflows/utils/vellum_variables.py,sha256=tDWGyE8CfxYaCQQfMwTHqQNgK5V5sJMuhjLsliT8Ar4,4286
 vellum/workflows/vellum_client.py,sha256=xkfoucodxNK5JR2-lbRqZx3xzDgExWkP6kySrpi_Ubc,1079
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=V60RZat8mG0XmMuIjprkHnacD_MpUdxGcN9t4TaP_Pg,24044
+vellum/workflows/workflows/base.py,sha256=ehJSHDf1vuNjJtKryqKgb5HKGtx_D-wWUiJNBWZ50JU,24347
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
 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.71.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.71.dist-info/METADATA,sha256=C5GX4tfVPU2-YXu_9tu4RToI1a6SafllfrsjW6SiM9c,5556
-vellum_ai-0.14.71.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.71.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.71.dist-info/RECORD,,
+vellum_ai-0.14.72.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.72.dist-info/METADATA,sha256=5rmPI1o0CHUiw7gPjZq2ZSjkiaWzLTbWTxG0pCyP3WA,5556
+vellum_ai-0.14.72.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.72.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.72.dist-info/RECORD,,

vellum_cli/image_push.py

@@ -30,12 +30,8 @@ def image_push_command(
         if not os.path.exists(source):
             handle_cli_error(logger, "Dockerfile not found", f"Dockerfile does not exist: {source}")
 
-        source_dir = os.path.dirname(source)
-        dockerfile_name = os.path.basename(source)
-
         build_result = subprocess.run(
-            ["docker", "buildx", "build", "-f", dockerfile_name, "--platform=linux/amd64", "-t", image, "."],
-            cwd=source_dir,
+            ["docker", "buildx", "build", "-f", source, "--platform=linux/amd64", "-t", image, "."],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )

vellum_cli/push.py

@@ -242,6 +242,13 @@ def push_command(
 {json.dumps(response.proposed_diffs, indent=2)}
 """
         )  # type: ignore[attr-defined]
+
+        error_list = list(workflow_display.errors)
+        has_errors = len(error_list) > 0
+        has_diffs = response.proposed_diffs is not None and response.proposed_diffs
+
+        if has_errors or has_diffs:
+            exit(1)
     else:
         default_api_url = client._client_wrapper._environment.default
         base_url = default_api_url.split("/v1")[0].replace("//api.", "//app.")

vellum_cli/tests/test_image_push.py

@@ -209,13 +209,12 @@ def test_image_push_with_source_success(
         "buildx",
         "build",
         "-f",
-        "Dockerfile",
+        dockerfile_path,
         "--platform=linux/amd64",
         "-t",
         "myimage:latest",
         ".",
     ]
-    assert build_call[1]["cwd"] == mock_temp_dir
 
     assert "Docker build completed successfully" in result.output
     assert "Image successfully pushed" in result.output

vellum_cli/tests/test_push.py

@@ -444,8 +444,8 @@ class ExampleWorkflow(BaseWorkflow):
     runner = CliRunner(mix_stderr=True)
     result = runner.invoke(cli_main, ["push", module, "--dry-run"])
 
-    # THEN it should succeed
-    assert result.exit_code == 0
+    # THEN it should fail with exit code 1 due to errors
+    assert result.exit_code == 1
 
     # AND we should have called the push API with the dry-run option
     vellum_client.workflows.push.assert_called_once()
@@ -459,6 +459,37 @@ class ExampleWorkflow(BaseWorkflow):
     assert "iterable_item_added" in result.output
 
 
+def test_push__dry_run_option_no_errors_returns_success(mock_module, vellum_client):
+    """Test that dry-run returns exit code 0 when there are no errors or diffs"""
+    # GIVEN a workflow module with a valid workflow (using the same pattern as happy path test)
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully with no errors and no diffs
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        proposed_diffs=None,
+    )
+
+    # WHEN calling `vellum push` with dry-run
+    runner = CliRunner(mix_stderr=True)
+    result = runner.invoke(cli_main, ["push", module, "--dry-run"])
+
+    # THEN it should succeed with exit code 0
+    assert result.exit_code == 0
+
+    # AND we should have called the push API with the dry-run option
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert call_args["dry_run"] is True
+
+    # AND the report should be in the output
+    assert "## Errors" in result.output
+    assert "No errors found." in result.output
+    assert "## Proposed Diffs" in result.output
+
+
 def test_push__strict_option_returns_diffs(mock_module, vellum_client):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir

vellum_ee/workflows/display/nodes/utils.py

@@ -8,11 +8,11 @@ _T = TypeVar("_T")
 
 
 @overload
-def raise_if_descriptor(_node_attr: BaseDescriptor[_T]) -> _T: ...
+def raise_if_descriptor(node_attr: BaseDescriptor[_T]) -> _T: ...
 
 
 @overload
-def raise_if_descriptor(_node_attr: _T) -> _T: ...
+def raise_if_descriptor(node_attr: _T) -> _T: ...
 
 
 def raise_if_descriptor(node_attr: Union[NodeReference[_T], _T]) -> Optional[_T]: