vellum-ai 1.11.2__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum/workflows/inputs/dataset_row.py

@@ -1,8 +1,11 @@
-from typing import Any, Dict, List, Optional, Sequence, Type, Union
+from datetime import datetime
+import warnings
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
-from pydantic import Field, field_serializer
+from pydantic import ConfigDict, Field, SerializationInfo, field_serializer, model_serializer, model_validator
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.utils.files.mixin import VellumFileMixin
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.mocks import MockNodeExecution
 from vellum.workflows.outputs.base import BaseOutputs
@@ -18,23 +21,107 @@ class DatasetRow(UniversalBaseModel):
         id: Optional unique identifier for the dataset row
         label: String label for the dataset row
         inputs: BaseInputs instance or dict containing the input data
-        workflow_trigger_id: Optional Trigger identifying the workflow trigger class for this scenario
-        node_output_mocks: Optional sequence of node output mocks for testing scenarios
+        workflow_trigger: Optional Trigger instance for this scenario
+        mocks: Optional sequence of node output mocks for testing scenarios
     """
 
+    model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True)
+
     id: Optional[str] = None
     label: str
     inputs: Union[BaseInputs, Dict[str, Any]] = Field(default_factory=BaseInputs)
-    workflow_trigger: Optional[Type[BaseTrigger]] = None
-    node_output_mocks: Optional[Sequence[Union[BaseOutputs, MockNodeExecution]]] = None
+    workflow_trigger: Optional[BaseTrigger] = None
+    mocks: Optional[Sequence[Union[BaseOutputs, MockNodeExecution]]] = None
+    # DEPRECATED: node_output_mocks - use mocks instead. Remove in v2.0.0
+    node_output_mocks: Optional[Sequence[Union[BaseOutputs, MockNodeExecution]]] = Field(
+        default=None,
+        exclude=True,  # Don't include in serialized output
+    )
+
+    @model_validator(mode="after")
+    def _handle_deprecated_node_output_mocks(self) -> "DatasetRow":
+        """Handle deprecated node_output_mocks field by mapping it to mocks."""
+        if self.node_output_mocks is not None:
+            warnings.warn(
+                "The 'node_output_mocks' parameter is deprecated and will be removed in v2.0.0. "
+                "Please use 'mocks' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            # If mocks is not set, use node_output_mocks value
+            if self.mocks is None:
+                object.__setattr__(self, "mocks", self.node_output_mocks)
+        return self
+
+    @model_serializer(mode="wrap")
+    def serialize_full_model(self, handler: Callable[[Any], Any], info: SerializationInfo) -> Dict[str, Any]:
+        """Serialize the model and add node_id field computed from then_outputs."""
+        serialized = handler(self)
+        if not isinstance(serialized, dict):
+            return serialized
+
+        # Add deprecation error if node_output_mocks was used - remove in v2.0.0
+        if self.node_output_mocks is not None:
+            add_error = info.context.get("add_error") if info.context else None
+            if add_error is not None:
+                add_error(
+                    Exception(
+                        f'Dataset row "{self.label}": "node_output_mocks" is deprecated. '
+                        'Please use "mocks" instead. This will be removed in v2.0.0.'
+                    )
+                )
+
+        if "mocks" in serialized and serialized.get("mocks") is None:
+            serialized.pop("mocks")
+
+        if "workflow_trigger" in serialized:
+            value = serialized.pop("workflow_trigger")
+            if value is not None:
+                serialized["workflow_trigger_id"] = value
+
+        # Merge trigger attribute values into inputs if workflow_trigger is present
+        if self.workflow_trigger is not None:
+            trigger_attrs = self.workflow_trigger.to_trigger_attribute_values()
+            for ref, attr_value in trigger_attrs.items():
+                # Convert datetime objects to ISO format strings for JSON serialization
+                if isinstance(attr_value, datetime):
+                    attr_value = attr_value.isoformat()
+                serialized["inputs"][ref.name] = attr_value
+
+        if "id" in serialized and serialized.get("id") is None:
+            serialized.pop("id")
+
+        return serialized
+
+    @field_serializer("workflow_trigger")
+    def serialize_workflow_trigger(self, workflow_trigger: Optional[BaseTrigger]) -> Optional[str]:
+        """
+        Custom serializer for workflow_trigger that converts it to a string ID.
+
+        Args:
+            workflow_trigger: Optional workflow trigger instance
+
+        Returns:
+            String representation of the trigger ID, or None if no trigger
+        """
+        if workflow_trigger is None:
+            return None
+
+        return str(workflow_trigger.__class__.__id__)
 
     @field_serializer("inputs")
-    def serialize_inputs(self, inputs: Union[BaseInputs, Dict[str, Any]]) -> Dict[str, Any]:
+    def serialize_inputs(self, inputs: Union[BaseInputs, Dict[str, Any]], info: SerializationInfo) -> Dict[str, Any]:
         """
         Custom serializer for inputs that converts it to a dictionary.
 
