vellum-ai 1.4.1__py3-none-any.whl → 1.4.2__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.4.1",
+            "User-Agent": "vellum-ai/1.4.2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.4.1",
+            "X-Fern-SDK-Version": "1.4.2",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/workflows/constants.py

@@ -58,3 +58,7 @@ class APIRequestMethod(Enum):
 class AuthorizationType(Enum):
     BEARER_TOKEN = "BEARER_TOKEN"
     API_KEY = "API_KEY"
+
+
+class VellumIntegrationProviderType(Enum):
+    COMPOSIO = "COMPOSIO"

vellum/workflows/emitters/base.py

@@ -29,3 +29,11 @@ class BaseWorkflowEmitter(ABC):
     @abstractmethod
     def snapshot_state(self, state: BaseState) -> None:
         pass
+
+    @abstractmethod
+    def join(self) -> None:
+        """
+        Wait for any background threads or timers used by this emitter to complete.
+        This ensures all pending work is finished before the workflow terminates.
+        """
+        pass

vellum/workflows/emitters/vellum_emitter.py

@@ -135,3 +135,13 @@ class VellumEmitter(BaseWorkflowEmitter):
             request=events,  # type: ignore[arg-type]
             request_options=request_options,
         )
+
+    def join(self) -> None:
+        """
+        Wait for any background threads or timers used by this emitter to complete.
+        This ensures all pending work is finished before the workflow terminates.
+        """
+        self._flush_events()
+
+        if self._debounce_timer and self._debounce_timer.is_alive():
+            self._debounce_timer.join()

vellum/workflows/inputs/dataset_row.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict
 
-from pydantic import field_serializer
+from pydantic import Field, field_serializer
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
@@ -16,7 +16,7 @@ class DatasetRow(UniversalBaseModel):
     """
 
     label: str
-    inputs: BaseInputs
+    inputs: BaseInputs = Field(default_factory=BaseInputs)
 
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: BaseInputs) -> Dict[str, Any]:

vellum/workflows/nodes/bases/base.py

@@ -1,4 +1,4 @@
-from abc import ABC, ABCMeta
+from abc import ABC, ABCMeta, abstractmethod
 from dataclasses import field
 from functools import cached_property, reduce
 import inspect
@@ -215,6 +215,17 @@ class BaseNodeMeta(ABCMeta):
                 yield attr_value
                 yielded_attr_names.add(attr_name)
 
+    @abstractmethod
+    def __validate__(cls) -> None:
+        """
+        Validates the node.
+        Subclasses can override this method to implement their specific validation logic.
+        Called during serialization or explicit validation.
+
+        Default implementation performs no validation.
+        """
+        pass
+
 
 class _BaseNodeTriggerMeta(type):
     def __eq__(self, other: Any) -> bool:

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

@@ -112,4 +112,10 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
         if not target_node_output:
             return False
 
+        if not isinstance(target_node_output.instance, OutputReference):
+            return False
+
+        if target_node_output.instance.name != "text":
+            return False
+
         return True

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

@@ -45,9 +45,15 @@ from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePrompt
 from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
-from vellum.workflows.types.definition import DeploymentDefinition, MCPServer
+from vellum.workflows.types.definition import (
+    ComposioToolDefinition,
+    DeploymentDefinition,
+    MCPServer,
+    VellumIntegrationToolDefinition,
+)
 from vellum.workflows.types.generics import StateType, is_workflow_class
 from vellum.workflows.utils.functions import (
+    compile_composio_tool_definition,
     compile_function_definition,
     compile_inline_workflow_function_definition,
     compile_mcp_tool_definition,
@@ -134,7 +140,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 elif isinstance(function, DeploymentDefinition):
                     normalized_functions.append(
                         compile_workflow_deployment_function_definition(
-                            function.model_dump(),
+                            function,
                             vellum_client=self._context.vellum_client,
                         )
                     )
@@ -142,6 +148,14 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                     normalized_functions.append(compile_inline_workflow_function_definition(function))
                 elif callable(function):
                     normalized_functions.append(compile_function_definition(function))
+                elif isinstance(function, ComposioToolDefinition):
+                    normalized_functions.append(compile_composio_tool_definition(function))
+                elif isinstance(function, VellumIntegrationToolDefinition):
+                    # TODO: Implement compile_vellum_integration_tool_definition
+                    raise NotImplementedError(
+                        "VellumIntegrationToolDefinition support coming soon. "
+                        "This will be implemented when compile_vellum_integration_tool_definition is created."
+                    )
                 elif isinstance(function, MCPServer):
                     tool_definitions = compile_mcp_tool_definition(function)
                     for tool_def in tool_definitions:

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

@@ -5,6 +5,7 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import cast_to_output_type
 from vellum.workflows.ports import NodePorts
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -27,6 +28,7 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
             **annotations,
             "value": parent.get_output_type(),
         }
+
         return parent
 
     def get_output_type(cls) -> Type:
@@ -38,6 +40,63 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
         else:
             return all_args[1]
 
+    def __validate__(cls) -> None:
+        cls._validate_output_type_consistency(cls)
+
+    @classmethod
+    def _validate_output_type_consistency(mcs, cls: Type) -> None:
+        """
+        Validates that the declared output type of FinalOutputNode matches
+        the type of the descriptor assigned to the 'value' attribute in its Outputs class.
+
+        Raises ValueError if there's a type mismatch.
+        """
+        if not hasattr(cls, "Outputs"):
+            return
+
+        outputs_class = cls.Outputs
+        if not hasattr(outputs_class, "value"):
+            return
+
+        declared_output_type = cls.get_output_type()
+        value_descriptor = None
+
+        if "value" in outputs_class.__dict__:
+            value_descriptor = outputs_class.__dict__["value"]
+        else:
+            value_descriptor = getattr(outputs_class, "value")
+
+        if isinstance(value_descriptor, OutputReference):
+            descriptor_types = value_descriptor.types
+
+            type_mismatch = True
+            for descriptor_type in descriptor_types:
+                if descriptor_type == declared_output_type:
+                    type_mismatch = False
+                    break
+                try:
+                    if issubclass(descriptor_type, declared_output_type) or issubclass(
+                        declared_output_type, descriptor_type
+                    ):
+                        type_mismatch = False
+                        break
+                except TypeError:
+                    # Handle cases where types aren't classes (e.g., Union)
+                    if str(descriptor_type) == str(declared_output_type):
+                        type_mismatch = False
+                        break
+
+            if type_mismatch:
+                declared_type_name = getattr(declared_output_type, "__name__", str(declared_output_type))
+                descriptor_type_names = [getattr(t, "__name__", str(t)) for t in descriptor_types]
+
+                raise ValueError(
+                    f"Output type mismatch in {cls.__name__}: "
+                    f"FinalOutputNode is declared with output type '{declared_type_name}' "
+                    f"but the 'value' descriptor has type(s) {descriptor_type_names}. "
+                    f"The output descriptor type must match the declared FinalOutputNode output type."
+                )
+
 
 class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], metaclass=_FinalOutputNodeMeta):
     """

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

@@ -2,10 +2,11 @@ import pytest
 
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.nodes.displayable.inline_prompt_node import InlinePromptNode
 from vellum.workflows.state.base import BaseState
 
 
-def test_final_output_node__mismatched_output_type():
+def test_final_output_node__mismatched_output_type_should_raise_exception_when_ran():
     # GIVEN a FinalOutputNode with a mismatched output type
     class StringOutputNode(FinalOutputNode[BaseState, str]):
         class Outputs(FinalOutputNode.Outputs):
@@ -18,3 +19,41 @@ def test_final_output_node__mismatched_output_type():
 
     # THEN an error is raised
     assert str(exc_info.value) == "Expected an output of type 'str', but received 'dict'"
+
+
+def test_final_output_node__mismatched_output_type_should_raise_exception():
+    # GIVEN a FinalOutputNode declared with list output type but has a string value type
+    class Output(FinalOutputNode[BaseState, list]):
+        """Output the extracted invoice line items as an array of objects."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = InlinePromptNode.Outputs.text
+
+    # WHEN attempting to validate the node class
+    # THEN a ValueError should be raised during validation
+    with pytest.raises(ValueError) as exc_info:
+        Output.__validate__()
+
+    # AND the error message should indicate the type mismatch
+    assert (
+        str(exc_info.value)
+        == "Output type mismatch in Output: FinalOutputNode is declared with output type 'list' but "
+        "the 'value' descriptor has type(s) ['str']. The output descriptor type must match the "
+        "declared FinalOutputNode output type."
+    )
+
+
+def test_final_output_node__matching_output_type_should_pass_validation():
+    # GIVEN a FinalOutputNode declared with correct matching types
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        """Output with correct type matching."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = InlinePromptNode.Outputs.text
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        CorrectOutput.__validate__()
+    except ValueError:
+        pytest.fail("Validation should not raise an exception for correct type matching")

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

@@ -2,6 +2,7 @@ from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set,
 
 from vellum import ChatMessage, PromptBlock
 from vellum.client.types.prompt_parameters import PromptParameters
+from vellum.client.types.prompt_settings import PromptSettings
 from vellum.prompts.constants import DEFAULT_PROMPT_PARAMETERS
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -47,6 +48,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
     max_prompt_iterations: ClassVar[Optional[int]] = 5