+        When add_error is provided in the serialization context, this method will
+        validate file-type inputs (VellumFileMixin) by attempting to serialize them,
+        and collect errors for fields that fail to serialize while still including
+        valid fields.
+
         Args:
             inputs: Either a BaseInputs instance or dict to serialize
+            info: Serialization info containing context
 
         Returns:
             Dictionary representation of the inputs
@@ -43,31 +130,49 @@ class DatasetRow(UniversalBaseModel):
             return inputs
 
         result = {}
+        add_error = info.context.get("add_error") if info.context else None
+
         for input_descriptor, value in inputs:
-            if not input_descriptor.name.startswith("__"):
+            if input_descriptor.name.startswith("__"):
+                continue
+
+            # For file types, validate by attempting to serialize and catch errors
+            if add_error is not None and isinstance(value, VellumFileMixin):
+                try:
+                    # Trigger validation by serializing the file type
+                    value.model_dump(mode="json", by_alias=True, exclude_none=True)
+                    result[input_descriptor.name] = value
+                except Exception as field_error:
+                    error_msg = (
+                        f'Dataset row "{self.label}": input "{input_descriptor.name}" '
+                        f"failed serialization: {field_error}"
+                    )
+                    add_error(Exception(error_msg))
+            else:
                 result[input_descriptor.name] = value
 
         return result
 
-    @field_serializer("node_output_mocks")
-    def serialize_node_output_mocks(
-        self, node_output_mocks: Optional[Sequence[Union[BaseOutputs, MockNodeExecution]]]
+    @field_serializer("mocks")
+    def serialize_mocks(
+        self, mocks: Optional[Sequence[Union[BaseOutputs, MockNodeExecution]]], info
     ) -> Optional[List[Dict[str, Any]]]:
         """
-        Custom serializer for node_output_mocks that normalizes both BaseOutputs and MockNodeExecution
+        Custom serializer for mocks that normalizes both BaseOutputs and MockNodeExecution
         to a consistent dict format with node_id, when_condition, and then_outputs.
 
         Args:
-            node_output_mocks: Optional sequence of BaseOutputs or MockNodeExecution instances
+            mocks: Optional sequence of BaseOutputs or MockNodeExecution instances
+            info: Serialization info containing context
 
         Returns:
             List of normalized mock execution dicts, or None if input is None
         """
-        if node_output_mocks is None:
+        if mocks is None:
             return None
 
         result = []
-        for mock in node_output_mocks:
+        for mock in mocks:
             if isinstance(mock, MockNodeExecution):
                 mock_exec = mock
             else:
@@ -76,6 +181,6 @@ class DatasetRow(UniversalBaseModel):
                     then_outputs=mock,
                 )
 
-            result.append(mock_exec.model_dump())
+            result.append(mock_exec.model_dump(context=info.context))
 
         return result

vellum/workflows/inputs/tests/test_inputs.py