+    settings: ClassVar[Optional[Union[PromptSettings, Dict[str, Any]]]] = None
 
     class Outputs(BaseOutputs):
         """
@@ -150,6 +152,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             max_prompt_iterations=self.max_prompt_iterations,
             process_parameters_method=process_parameters_method,
             process_blocks_method=process_blocks_method,
+            settings=self.settings,
         )
 
         # Create the router node (handles routing logic only)

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

@@ -5,6 +5,7 @@ from vellum.client.types.chat_message_prompt_block import ChatMessagePromptBlock
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
 from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
 from vellum.client.types.plain_text_prompt_block import PlainTextPromptBlock
+from vellum.client.types.prompt_settings import PromptSettings
 from vellum.client.types.rich_text_prompt_block import RichTextPromptBlock
 from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
@@ -250,3 +251,66 @@ def test_get_mcp_tool_name_snake_case():
 
     result = get_mcp_tool_name(mcp_tool)
     assert result == "github_server__create_repository"
+
+
+def test_create_tool_prompt_node_settings_dict_stream_disabled(vellum_adhoc_prompt_client):
+    # GIVEN settings provided as dict with stream disabled
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+        max_prompt_iterations=1,
+        settings={"stream_enabled": False},
+    )
+
+    # AND the API mocks
+    def generate_non_stream_response(*args, **kwargs):
+        return FulfilledExecutePromptEvent(execution_id=str(uuid4()), outputs=[StringVellumValue(value="ok")])
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt.side_effect = generate_non_stream_response
+
+    # WHEN we run the node
+    node_instance = tool_prompt_node()
+    list(node_instance.run())
+
+    # THEN the node should have called the API correctly
+    assert node_instance.settings is not None
+    assert node_instance.settings.stream_enabled is False
+    assert vellum_adhoc_prompt_client.adhoc_execute_prompt.call_count == 1
+    assert vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.call_count == 0
+
+
+def test_create_tool_prompt_node_settings_model_stream_enabled(vellum_adhoc_prompt_client):
+    # GIVEN settings provided as PromptSettings with stream enabled
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+        max_prompt_iterations=1,
+        settings=PromptSettings(stream_enabled=True),
+    )
+
+    # AND the API mocks
+    def generate_stream_events(*args, **kwargs):
+        execution_id = str(uuid4())
+        events = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(execution_id=execution_id, outputs=[StringVellumValue(value="ok")]),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_stream_events
+
+    # WHEN we run the node
+    node_instance = tool_prompt_node()
+    list(node_instance.run())
+
+    # THEN the node should have called the API correctly
+    assert node_instance.settings is not None
+    assert node_instance.settings.stream_enabled is True
+    assert vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.call_count == 1
+    assert vellum_adhoc_prompt_client.adhoc_execute_prompt.call_count == 0

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

@@ -9,9 +9,9 @@ from vellum.client.types.array_chat_message_content import ArrayChatMessageConte
 from vellum.client.types.array_chat_message_content_item import ArrayChatMessageContentItem
 from vellum.client.types.function_call_chat_message_content import FunctionCallChatMessageContent
 from vellum.client.types.function_call_chat_message_content_value import FunctionCallChatMessageContentValue
-from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.prompt_parameters import PromptParameters
+from vellum.client.types.prompt_settings import PromptSettings
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -31,7 +31,13 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolBase
-from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
+from vellum.workflows.types.definition import (
+    ComposioToolDefinition,
+    DeploymentDefinition,
+    MCPServer,
+    MCPToolDefinition,
+    VellumIntegrationToolDefinition,
+)
 from vellum.workflows.types.generics import is_workflow_class
 from vellum.workflows.utils.functions import compile_mcp_tool_definition, get_mcp_tool_name
 
@@ -274,36 +280,6 @@ class ElseNode(BaseNode[ToolCallingState]):
         return self.Outputs()
 
 
-def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> FunctionDefinition:
-    """Hydrate a ComposioToolDefinition with detailed information from the Composio API.
-
-    Args:
-        tool_def: The basic ComposioToolDefinition to enhance
-
-    Returns:
-        FunctionDefinition with detailed parameters and description
-    """
-    try:
-        composio_service = ComposioService()
-        tool_details = composio_service.get_tool_by_slug(tool_def.action)
-
-        # Create a FunctionDefinition directly with proper field extraction
-        return FunctionDefinition(
-            name=tool_def.name,
-            description=tool_details.get("description", tool_def.description),
-            parameters=tool_details.get("input_parameters", {}),
-        )
-
-    except Exception as e:
-        # If hydration fails (including no API key), log and return basic function definition
-        logger.warning(f"Failed to enhance Composio tool '{tool_def.action}': {e}")
-        return FunctionDefinition(
-            name=tool_def.name,
-            description=tool_def.description,
-            parameters={},
-        )
-
-
 def create_tool_prompt_node(
     ml_model: str,
     blocks: List[Union[PromptBlock, Dict[str, Any]]],
@@ -313,17 +289,10 @@ def create_tool_prompt_node(
     max_prompt_iterations: Optional[int] = None,
     process_parameters_method: Optional[Callable] = None,
     process_blocks_method: Optional[Callable] = None,
+    settings: Optional[Union[PromptSettings, Dict[str, Any]]] = None,
 ) -> Type[ToolPromptNode]:
     if functions and len(functions) > 0:
-        prompt_functions: List[Union[Tool, FunctionDefinition]] = []
-
-        for function in functions:
-            if isinstance(function, ComposioToolDefinition):
-                # Get Composio tool details and hydrate the function definition
-                enhanced_function = _hydrate_composio_tool_definition(function)
-                prompt_functions.append(enhanced_function)
-            else:
-                prompt_functions.append(function)
+        prompt_functions: List[Tool] = functions
     else:
         prompt_functions = []
 
@@ -359,6 +328,13 @@ def create_tool_prompt_node(
         ),
     }
 
+    # Normalize settings to PromptSettings if provided as a dict
+    normalized_settings: Optional[PromptSettings]
+    if isinstance(settings, dict):
+        normalized_settings = PromptSettings.model_validate(settings)
+    else:
+        normalized_settings = settings
+
     node = cast(
         Type[ToolPromptNode],
         type(
@@ -371,6 +347,7 @@ def create_tool_prompt_node(
                 "prompt_inputs": node_prompt_inputs,
                 "parameters": parameters,
                 "max_prompt_iterations": max_prompt_iterations,
+                "settings": normalized_settings,
                 **({"process_parameters": process_parameters_method} if process_parameters_method is not None else {}),
                 **({"process_blocks": process_blocks_method} if process_blocks_method is not None else {}),
                 "__module__": __name__,
@@ -409,6 +386,10 @@ def create_router_node(
                 function_name = get_function_name(function)
                 port = create_port_condition(function_name)
                 setattr(Ports, function_name, port)
+            elif isinstance(function, VellumIntegrationToolDefinition):
+                function_name = get_function_name(function)
+                port = create_port_condition(function_name)
+                setattr(Ports, function_name, port)
             elif isinstance(function, MCPServer):
                 tool_functions: List[MCPToolDefinition] = compile_mcp_tool_definition(function)
                 for tool_function in tool_functions:
@@ -483,6 +464,12 @@ def create_function_node(
             },
         )
         return node
+    elif isinstance(function, VellumIntegrationToolDefinition):
+        # TODO: Implement VellumIntegrationNode
+        raise NotImplementedError(
+            "VellumIntegrationToolDefinition support coming soon. "
+            "This will be implemented when the VellumIntegrationService is created."
+        )
     elif is_workflow_class(function):
         function.is_dynamic = True
         node = type(
@@ -572,5 +559,7 @@ def get_function_name(function: ToolBase) -> str:
     elif isinstance(function, ComposioToolDefinition):
         # model post init sets the name to the action if it's not set
         return function.name  # type: ignore[return-value]
+    elif isinstance(function, VellumIntegrationToolDefinition):
+        return function.name
     else:
         return snake_case(function.__name__)

vellum/workflows/tests/test_dataset_row.py

@@ -97,3 +97,32 @@ def test_dataset_row_with_default_inputs():
     assert serialized_dict["label"] == "defaults_test"
     assert serialized_dict["inputs"]["required_field"] == "required_value"
     assert serialized_dict["inputs"]["optional_with_default"] == "default_value"
+
+
+def test_dataset_row_without_inputs():
+    """
+    Test that DatasetRow can be created with only a label (no inputs parameter).
+    """
+
+    dataset_row = DatasetRow(label="test_label_only")
+
+    serialized_dict = dataset_row.model_dump()
+
+    assert serialized_dict["label"] == "test_label_only"
+    assert serialized_dict["inputs"] == {}
+
+    assert isinstance(dataset_row.inputs, BaseInputs)
+
+
+def test_dataset_row_with_empty_inputs():
+    """
+    Test that DatasetRow can be created with explicitly empty BaseInputs.
+    """
+
+    # GIVEN a DatasetRow with explicitly empty BaseInputs
+    dataset_row = DatasetRow(label="test_label", inputs=BaseInputs())
+
+    serialized_dict = dataset_row.model_dump()
+
+    assert serialized_dict["label"] == "test_label"
+    assert serialized_dict["inputs"] == {}

vellum/workflows/types/core.py

@@ -13,7 +13,12 @@ from typing import (  # type: ignore[attr-defined]
 )
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
-from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer
+from vellum.workflows.types.definition import (
+    ComposioToolDefinition,
+    DeploymentDefinition,
+    MCPServer,
+    VellumIntegrationToolDefinition,
+)
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -51,5 +56,11 @@ class ConditionType(Enum):
 
 
 # Type alias for functions that can be called in tool calling nodes
-ToolBase = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"], ComposioToolDefinition]
+ToolBase = Union[
+    Callable[..., Any],
+    DeploymentDefinition,
+    Type["BaseWorkflow"],
+    ComposioToolDefinition,
+    VellumIntegrationToolDefinition,
+]
 Tool = Union[ToolBase, MCPServer]

vellum/workflows/types/definition.py

@@ -10,7 +10,7 @@ from vellum import Vellum
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_resource_definition import CodeResourceDefinition as ClientCodeResourceDefinition
 from vellum.client.types.vellum_variable import VellumVariable
-from vellum.workflows.constants import AuthorizationType
+from vellum.workflows.constants import AuthorizationType, VellumIntegrationProviderType
 from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 
 
@@ -165,6 +165,18 @@ class ComposioToolDefinition(UniversalBaseModel):
             self.name = self.action.lower()
 
 
+class VellumIntegrationToolDefinition(UniversalBaseModel):
+    type: Literal["INTEGRATION"] = "INTEGRATION"
+
+    # Core identification
+    provider: VellumIntegrationProviderType
+    integration: str  # "GITHUB", "SLACK", etc.
+    name: str  # Specific action like "GITHUB_CREATE_AN_ISSUE"
+
+    # Required for tool base consistency
+    description: str
+
+
 class MCPServer(UniversalBaseModel):
     type: Literal["MCP_SERVER"] = "MCP_SERVER"
     name: str

vellum/workflows/utils/functions.py

@@ -1,19 +1,6 @@
 import dataclasses
 import inspect
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Callable,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Type,
-    Union,
-    get_args,
-    get_origin,
-)
+from typing import TYPE_CHECKING, Annotated, Any, Callable, List, Literal, Optional, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
@@ -21,8 +8,15 @@ from pydash import snake_case
 
 from vellum import Vellum
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.workflows.integrations.composio_service import ComposioService
 from vellum.workflows.integrations.mcp_service import MCPService
-from vellum.workflows.types.definition import MCPServer, MCPToolDefinition
+from vellum.workflows.types.definition import (
+    ComposioToolDefinition,
+    DeploymentDefinition,
+    MCPServer,
+    MCPToolDefinition,
+    VellumIntegrationToolDefinition,
+)
 from vellum.workflows.utils.vellum_variables import vellum_variable_type_to_openapi_type
 
 if TYPE_CHECKING:
@@ -238,25 +232,21 @@ def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkfl
 
 
 def compile_workflow_deployment_function_definition(
-    deployment_config: Dict[str, str],
+    deployment_definition: DeploymentDefinition,
     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
+        deployment_definition: DeploymentDefinition instance
         vellum_client: Vellum client instance
     """