@@ -54,7 +54,7 @@ def test_base_inputs_explicit_none_should_raise_on_fields_without_defaults(field
         TestInputs()  # type: ignore[call-arg]
 
     assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
-    assert "Required input variables required_string should have defined value" == str(exc_info.value)
+    assert "Required input variables 'required_string' should have defined value" == str(exc_info.value)
 
 
 def test_base_inputs_explicit_none_should_raise_on_required_fields_with_none():
@@ -69,7 +69,7 @@ def test_base_inputs_explicit_none_should_raise_on_required_fields_with_none():
         TestInputs(required_string=None)  # type: ignore[arg-type]
 
     assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
-    assert "Required input variables required_string should have defined value" == str(exc_info.value)
+    assert "Required input variables 'required_string' should have defined value" == str(exc_info.value)
 
 
 def test_base_inputs_empty_value():
@@ -84,7 +84,7 @@ def test_base_inputs_empty_value():
 
     # THEN it should raise a NodeException with the correct error message and code
     assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
-    assert "Required input variables required_string should have defined value" == str(exc_info.value)
+    assert "Required input variables 'required_string' should have defined value" == str(exc_info.value)
 
 
 def test_base_inputs_with_default():

vellum/workflows/integrations/tests/test_vellum_integration_service.py

@@ -33,6 +33,7 @@ def test_vellum_integration_service_get_tool_definition_success(vellum_client):
             "required": ["repo", "title"],
         },
         output_parameters={},
+        toolkit_version="1.0.0",
     )
     mock_client.integrations.retrieve_integration_tool_definition.return_value = tool_definition_response
 
@@ -61,6 +62,55 @@ def test_vellum_integration_service_get_tool_definition_success(vellum_client):
         integration_name="GITHUB",
         integration_provider="COMPOSIO",
         tool_name="GITHUB_CREATE_AN_ISSUE",
+        toolkit_version=None,
+    )
+
+
+def test_vellum_integration_service_get_tool_definition_with_toolkit_version(vellum_client):
+    """Test that toolkit_version is passed through when retrieving tool definitions"""
+    # GIVEN a mock client configured to return a tool definition
+    mock_client = vellum_client
+    tool_definition_response = ComponentsSchemasComposioToolDefinition(
+        integration=Integration(
+            id=str(uuid4()),
+            provider="COMPOSIO",
+            name="GITHUB",
+        ),
+        label="GITHUB_CREATE_AN_ISSUE",
+        name="GITHUB_CREATE_AN_ISSUE",
+        description="Create a new issue in a GitHub repository",
+        input_parameters={
+            "type": "object",
+            "properties": {
+                "repo": {"type": "string", "description": "Repository name"},
+            },
+            "required": ["repo"],
+        },
+        output_parameters={},
+        toolkit_version="2.0.0",
+    )
+    mock_client.integrations.retrieve_integration_tool_definition.return_value = tool_definition_response
+
+    # WHEN we request a tool definition with a specific toolkit_version
+    service = VellumIntegrationService(client=mock_client)
+    result = service.get_tool_definition(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+        toolkit_version="2.0.0",
+    )
+
+    # THEN the tool definition should be returned with the toolkit_version preserved
+    assert isinstance(result, VellumIntegrationToolDetails)
+    assert result.name == "GITHUB_CREATE_AN_ISSUE"
+    assert result.toolkit_version == "2.0.0"
+
+    # AND the API should have been called with the toolkit_version parameter
+    mock_client.integrations.retrieve_integration_tool_definition.assert_called_once_with(
+        integration_name="GITHUB",
+        integration_provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+        toolkit_version="2.0.0",
     )
 
 
@@ -128,6 +178,40 @@ def test_vellum_integration_service_execute_tool_success(vellum_client):
             "title": "Test Issue",
             "body": "Test body",
         },
+        toolkit_version=None,
+    )
+
+
+def test_vellum_integration_service_execute_tool_with_toolkit_version(vellum_client):
+    """Test that toolkit_version is passed through when executing tools"""
+    # GIVEN a mock client configured to return a successful response
+    mock_client = vellum_client
+    mock_client.integrations = mock.MagicMock()
+
+    mock_response = mock.MagicMock()
+    mock_response.data = {"success": True, "result": "executed with version"}
+    mock_client.integrations.execute_integration_tool.return_value = mock_response
+
+    # WHEN we execute a tool with a specific toolkit_version
+    service = VellumIntegrationService(client=mock_client)
+    result = service.execute_tool(
+        integration="GITHUB",
+        provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+        arguments={"repo": "user/repo"},
+        toolkit_version="2.0.0",
+    )
+
+    # THEN the execution result should contain expected data
+    assert result["success"] is True
+
+    # AND the API should have been called with the toolkit_version parameter
+    mock_client.integrations.execute_integration_tool.assert_called_once_with(
+        integration_name="GITHUB",
+        integration_provider="COMPOSIO",
+        tool_name="GITHUB_CREATE_AN_ISSUE",
+        arguments={"repo": "user/repo"},
+        toolkit_version="2.0.0",
     )
 
 

vellum/workflows/integrations/vellum_integration_service.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from vellum.client.core.api_error import ApiError
 from vellum.workflows.constants import VellumIntegrationProviderType
@@ -25,6 +25,7 @@ class VellumIntegrationService:
         integration: str,
         provider: str,
         tool_name: str,
+        toolkit_version: Optional[str] = None,
     ) -> VellumIntegrationToolDetails:
         """Retrieve a tool definition from Vellum integrations.
 
@@ -32,6 +33,9 @@ class VellumIntegrationService:
             integration: The integration name (e.g., "GITHUB", "SLACK")
             provider: The integration provider name (e.g., "COMPOSIO")
             tool_name: The tool's unique name as specified by the provider
+            toolkit_version: The version of the toolkit to use. Pass 'latest' to get the
+                latest version, or a specific version string to pin it. If not provided,
+                uses the provider's default.
 
         Returns:
             VellumIntegrationToolDetails containing the tool definition with parameters
@@ -44,6 +48,7 @@ class VellumIntegrationService:
                 integration_name=integration,
                 integration_provider=provider,
                 tool_name=tool_name,
+                toolkit_version=toolkit_version,
             )
 
             return VellumIntegrationToolDetails(
@@ -52,6 +57,7 @@ class VellumIntegrationService:
                 name=response.name,
                 description=response.description,
                 parameters=response.input_parameters,
+                toolkit_version=response.toolkit_version,
             )
         except Exception as e:
             error_message = f"Failed to retrieve tool definition for {tool_name}: {str(e)}"
@@ -66,6 +72,7 @@ class VellumIntegrationService:
         provider: str,
         tool_name: str,
         arguments: Dict[str, Any],
+        toolkit_version: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Execute a tool through Vellum integrations.
 
@@ -74,6 +81,9 @@ class VellumIntegrationService:
             provider: The integration provider name (e.g., "COMPOSIO")
             tool_name: The tool's unique name as specified by the provider
             arguments: Arguments to pass to the tool
+            toolkit_version: The version of the toolkit to use. Pass 'latest' to get the
+                latest version, or a specific version string to pin it. If not provided,
+                uses the provider's default.
 
         Returns:
             Dict containing the execution result data
@@ -88,6 +98,7 @@ class VellumIntegrationService:
                 integration_provider=provider,
                 tool_name=tool_name,
                 arguments=arguments,
+                toolkit_version=toolkit_version,
             )
 
             # Return the data from the response

vellum/workflows/loaders/base.py

@@ -9,6 +9,8 @@ class BaseWorkflowFinder(importlib.abc.MetaPathFinder, ABC):
     Abstract base class for workflow finders that support custom error message formatting.
     """
 