-    deployment = deployment_config["deployment"]
-    release_tag = deployment_config["release_tag"]
-
-    workflow_deployment_release = vellum_client.workflow_deployments.retrieve_workflow_deployment_release(
-        deployment, release_tag
-    )
+    release_info = deployment_definition.get_release_info(vellum_client)
 
-    input_variables = workflow_deployment_release.workflow_version.input_variables
-    description = workflow_deployment_release.description
+    name = release_info["name"]
+    description = release_info["description"]
+    input_variables = release_info["input_variables"]
 
     properties = {}
     required = []
@@ -270,7 +260,7 @@ def compile_workflow_deployment_function_definition(
     parameters = {"type": "object", "properties": properties, "required": required}
 
     return FunctionDefinition(
-        name=deployment.replace("-", ""),
+        name=name.replace("-", ""),
         description=description,
         parameters=parameters,
     )
@@ -300,6 +290,53 @@ def compile_mcp_tool_definition(server_def: MCPServer) -> List[MCPToolDefinition
         return []
 
 
+def compile_composio_tool_definition(tool_def: ComposioToolDefinition) -> FunctionDefinition:
+    """Hydrate a ComposioToolDefinition with detailed information from the Composio API.
+
+    Args:
+        tool_def: The basic ComposioToolDefinition to enhance
+
+    Returns:
+        FunctionDefinition with detailed parameters and description
+    """
+    try:
+        composio_service = ComposioService()
+        tool_details = composio_service.get_tool_by_slug(tool_def.action)
+
+        # Create a FunctionDefinition directly with proper field extraction
+        return FunctionDefinition(
+            name=tool_def.name,
+            description=tool_details.get("description", tool_def.description),
+            parameters=tool_details.get("input_parameters", {}),
+        )
+    except Exception:
+        # If hydration fails (including no API key), return basic function definition
+        return FunctionDefinition(
+            name=tool_def.name,
+            description=tool_def.description,
+            parameters={},
+        )
+
+
+def compile_vellum_integration_tool_definition(tool_def: VellumIntegrationToolDefinition) -> FunctionDefinition:
+    """Compile a VellumIntegrationToolDefinition into a FunctionDefinition.
+
+    TODO: Implement when VellumIntegrationService is created.
+
+    Args:
+        tool_def: The VellumIntegrationToolDefinition to compile
+
+    Returns:
+        FunctionDefinition with tool parameters and description
+    """
+    # TODO: Implement when VellumIntegrationService is available
+    # This will eventually use VellumIntegrationService to fetch tool details
+    raise NotImplementedError(
+        "VellumIntegrationToolDefinition compilation coming soon. "
+        "This will be implemented when the VellumIntegrationService is created."
+    )
+
+
 def use_tool_inputs(**inputs):
     """
     Decorator to specify which parameters of a tool function should be provided

vellum/workflows/utils/tests/test_functions.py

@@ -13,6 +13,7 @@ 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.types.definition import DeploymentDefinition
 from vellum.workflows.utils.functions import (
     compile_function_definition,
     compile_inline_workflow_function_definition,
@@ -449,14 +450,15 @@ def test_compile_workflow_deployment_function_definition__just_name():
     # GIVEN a mock Vellum client and deployment
     mock_client = Mock()
     mock_release = Mock()
+    mock_release.deployment.name = "my_deployment"
     mock_release.workflow_version.input_variables = []
     mock_release.description = "This is a test deployment"
     mock_client.workflow_deployments.retrieve_workflow_deployment_release.return_value = mock_release
 
-    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+    deployment_definition = DeploymentDefinition(deployment="my_deployment", release_tag="LATEST")
 
     # WHEN compiling the deployment workflow function
-    compiled_function = compile_workflow_deployment_function_definition(deployment_config, mock_client)
+    compiled_function = compile_workflow_deployment_function_definition(deployment_definition, mock_client)
 
     # THEN it should return the compiled function definition (same structure as function test)
     assert compiled_function == FunctionDefinition(
@@ -496,13 +498,14 @@ def test_compile_workflow_deployment_function_definition__all_args():
         mock_inputs.append(mock_input)
 
     mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.deployment.name = "my_deployment"
     mock_release.description = "This is a test deployment"
     mock_client.workflow_deployments.retrieve_workflow_deployment_release.return_value = mock_release
 
-    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+    deployment_definition = DeploymentDefinition(deployment="my_deployment", release_tag="latest")
 
     # WHEN compiling the deployment workflow function
-    compiled_function = compile_workflow_deployment_function_definition(deployment_config, mock_client)
+    compiled_function = compile_workflow_deployment_function_definition(deployment_definition, mock_client)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -564,13 +567,14 @@ def test_compile_workflow_deployment_function_definition__defaults():
     mock_inputs.append(mock_input_actual_default)
 
     mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.deployment.name = "my_deployment"
     mock_release.description = "This is a test deployment"
     mock_client.workflow_deployments.retrieve_workflow_deployment_release.return_value = mock_release
 
-    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+    deployment_definition = DeploymentDefinition(deployment="my_deployment", release_tag="LATEST")
 
     # WHEN compiling the deployment workflow function
-    compiled_function = compile_workflow_deployment_function_definition(deployment_config, mock_client)
+    compiled_function = compile_workflow_deployment_function_definition(deployment_definition, mock_client)
 
     # THEN it should return the compiled function definition with proper default handling
     assert compiled_function == FunctionDefinition(

vellum/workflows/vellum_client.py

@@ -2,15 +2,21 @@ import os
 from typing import List, Optional
 
 from vellum import Vellum, VellumEnvironment
+from vellum.client.types.api_version_enum import ApiVersionEnum
 
 
-def create_vellum_client(api_key: Optional[str] = None, api_url: Optional[str] = None) -> Vellum:
+def create_vellum_client(
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    api_version: Optional[ApiVersionEnum] = None,
+) -> Vellum:
     if api_key is None:
         api_key = os.getenv("VELLUM_API_KEY", default="")
 
     return Vellum(
         api_key=api_key,
         environment=create_vellum_environment(api_url),
+        api_version=api_version,
     )
 
 

vellum/workflows/workflows/base.py

@@ -687,6 +687,14 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
             raise ValueError(f"Multiple workflows found in {module_path}")
         return workflows[0]
 
+    def join(self) -> None:
+        """
+        Wait for all emitters to complete their background work.
+        This ensures all pending events are processed before the workflow terminates.
+        """
+        for emitter in self.emitters:
+            emitter.join()
+
 
 WorkflowExecutionInitiatedBody.model_rebuild()
 WorkflowExecutionFulfilledBody.model_rebuild()

{vellum_ai-1.4.1.dist-info → vellum_ai-1.4.2.dist-info}/METADATA

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

{vellum_ai-1.4.1.dist-info → vellum_ai-1.4.2.dist-info}/RECORD

@@ -19,8 +19,8 @@ vellum_cli/tests/test_init.py,sha256=C_rV4lu-ab5iFoLRizs1XAUnSPdMf7oFuc1i4N4udOU
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_move.py,sha256=FIrL1xlH5oFKGX2MugcTKL8JilpopmUC7hP5OaqF5zw,5213
 vellum_cli/tests/test_ping.py,sha256=b3aQLd-N59_8w2rRiWqwpB1rlHaKEYVbAj1Y3hi7A-g,2605
-vellum_cli/tests/test_pull.py,sha256=f7dK61y82LlJm-FAv-IpfmscJijIfZZrR-rzN1TKkU0,49421
-vellum_cli/tests/test_push.py,sha256=10G-H88tdiYvg9CaC8OXOf25UEzWkWWB01vNhuxzjog,41944
+vellum_cli/tests/test_pull.py,sha256=e2XHzcHIx9k-FyuNAl7wMSNsSSebPGyP6U05JGcddFs,49447
+vellum_cli/tests/test_push.py,sha256=2MjkNKr_9Guv5Exjsm3L1BeVXmPkKUcCSiKnp90HgW4,41996
 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
@@ -44,7 +44,7 @@ vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=dtO9A-rjbDEJ
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=8tSb8qGVoRIELubu0qPeoDlt1LpiIqc6d9_30GWRd_k,2266
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=z4oeTgKnMGVaGig8XOZm5B_xYL4H7zweYlFweCbhnyA,3000
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=9_AslWjzj4RHH2sq3SIaq9FU0NCg7ex5TIWrNMybqXg,2173
-vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=20tahU75zKImm6sAwLIYA9VEC6aNATjZdwA2beNnCIk,11949
+vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=muyLv3KMIsUnnXhiPbPhw5B0TO1Z8LUwytpVQKlz4tM,11906
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=qy_EtBIAHIhju68PA-skm-WbFnaNEuDoxkSMWRl2SpQ,5870
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=kwLqptup7bzYUDkGDbpcJPMMusMezsYrG5rSUYl5TlQ,3750
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=xMHaPfTSZWYprQenlHm2g47u0a5O9Me_dhAjfqo8nKQ,3116
@@ -58,6 +58,7 @@ vellum_ee/workflows/display/nodes/vellum/tests/__init__.py,sha256=47DEQpj8HBSa-_
 vellum_ee/workflows/display/nodes/vellum/tests/test_api_node.py,sha256=DQAtsabvn6BE6xWwKNHzMOppzoy1-1dssNnrwbHUdRU,1490
 vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py,sha256=oEH9myRn-NAP_mRstV0LifX3ncbmAOjCvyIVCZhACk0,10885
 vellum_ee/workflows/display/nodes/vellum/tests/test_error_node.py,sha256=540FoWMpJ3EN_DPjHsr9ODJWCRVcUa5hZBn-5T2GiHU,1665
+vellum_ee/workflows/display/nodes/vellum/tests/test_final_output_node.py,sha256=KVftEQxXARlcr-Uuo1ZK_wEHTcTH64OZJ3Ub3mN8x7I,3006
 vellum_ee/workflows/display/nodes/vellum/tests/test_inline_subworkflow_node.py,sha256=SKOYan-dxY4gsO0R4JyQUyWrABHBN8XImKw9Eeo4wGo,3535
 vellum_ee/workflows/display/nodes/vellum/tests/test_note_node.py,sha256=uiMB0cOxKZzos7YKnj4ef4DFa2bOvZJWIv-hfbUV6Go,1218
 vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_deployment_node.py,sha256=54oatuBB98Dfbr08NqZU8ZNhfQdJWhODIwjsegPPJJw,6376
@@ -98,17 +99,17 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=ddPa8gNBYH2tWk92ymngY7M8n74J-8CEre50HISP_-g,7877
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=A7Ef8P1-Nyvsb97bumKT9W2R1LuZaY9IKFV-7iRueog,4010
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_composio_serialization.py,sha256=oVXCjkU0G56QJmqnd_xIwF3D9bhJwALFibM2wmRhwUk,3739
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py,sha256=UD1HU8aEAXSo43JGhjBGE2FGsknHj_zOsIHTo2TLEW0,26470
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py,sha256=K7r5hivC3-599oqbkLgj5WMBcrix1znmuhAxs0w0EAE,26692
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_mcp_serialization.py,sha256=QhQbijeCnFeX1i3SMjHJg2WVAEt5JEO3dhFRv-mofdA,2458
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_parent_input.py,sha256=__LX4cuzbyZp_1wc-SI8X_J0tnhOkCEmRVUWLKI5aQM,4578
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=tyRlb6ozcsvkeHOC9dsHc4jg3HrHQITDGadi8qbNGns,10215
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=5yaoN5aM6VZZtsleQcSWpbNyWLE1nTnMF6KbLmCrlc8,10437
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py,sha256=XIZZr5POo2NLn2uEWm9EC3rejeBMoO4X-JtzTH6mvp4,4074
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=pLCyMScV88DTBXRH7jXaXOEA1GBq8NIipCUFwIAWnwI,2771
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=exT7U-axwtYgFylagScflSQLJEND51qIAx2UATju6JM,6023
 vellum_ee/workflows/display/tests/workflow_serialization/test_final_output_node_map_reference_serialization.py,sha256=vl3pxUJlrYRA8zzFJ-gRm7fe-5fviLNSIsUC7imnMqk,3502
 vellum_ee/workflows/display/tests/workflow_serialization/test_web_search_node_serialization.py,sha256=vbDFBrWUPeeW7cxjNA6SXrsHlYcbOAhlQ4C45Vdnr1c,3428
 vellum_ee/workflows/display/tests/workflow_serialization/test_workflow_input_parameterization_error.py,sha256=vAdmn3YTBDpo55znbydQxsgg9ASqHcvsUPwiBR_7wfo,1461
-vellum_ee/workflows/display/types.py,sha256=cyZruu4sXAdHjwuFc7dydM4DcFNf-pp_CmulXItxac4,3679
+vellum_ee/workflows/display/types.py,sha256=Yko3zPXRjkkPjpx3gCSdNNjegh3CQYsoXFoQWWiTxWU,3777
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/auto_layout.py,sha256=f4GiLn_LazweupfqTpubcdtdfE_vrOcmZudSsnYIY9E,3906
 vellum_ee/workflows/display/utils/events.py,sha256=DE33uoKW78BZtITJ6L22dMZN3KR1BuZBVC98C_gIyzU,1943
@@ -121,7 +122,7 @@ vellum_ee/workflows/display/utils/tests/test_events.py,sha256=42IEBnMbaQrH8gigw5
 vellum_ee/workflows/display/utils/vellum.py,sha256=sZwU0KdmZZTKWW62SyxJTl2tC8tN6p_BpZ-lDoinV-U,5670
 vellum_ee/workflows/display/vellum.py,sha256=J2mdJZ1sdLW535DDUkq_Vm8Z572vhuxHxVZF9deKSdk,391
 vellum_ee/workflows/display/workflows/__init__.py,sha256=JTB9ObEV3l4gGGdtfBHwVJtTTKC22uj-a-XjTVwXCyA,148
-vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=tlhtdNFT4_NJlBDkcn13CQOA49iy6d1F7kl5ONq21Rw,44032
+vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=x8HQK9AN2ql0_PFQAIilS4VEc_6h6Vd5tjhGYy7Hbs8,44329
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=gxz76AeCqgAZ9D2lZeTiZzxY9eMgn3qOSfVgiqYcOh8,2028
 vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=OKf_WVoPkYPrielOz8CyI5AjWt9MS2nSbWQKpF7HSLI,37847
 vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -155,7 +156,7 @@ vellum/client/README.md,sha256=flqu57ubZNTfpq60CdLtJC9gp4WEkyjb_n_eZ4OYf9w,6497
 vellum/client/__init__.py,sha256=T5Ht_w-Mk_9nzGqdadhQB8V20M0vYj7am06ut0A3P1o,73401
 vellum/client/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 vellum/client/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-vellum/client/core/client_wrapper.py,sha256=llxvaMOp54YJE6Vhu9cPaMURRdf9SIRPapzoEfyMqi0,2840
+vellum/client/core/client_wrapper.py,sha256=3LRRCUmekHH5eSClvUo_1GvPVridWvzGOYcx_DPDVZQ,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
@@ -1716,7 +1717,7 @@ vellum/utils/uuid.py,sha256=Ch6wWRgwICxLxJCTl5iE3EdRlZj2zADR-zUMUtjcMWM,214
 vellum/version.py,sha256=jq-1PlAYxN9AXuaZqbYk9ak27SgE2lw9Ia5gx1b1gVI,76
 vellum/workflows/README.md,sha256=hZdTKBIcsTKPofK68oPkBhyt0nnRh0csqC12k4FMHHA,3597
 vellum/workflows/__init__.py,sha256=gd5AiZqVTcvqelhysG0jOWYfC6pJKRAVhS7qwf0bHU4,132
-vellum/workflows/constants.py,sha256=xweiPRUSVEnGz9BJvpIWu96Gfok89QneARu4K7wj7f8,1358
+vellum/workflows/constants.py,sha256=ApFp3fm_DOuakvZV-c0ybieyVp-wELgHk-GTzDJoDCg,1429
 vellum/workflows/context.py,sha256=ViyIeMDhUv-MhnynLaXPlvlbYxRU45ySvYidCNSbFZU,2458
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/descriptors/base.py,sha256=fRnRkECyDjfz2QEDCY9Q5mAerlJ6jR0R4nE-MP2VP_k,16558
@@ -1726,8 +1727,8 @@ vellum/workflows/descriptors/utils.py,sha256=7QvS_IOZWIoKvhNwpYBOTP3NasLSIBKTnhy
 vellum/workflows/edges/__init__.py,sha256=wSkmAnz9xyi4vZwtDbKxwlplt2skD7n3NsxkvR_pUus,50
 vellum/workflows/edges/edge.py,sha256=N0SnY3gKVuxImPAdCbPMPlHJIXbkQ3fwq_LbJRvVMFc,677
 vellum/workflows/emitters/__init__.py,sha256=d9QFOI3eVg6rzpSFLvrjkDYXWikf1tcp3ruTRa2Boyc,143
-vellum/workflows/emitters/base.py,sha256=Tcp13VMB-GMwEJdl-6XTPckspdOdwpMgBx22-PcQxds,892
-vellum/workflows/emitters/vellum_emitter.py,sha256=ECBIRA48WS5rIJd1iWUfye7B5Up7ujL98BTlZwWALKs,4430
+vellum/workflows/emitters/base.py,sha256=4hClzI-ue0kWiEnZ1T1zvGz2ZWnoWLCVF-seqHBMUC8,1144
+vellum/workflows/emitters/vellum_emitter.py,sha256=T77LuU31TBU75GOFyrWuJWyW5RzRNNH1_PFWcgdWMg0,4788
 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
@@ -1795,7 +1796,7 @@ vellum/workflows/graph/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 vellum/workflows/graph/tests/test_graph.py,sha256=0Pov0sCsxjzUDL9wy7xy9jFD-F2GsMJnZVEVFXzQGdM,15433
 vellum/workflows/inputs/__init__.py,sha256=02pj0IbJkN1AxTreswK39cNi45tA8GWcAAdRJve4cuM,116
 vellum/workflows/inputs/base.py,sha256=4kCRVz8AOqL6NgWZlfsBMnmCeDGDCTU0ImyBLlB0oaE,5203
-vellum/workflows/inputs/dataset_row.py,sha256=T8lcn9qyC7IY0w3EIfnn4AwZ3pYw9sf4kdIi0VkX_Sw,1033
+vellum/workflows/inputs/dataset_row.py,sha256=Szdb_RKysCEBRfy4B5LoXoPiTZPEFp_0_RqRZUZRGbU,1076
 vellum/workflows/inputs/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/inputs/tests/test_inputs.py,sha256=lioA8917mFLYq7Ml69UNkqUjcWbbxkxnpIEJ4FBaYBk,2206
 vellum/workflows/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1805,7 +1806,7 @@ vellum/workflows/integrations/tests/test_mcp_service.py,sha256=q_DYrDkIqI4sQBNgI
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=zymtc3_iW2rFmMR-sayTLuN6ZsAw8VnJweWPsjQk2-Q,1197
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=i4tuPo_KyFI1ZJh__AI-oxRkDGch9pNTmOqt69HTcE0,20478
+vellum/workflows/nodes/bases/base.py,sha256=WWRHbCk9Xf6FzY82af7WwGasF_h6nQAjMXjDDzHTVOs,20821
 vellum/workflows/nodes/bases/base_adornment_node.py,sha256=hrgzuTetM4ynPd9YGHoK8Vwwn4XITi3aZZ_OCnQrq4Y,3433
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_adornment_node.py,sha256=fXZI9KqpS4XMBrBnIEkK3foHaBVvyHwYcQWWDKay7ic,1148
@@ -1843,9 +1844,9 @@ vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=cOYaIqimzDL6TuX
 vellum/workflows/nodes/displayable/bases/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/api_node/tests/test_node.py,sha256=5C59vn_yg4r5EWioKIr658Jr1MSGX3YF4yKJokY37Xc,4726
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
-vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=ea20icDM1HB942wkH-XtXNSNCBDcjeOiN3vowkHL4fs,4477
+vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=w02vgydiwNoKru324QLSkH3BiGUvHTgKbf05BEx945s,4657
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
-vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=eRhqxpkqcP5S4jx-vnnyHZvZAVQxKyCQ9kYxQCyWNvY,17921
+vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=ucbfX1HttsRDgngYnbS5MTytky-MAJW2ZkWgK4B-jI8,18600
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py,sha256=xc53wGwVqxBnN7eoyWkJ-RJ-FeUpHKekkKjViASHAFg,27495
 vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=H9mM75EQpP6PUvsXCTbwjw4CqMMLf36m1G2XqiPEvH4,12139
@@ -1865,9 +1866,9 @@ vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=71ZUNfTiD7t2Kai2ypw0tmv1lSf1brQaHAQD-SeUrGE,1101
 vellum/workflows/nodes/displayable/conftest.py,sha256=K2kLM2JGAfcrmmd92u8DXInUO5klFdggPWblg5RVcx4,5729
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
-vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=6SMaGeBlHQ5rdBq_AJ75bHUS4iizoT4Q9gEBVu6DWHM,2497
+vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=1_F9S7w-gIEUoXIdilgpqDeCKxJ0_J0oTYvE35dbjHk,4908
 vellum/workflows/nodes/displayable/final_output_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py,sha256=E6LQ74qZjY4Xi4avx2qdOCgGhF8pEcNLBh8cqYRkzMI,709
+vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py,sha256=FR7lWUJlcWW1e9q_3vefi-b8_LA7CayZgTWZAnlAiLg,2387
 vellum/workflows/nodes/displayable/guardrail_node/__init__.py,sha256=Ab5eXmOoBhyV4dMWdzh32HLUmnPIBEK_zFCT38C4Fng,68
 vellum/workflows/nodes/displayable/guardrail_node/node.py,sha256=axYUojar_kdB3gi4LG3g9euJ8VkOxNtiFxJNI46v-SQ,5869
 vellum/workflows/nodes/displayable/guardrail_node/test_node.py,sha256=SAGv6hSFcBwQkudn1VxtaKNsXSXWWELl3eK05zM6tS0,5410
@@ -1899,13 +1900,13 @@ 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=Bjv-wZyFgNaVZb9KEMMZd9lFoLzbPEPjEMpANizMZw4,2413
 vellum/workflows/nodes/displayable/tool_calling_node/__init__.py,sha256=3n0-ysmFKsr40CVxPthc0rfJgqVJeZuUEsCmYudLVRg,117
-vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=Exw0_5-bzphKF42pKwHF-tH25s8MD6wSbGcp7jZuBFg,8236
+vellum/workflows/nodes/displayable/tool_calling_node/node.py,sha256=WXpCYhZ_wlyF_q0T769fw6CI_6-I9kvTiy1yfBGXjvE,8414
 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_utils.py,sha256=SIu5GCj4tIE4fz-cAcdULtQfqZIhrcc3Doo6TWLXBws,8804
-vellum/workflows/nodes/displayable/tool_calling_node/utils.py,sha256=6XsvA77wF9MI6KBQNN1JMdpQwhK8pKUQtXgsPmq_I3Q,22837
+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=jqFpPDLZ463i2Lt7w_IN0fPypl1vrzZiYq2_1q9OyPo,22388
 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
@@ -1955,13 +1956,13 @@ vellum/workflows/state/store.py,sha256=uVe-oN73KwGV6M6YLhwZMMUQhzTQomsVfVnb8V91g
 vellum/workflows/state/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/state/tests/test_state.py,sha256=zEVFIY2any41X2BA5Us_qqKpzH5HRqmyrUJ04GTO0pU,7484
 vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/tests/test_dataset_row.py,sha256=qtz3cEcppCtr96co_8MmX4Jh1ro6bKZd_FGtRyFncRA,3370
+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/code_execution_node_wrappers.py,sha256=fewX9bqF_4TZuK-gZYIn12s31-k03vHMGRpvFAPm11Y,3206
-vellum/workflows/types/core.py,sha256=TggDVs2lVya33xvu374EDhMC1b7RRlAAs0zWLaF46BA,1385
-vellum/workflows/types/definition.py,sha256=727tDk-XzLAlpK2_OuPICz2VnFLW5WZd-WcZQrd2lvY,6854
+vellum/workflows/types/core.py,sha256=yKm3sE02ult969q80DTmawiwYqodVjcAW-zlaUIgIv4,1495
+vellum/workflows/types/definition.py,sha256=rVoiXhj7xcQS793qjt2gdv64ywfQrRvujURjIWeC6gA,7240
 vellum/workflows/types/generics.py,sha256=8jptbEx1fnJV0Lhj0MpCJOT6yNiEWeTOYOwrEAb5CRU,1576
 vellum/workflows/types/stack.py,sha256=h7NE0vXR7l9DevFBIzIAk1Zh59K-kECQtDTKOUunwMY,1314
 vellum/workflows/types/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1969,27 +1970,27 @@ vellum/workflows/types/tests/test_definition.py,sha256=rvDYjdJ1rvAv0qHBN7i7s-_WA
 vellum/workflows/types/tests/test_utils.py,sha256=UnZog59tR577mVwqZRqqWn2fScoOU1H6up0EzS8zYhw,2536
 vellum/workflows/types/utils.py,sha256=mTctHITBybpt4855x32oCKALBEcMNLn-9cCmfEKgJHQ,6498
 vellum/workflows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/functions.py,sha256=z1V_HujCZI-pfOLIEwkd0_ZeeR1MNqq3fvgDke62NRo,11016
+vellum/workflows/utils/functions.py,sha256=CmdyfICCs0ZWmdrRpX8oITHkYcDrGu61Rrd_pVwl6ks,12723
 vellum/workflows/utils/hmac.py,sha256=JJCczc6pyV6DuE1Oa0QVfYPUN_of3zEYmGFib3OZnrE,1135
 vellum/workflows/utils/names.py,sha256=QtHquoaGqRseu5gg2OcVGI2d_CMcEOvjb9KspwH4C-A,552
 vellum/workflows/utils/pydantic_schema.py,sha256=eR_bBtY-T0pttJP-ARwagSdCOnwPUtiT3cegm2lzDTQ,1310
 vellum/workflows/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/utils/tests/test_functions.py,sha256=TlNhD0OBJ-aeYn4qUqmApuajkx9sJx0lIQRMfT8Xf0w,23688
+vellum/workflows/utils/tests/test_functions.py,sha256=PClZVGKTx4zLJwDmMM-NpLjat2M64B8rq26Nu4MEEIM,23974
 vellum/workflows/utils/tests/test_names.py,sha256=DnRRnuORxQXx9ESegCzkxiWcHy2_bBi7lXgbFi3FZK8,757
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
 vellum/workflows/utils/tests/test_vellum_variables.py,sha256=X7b-bbN3bFRx0WG31bowcaOgsXxEPYnh2sgpsqgKIsQ,2096
 vellum/workflows/utils/uuids.py,sha256=IaZQANz7fhF7la0_J1O50Y6D2PIYv_taRDTRzBT9aWw,1284
 vellum/workflows/utils/vellum_variables.py,sha256=Tgv09yYROgq8QZbrKKIOEdg0IQ8Vfgz_vRjY4tYzaTQ,7152
 vellum/workflows/utils/zip.py,sha256=HVg_YZLmBOTXKaDV3Xhaf3V6sYnfqqZXQ8CpuafkbPY,1181
-vellum/workflows/vellum_client.py,sha256=xkfoucodxNK5JR2-lbRqZx3xzDgExWkP6kySrpi_Ubc,1079
+vellum/workflows/vellum_client.py,sha256=3iDR7VV_NgLSm1iZQCKDvrmfEaX1bOJiU15QrxyHpv0,1237
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=4_-kEebUBCn7d4N0TxF-sQejM2gAF8N6FbGabV2t6Pw,28346
+vellum/workflows/workflows/base.py,sha256=PvrsKCEGsnBzKalYymErGmdnYUNBs7pJ5NEOCKL90CY,28615
 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=ptMntHzVyy8ZuzNgeTuk7hREgKQ5UBdgq8VJFSGaW4Y,20832
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.4.1.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.4.1.dist-info/METADATA,sha256=le27kYJhHlVpQr0IVs13TF46G-7YTLPVPtVPQtHsANk,5547
-vellum_ai-1.4.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.4.1.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-1.4.1.dist-info/RECORD,,
+vellum_ai-1.4.2.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.4.2.dist-info/METADATA,sha256=2O0UVBAX-fWKzUzs1b8dWnKnfK2gpUNOTM1ZAz5alk0,5547
+vellum_ai-1.4.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.4.2.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-1.4.2.dist-info/RECORD,,

vellum_cli/tests/test_pull.py

@@ -1323,6 +1323,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have been updated with the correct workspace

vellum_cli/tests/test_push.py

@@ -721,6 +721,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have been updated with the correct workspace
@@ -882,6 +883,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have the same two workflows

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

@@ -163,9 +163,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         elif callable(function):
             normalized_functions = compile_function_definition(function)
         elif isinstance(function, DeploymentDefinition):
-            normalized_functions = compile_workflow_deployment_function_definition(
-                function.model_dump(), display_context.client
-            )
+            normalized_functions = compile_workflow_deployment_function_definition(function, display_context.client)
         else:
             raise ValueError(f"Unsupported function type: {type(function)}")
         return {

vellum_ee/workflows/display/nodes/vellum/tests/test_final_output_node.py

@@ -0,0 +1,78 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_final_output_node_display__serialize_with_valid_types():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with matching type to that node
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> CorrectOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = CorrectOutput.Outputs.value
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should succeed without raising validation errors
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # AND the node should be properly serialized
+    assert "workflow_raw_data" in serialized_workflow
+    assert "nodes" in serialized_workflow["workflow_raw_data"]
+
+    # Find the terminal node in the serialized output
+    terminal_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "TERMINAL"
+    )
+    assert terminal_node is not None
+    assert terminal_node["id"] == str(CorrectOutput.__id__)
+
+
+def test_final_output_node_display__serialize_with_invalid_types_should_raise_error():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with mismatched types (expects list but gets str)
+    class BadOutput(FinalOutputNode[BaseState, list]):
+        """Output with type mismatch."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result  # str type, conflicts with list
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> BadOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = BadOutput.Outputs.value
+
+    # WHEN we attempt to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should complete without raising an exception
+    serialized_workflow = workflow_display.serialize()
+
+    # AND the error should be captured in workflow_display.errors
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+    assert "Output type mismatch" in str(errors[0])
+    assert "list" in str(errors[0])
+    assert "str" in str(errors[0])
+
+    # AND the serialized workflow should still be created
+    assert "workflow_raw_data" in serialized_workflow

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -437,6 +437,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -206,6 +206,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/types.py

@@ -62,6 +62,9 @@ class WorkflowDisplayContext:
 
         raise error
 
+    def add_validation_error(self, error: Exception) -> None:
+        self._errors.append(error)
+
     def add_invalid_node(self, node: Type[BaseNode]) -> None:
         """Track a node that failed to serialize."""
         if node not in self._invalid_nodes:

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -196,6 +196,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             node_display = self.display_context.node_displays[node]
 
             try:
+                try:
+                    node.__validate__()
+                except ValueError as validation_error:
+                    # Only collect node validation errors directly to errors list, don't raise them
+                    self.display_context.add_validation_error(validation_error)
+
                 serialized_node = node_display.serialize(self.display_context)
             except (NotImplementedError, NodeValidationError) as e:
                 self.display_context.add_error(e)