+    namespace: str
+
     @abstractmethod
     def format_error_message(self, error_message: str) -> str:
         """

vellum/workflows/nodes/bases/base.py

@@ -1,4 +1,4 @@
-from abc import ABC, ABCMeta, abstractmethod
+from abc import ABC, ABCMeta
 from collections.abc import Callable as CollectionsCallable
 from dataclasses import field
 from functools import cached_property, reduce
@@ -46,7 +46,7 @@ from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_class_attr_names, get_original_base, infer_types
-from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.uuids import generate_entity_id_from_path, uuid4_from_hash
 
 
 def _is_nested_class(nested: Any, parent: Type) -> bool:
@@ -115,7 +115,21 @@ class BaseNodeMeta(ABCMeta):
                     dct["Ports"] = type(f"{name}.Ports", (base.Ports,), ports_dct)
                     break
 
-        if "Display" not in dct:
+        if "Display" in dct:
+            display_class = dct["Display"]
+            parent_display_class = next(
+                (base.Display for base in bases if hasattr(base, "Display")),
+                None,
+            )
+            # Ensure user-defined Display class inherits from parent's Display
+            if parent_display_class and not issubclass(display_class, parent_display_class):
+                filtered_bases = tuple(base for base in display_class.__bases__ if base is not object)
+                dct["Display"] = type(
+                    f"{name}.Display",
+                    (parent_display_class,) + filtered_bases,
+                    {**display_class.__dict__, "__module__": dct["__module__"]},
+                )
+        else:
             for base in reversed(bases):
                 if issubclass(base, BaseNode):
                     dct["Display"] = type(
@@ -159,7 +173,8 @@ class BaseNodeMeta(ABCMeta):
         node_class.ExternalInputs.__parent_class__ = node_class
 
         # Use new ID generation (module + qualname)
-        node_class.__id__ = uuid4_from_hash(f"{node_class.__module__}.{node_class.__qualname__}")
+        # generate_entity_id_from_path normalizes the module path to filter out UUID namespace for stable ID generation
+        node_class.__id__ = generate_entity_id_from_path(f"{node_class.__module__}.{node_class.__qualname__}")
 
         node_class.__output_ids__ = {
             ref.name: uuid4_from_hash(f"{node_class.__id__}|{ref.name}")
@@ -247,17 +262,6 @@ 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:
@@ -325,6 +329,9 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
 
         icon: Optional[str] = None
         color: Optional[str] = None
+        x: Optional[float] = None
+        y: Optional[float] = None
+        z_index: Optional[int] = None
 
     class Trigger(metaclass=_BaseNodeTriggerMeta):
         node_class: Type["BaseNode"]
@@ -383,8 +390,11 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
                 all_deps_invoked = all(dep in node_classes_invoked for dep in dependencies)
                 return all_deps_invoked
 
+            if cls.merge_behavior == MergeBehavior.CUSTOM:
+                return False
+
             raise NodeException(
-                message="Invalid Trigger Node Specification",
+                message=f"Invalid Trigger Node Specification: {cls.merge_behavior}",
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
@@ -571,3 +581,14 @@ class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
         """
 
         return False
+
+    @classmethod
+    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

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

@@ -1,11 +1,13 @@
 import pytest
 from uuid import UUID
-from typing import Optional, Set
+from typing import Any, Dict, Optional, Set
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
+from vellum.workflows import BaseWorkflow
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.tests.test_utils import FixtureState
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import FinalOutputNode
 from vellum.workflows.nodes.bases.base import BaseNode
@@ -15,6 +17,7 @@ from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 def test_base_node__node_resolution__unset_pydantic_fields():
@@ -379,3 +382,103 @@ def test_base_node__ports_inheritance__cumulative_ports():
     # Potentially in the future, we support inheriting ports from multiple parents.
     # For now, we take only the declared ports, so that not all nodes have the default port.
     assert ports == ["bar"]
+
+
+def test_base_node__trigger_should_initiate__invalid_merge_behavior():
+    """
+    Tests that an invalid merge behavior raises a NodeException with the invalid value in the error message.
+    """
+
+    # GIVEN a node with an invalid merge behavior
+    class InvalidMergeBehaviorNode(BaseNode):
+        class Trigger(BaseNode.Trigger):
+            merge_behavior = "INVALID_MERGE_BEHAVIOR"  # type: ignore[assignment]
+
+    # AND a workflow that uses the node
+    class InvalidMergeBehaviorWorkflow(BaseWorkflow):
+        graph = InvalidMergeBehaviorNode
+
+    # WHEN we stream the workflow
+    workflow = InvalidMergeBehaviorWorkflow()
+    events = list(workflow.stream(event_filter=all_workflow_event_filter))
+
+    # THEN the workflow should reject
+    workflow_rejected_event = events[-1]
+    assert workflow_rejected_event.name == "workflow.execution.rejected"
+
+    # AND the error should have the correct code
+    assert workflow_rejected_event.error.code == WorkflowErrorCode.INVALID_INPUTS
+
+    # AND the error message should contain the invalid merge behavior
+    assert "INVALID_MERGE_BEHAVIOR" in workflow_rejected_event.error.message
+
+
+def test_base_node__int_input_preserves_type_when_float_passed():
+    """
+    Tests that an int workflow input is correctly coerced to int when a float value is passed.
+    """
+
+    # GIVEN an Inputs class with an int field
+    class Inputs(BaseInputs):
+        total_requests: int
+
+    # AND a custom node that references the int input
+    class CustomNode(BaseNode):
+        total_requests = Inputs.total_requests
+
+        class Outputs(BaseOutputs):
+            result: int
+
+        def run(self) -> BaseOutputs:
+            # This should work without error - range() requires an int, not a float
+            result = len(range(self.total_requests))
+            return self.Outputs(result=result)
+
+    # AND a workflow that uses the custom node
+    class IntInputWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = CustomNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = CustomNode.Outputs.result
+
+    # WHEN we run the workflow with a float value for an int input
+    # This simulates what happens when the API returns a NUMBER value as a float
+    workflow = IntInputWorkflow()
+    raw_inputs: Dict[str, Any] = {"total_requests": 5.0}
+    inputs = Inputs(**raw_inputs)
+
+    # THEN the input should be coerced to an integer at construction time
+    assert inputs.total_requests == 5
+    assert type(inputs.total_requests) is int
+
+    # AND the workflow should complete successfully
+    final_event = workflow.run(inputs=inputs)
+    assert final_event.name == "workflow.execution.fulfilled"
+
+    # AND the result should be correct
+    assert final_event.outputs.result == 5
+
+
+def test_base_node__bytes_output_raises_serialization_error():
+    """Test that returning bytes in node outputs rejects the workflow execution."""
+
+    class BytesOutputNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+        def run(self) -> "BytesOutputNode.Outputs":
+            b = b"hello"
+            return self.Outputs(result=b)  # type: ignore[arg-type]
+
+    class BytesWorkflow(BaseWorkflow):
+        graph = BytesOutputNode
+
+    workflow = BytesWorkflow()
+
+    # WHEN we run the workflow
+    result = workflow.run()
+
+    # THEN the execution is rejected with a helpful error
+    assert result.name == "workflow.execution.rejected"
+    assert result.error.code == WorkflowErrorCode.INVALID_OUTPUTS
+    assert "bytes" in result.error.message.lower()

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

@@ -84,6 +84,7 @@ class InlineSubworkflowNode(
                 event_filter=all_workflow_event_filter,
                 node_output_mocks=self._context._get_all_node_output_mocks(),
                 cancel_signal=self._child_cancel_signal,
+                event_max_size=self._context.event_max_size,
             )
 
         outputs: Optional[BaseOutputs] = None

vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -116,7 +116,7 @@ def test_inline_subworkflow_node__base_inputs_validation():
 
     # AND the error message should indicate the missing required input
     assert e.value.code == WorkflowErrorCode.INVALID_INPUTS
-    assert "Required input variables required_input should have defined value" == str(e.value)
+    assert "Required input variables 'required_input' should have defined value" == str(e.value)
 
 
 def test_inline_subworkflow_node__with_adornment():