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

vellum/workflows/events/tests/test_event.py

@@ -5,6 +5,10 @@ from uuid import UUID
 from deepdiff import DeepDiff
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types import (
+    NodeExecutionFulfilledEvent as ClientNodeExecutionFulfilledEvent,
+    WorkflowExecutionFulfilledEvent as ClientWorkflowExecutionFulfilledEvent,
+)
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events.exception_handling import stream_initialization_exception
@@ -13,6 +17,8 @@ from vellum.workflows.events.node import (
     NodeExecutionFulfilledEvent,
     NodeExecutionInitiatedBody,
     NodeExecutionInitiatedEvent,
+    NodeExecutionLogBody,
+    NodeExecutionLogEvent,
     NodeExecutionStreamingBody,
     NodeExecutionStreamingEvent,
 )
@@ -37,6 +43,7 @@ from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import VellumSecret
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.base import BaseWorkflow
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 class MockInputs(BaseInputs):
@@ -471,6 +478,41 @@ mock_node_uuid = str(MockNode.__id__)
                 "links": None,
             },
         ),
+        (
+            NodeExecutionLogEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionLogBody(
+                    node_definition=MockNode,
+                    attributes={"foo": "bar"},
+                    severity="INFO",
+                    message="Test log message",
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00Z",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.log",
+                "body": {
+                    "node_definition": {
+                        "id": mock_node_uuid,
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                        "exclude_from_monitoring": False,
+                    },
+                    "attributes": {"foo": "bar"},
+                    "severity": "INFO",
+                    "message": "Test log message",
+                },
+                "parent": None,
+                "links": None,
+            },
+        ),
     ],
     ids=[
         "workflow.execution.initiated",
@@ -483,6 +525,7 @@ mock_node_uuid = str(MockNode.__id__)
         "node.execution.fulfilled",
         "fulfilled_node_with_undefined_outputs",
         "mocked_node",
+        "node.execution.log",
     ],
 )
 def test_event_serialization(event, expected_json):
@@ -573,3 +616,83 @@ def test_node_execution_initiated_event_includes_exclude_from_monitoring():
     serialized = else_node_event.model_dump(mode="json")
     assert "exclude_from_monitoring" in serialized["body"]["node_definition"]
     assert serialized["body"]["node_definition"]["exclude_from_monitoring"] is True
+
+
+def test_event_max_size__outputs_redacted_when_exceeds_limit():
+    """
+    Tests that event outputs are redacted when serialized size exceeds event_max_size.
+    """
+
+    # GIVEN a workflow with a node
+    workflow = MockWorkflow()
+
+    # WHEN the workflow is streamed with a very small event_max_size
+    events = list(
+        workflow.stream(inputs=MockInputs(foo="bar"), event_filter=all_workflow_event_filter, event_max_size=10)
+    )
+
+    # THEN both node and workflow fulfilled events should have redacted outputs
+    node_fulfilled_events = [e for e in events if e.name == "node.execution.fulfilled"]
+    workflow_fulfilled_events = [e for e in events if e.name == "workflow.execution.fulfilled"]
+
+    assert len(node_fulfilled_events) > 0, "Expected at least one node fulfilled event"
+    assert len(workflow_fulfilled_events) == 1, "Expected exactly one workflow fulfilled event"
+
+    # AND the node fulfilled event outputs should be empty
+    node_serialized = node_fulfilled_events[0].model_dump(mode="json")
+    assert node_serialized["body"]["outputs"] == {}
+
+    # AND the serialized node event should be parseable by the client library
+    ClientNodeExecutionFulfilledEvent.model_validate(node_serialized)
+
+    # AND the workflow fulfilled event outputs should be empty
+    workflow_serialized = workflow_fulfilled_events[0].model_dump(mode="json")
+    assert workflow_serialized["body"]["outputs"] == {}
+
+    # AND the serialized workflow event should be parseable by the client library
+    ClientWorkflowExecutionFulfilledEvent.model_validate(workflow_serialized)
+
+
+def test_event_max_size__outputs_preserved_when_under_limit():
+    """
+    Tests that event outputs are preserved when serialized size is under event_max_size.
+    """
+
+    # GIVEN a workflow with a node that produces outputs
+    class OutputNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str = "hello world"
+
+    class OutputWorkflow(BaseWorkflow[MockInputs, BaseState]):
+        graph = OutputNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final = OutputNode.Outputs.result
+
+    workflow = OutputWorkflow()
+
+    # WHEN the workflow is streamed with a large event_max_size
+    events = list(
+        workflow.stream(inputs=MockInputs(foo="bar"), event_filter=all_workflow_event_filter, event_max_size=100000)
+    )
+
+    # THEN both node and workflow fulfilled events should have their outputs preserved
+    node_fulfilled_events = [e for e in events if e.name == "node.execution.fulfilled"]
+    workflow_fulfilled_events = [e for e in events if e.name == "workflow.execution.fulfilled"]
+
+    assert len(node_fulfilled_events) > 0, "Expected at least one node fulfilled event"
+    assert len(workflow_fulfilled_events) == 1, "Expected exactly one workflow fulfilled event"
+
+    # AND the node fulfilled event outputs should contain the result
+    node_serialized = node_fulfilled_events[0].model_dump(mode="json")
+    assert node_serialized["body"]["outputs"]["result"] == "hello world"
+
+    # AND the serialized node event should be parseable by the client library
+    ClientNodeExecutionFulfilledEvent.model_validate(node_serialized)
+
+    # AND the workflow fulfilled event outputs should contain the final output
+    workflow_serialized = workflow_fulfilled_events[0].model_dump(mode="json")
+    assert workflow_serialized["body"]["outputs"]["final"] == "hello world"
+
+    # AND the serialized workflow event should be parseable by the client library
+    ClientWorkflowExecutionFulfilledEvent.model_validate(workflow_serialized)

vellum/workflows/events/types.py

@@ -3,7 +3,7 @@ import json
 from uuid import UUID, uuid4
 from typing import Annotated, Any, List, Literal, Optional, Union, get_args
 
-from pydantic import Field, GetCoreSchemaHandler, Tag, ValidationInfo
+from pydantic import Field, GetCoreSchemaHandler, PrivateAttr, Tag, ValidationInfo
 from pydantic_core import CoreSchema, core_schema
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
@@ -186,3 +186,4 @@ class BaseEvent(UniversalBaseModel):
     span_id: UUID
     parent: Optional[ParentContext] = None
     links: Optional[List[SpanLink]] = None
+    _event_max_size: Optional[int] = PrivateAttr(default=None)

vellum/workflows/events/workflow.py

@@ -1,11 +1,13 @@
+import json
 import logging
 from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Literal, Optional, Type, Union, cast
 from typing_extensions import TypeGuard
 
-from pydantic import SerializationInfo, field_serializer, field_validator
+from pydantic import Field, SerializationInfo, field_serializer, field_validator, model_serializer
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.utils.json_encoder import VellumJsonEncoder
 from vellum.workflows.errors import WorkflowError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
@@ -16,6 +18,7 @@ from ..triggers import BaseTrigger
 from .node import (
     NodeExecutionFulfilledEvent,
     NodeExecutionInitiatedEvent,
+    NodeExecutionLogEvent,
     NodeExecutionPausedEvent,
     NodeExecutionRejectedEvent,
     NodeExecutionResumedEvent,
@@ -111,9 +114,17 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsT
 
     trigger: Optional[Type[BaseTrigger]] = None
 
+    # Raw inputs from trigger event data, used to include trigger attributes in serialized inputs.
+    # This field is excluded from serialization and only used to merge into the inputs field.
+    raw_inputs: Optional[Dict[str, Any]] = Field(default=None, exclude=True)
+
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
-        return default_serializer(inputs)
+        serialized = default_serializer(inputs)
+        # Merge raw_inputs (trigger event data) with serialized inputs
+        if self.raw_inputs:
+            return {**self.raw_inputs, **serialized}
+        return serialized
 
     @field_serializer("initial_state")
     def serialize_initial_state(self, initial_state: Optional[StateType], _info: Any) -> Optional[Dict[str, Any]]:
@@ -203,6 +214,20 @@ class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType, S
             WorkflowExecutionFulfilledBody[OutputsType, StateType], _serialize_body_with_enricher(self, body, info)
         )
 
+    @model_serializer(mode="plain", when_used="json")
+    def serialize_model(self, info: SerializationInfo) -> Dict[str, Any]:
+        serialized = super().serialize_model(info)
+
+        if (
+            self._event_max_size is not None
+            and len(json.dumps(serialized, cls=VellumJsonEncoder)) > self._event_max_size
+            and "body" in serialized
+            and isinstance(serialized["body"], dict)
+        ):
+            serialized["body"]["outputs"] = {}
+
+        return serialized
+
 
 class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
     error: WorkflowError
@@ -287,6 +312,7 @@ GenericWorkflowEvent = Union[
     NodeExecutionRejectedEvent,
     NodeExecutionPausedEvent,
     NodeExecutionResumedEvent,
+    NodeExecutionLogEvent,
 ]
 
 WorkflowEvent = Union[

vellum/workflows/expressions/add.py

@@ -38,4 +38,7 @@ class AddExpression(BaseDescriptor[Any], Generic[LHS, RHS]):
         if not has_add(lhs):
             raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '+' operator")
 
+        if isinstance(lhs, list) and not isinstance(rhs, list):
+            return lhs + [rhs]
+
         return lhs + rhs

vellum/workflows/expressions/tests/test_add.py

@@ -70,3 +70,27 @@ def test_add_expression_types():
     expression = AddExpression(lhs=5, rhs=3)
 
     assert expression.types == (object,)
+
+
+def test_add_expression_list_plus_non_list():
+    """
+    Tests that AddExpression correctly handles list + non-list by wrapping non-list in a list.
+    This allows State.chat_history + ChatMessage(...) to work.
+    """
+
+    state = TestState()
+
+    # GIVEN a list and a non-list value
+    my_list = [1, 2, 3]
+    single_item = 4
+
+    # WHEN we create an AddExpression and resolve it
+    expression = AddExpression(lhs=my_list, rhs=single_item)
+    result = expression.resolve(state)
+
+    # THEN the result should be the list with the item appended
+    assert result == [1, 2, 3, 4]
+    assert isinstance(result, list)
+
+    # AND the original list should be unchanged
+    assert my_list == [1, 2, 3]

vellum/workflows/graph/graph.py

@@ -81,12 +81,16 @@ class Graph:
         entrypoints = set()
         edges = OrderedSet[Edge]()
         terminals = set()
+        trigger_edges: List[TriggerEdge] = []
 
         for target in targets:
             if isinstance(target, Graph):
                 entrypoints.update(target._entrypoints)
                 edges.update(target._edges)
                 terminals.update(target._terminals)
+                for trigger_edge in target._trigger_edges:
+                    if trigger_edge not in trigger_edges:
+                        trigger_edges.append(trigger_edge)
             elif hasattr(target, "Ports"):
                 entrypoints.update({port for port in target.Ports})
                 terminals.update({port for port in target.Ports})
@@ -95,11 +99,14 @@ class Graph:
                 entrypoints.update({target})
                 terminals.update({target})
 
-        return Graph(entrypoints=entrypoints, edges=list(edges), terminals=terminals)
+        return Graph(entrypoints=entrypoints, edges=list(edges), terminals=terminals, trigger_edges=trigger_edges)
 
     @staticmethod
     def from_edge(edge: Edge) -> "Graph":
-        return Graph(entrypoints={edge.from_port}, edges=[edge], terminals={port for port in edge.to_node.Ports})
+        terminals: Set[Union["Port", "NoPortsNode"]] = {port for port in edge.to_node.Ports}
+        if not terminals:
+            terminals = {NoPortsNode(edge.to_node)}
+        return Graph(entrypoints={edge.from_port}, edges=[edge], terminals=terminals)
 
     @staticmethod
     def from_trigger_edge(edge: TriggerEdge) -> "Graph":
@@ -166,6 +173,7 @@ class Graph:
 
     def __rshift__(self, other: GraphTarget) -> "Graph":
         # Check for trigger target (class-level only)
+        from vellum.workflows.nodes.bases.base import BaseNode
         from vellum.workflows.triggers.base import BaseTrigger
 
         if isinstance(other, type) and issubclass(other, BaseTrigger):
@@ -197,13 +205,16 @@ class Graph:
                         midgraph = final_output_node >> set(elem.entrypoints)
                         self._extend_edges(midgraph.edges)
                         self._extend_edges(elem.edges)
+                        self._extend_trigger_edges(elem._trigger_edges)
                         for other_terminal in elem._terminals:
                             new_terminals.add(other_terminal)
                     elif hasattr(elem, "Ports"):
                         midgraph = final_output_node >> elem
                         self._extend_edges(midgraph.edges)
-                        for other_terminal in elem.Ports:
-                            new_terminals.add(other_terminal)
+                        other_ports = {port for port in elem.Ports}
+                        if isinstance(elem, type) and issubclass(elem, BaseNode) and not other_ports:
+                            other_ports = {NoPortsNode(elem)}
+                        new_terminals.update(other_ports)
                     else:
                         # elem is a Port
                         midgraph = final_output_node >> elem
@@ -219,6 +230,7 @@ class Graph:
                 midgraph = final_output_node >> set(other.entrypoints)
                 self._extend_edges(midgraph.edges)
                 self._extend_edges(other.edges)
+            self._extend_trigger_edges(other._trigger_edges)
             self._terminals = other._terminals
             return self
 
@@ -228,7 +240,11 @@ class Graph:
                     continue
                 subgraph = final_output_node >> other
                 self._extend_edges(subgraph.edges)
-            self._terminals = {port for port in other.Ports}
+
+            other_ports = {port for port in other.Ports}
+            if isinstance(other, type) and issubclass(other, BaseNode) and not other_ports:
+                other_ports = {NoPortsNode(other)}
+            self._terminals = other_ports
             return self
 
         # other is a Port
@@ -298,6 +314,11 @@ class Graph:
             if edge not in self._edges:
                 self._edges.append(edge)
 
+    def _extend_trigger_edges(self, trigger_edges: List[TriggerEdge]) -> None:
+        for trigger_edge in trigger_edges:
+            if trigger_edge not in self._trigger_edges:
+                self._trigger_edges.append(trigger_edge)
+
     def __str__(self) -> str:
         """
         Return a visual ASCII representation of the graph showing the flow structure.

vellum/workflows/graph/tests/test_graph.py

@@ -1,10 +1,14 @@
 import pytest
+from typing import Type
 
 from vellum.workflows.edges.edge import Edge
-from vellum.workflows.graph.graph import Graph
+from vellum.workflows.graph.graph import Graph, NoPortsNode
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
 from vellum.workflows.ports.port import Port
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.triggers import ManualTrigger
+from vellum.workflows.triggers.schedule import ScheduleTrigger
 
 
 def test_graph__empty():
@@ -784,3 +788,226 @@ def test_graph__trigger_then_graph_then_node():
     # AND the graph has both nodes
     nodes = list(graph.nodes)
     assert len(nodes) == 2
+
+
+def test_graph__set_of_trigger_graphs_preserves_trigger_edges():
+    """Test that combining graphs with triggers via a set preserves trigger edges.
+
+    This tests the fix for Graph.from_set() not propagating _trigger_edges.
+    """
+
+    # GIVEN a custom scheduled trigger
+    class MyScheduledTrigger(ScheduleTrigger):
+        class Config:
+            cron = "0 9 * * *"
+
+    # AND two trigger-initiated graphs
+    class MyFirstNode(BaseNode):
+        pass
+
+    class MySecondNode(BaseNode):
+        pass
+
+    trigger_graph_a = MyScheduledTrigger >> MyFirstNode
+    trigger_graph_b = MyScheduledTrigger >> MySecondNode
+
+    # WHEN we combine them in a set
+    combined_graph = Graph.from_set({trigger_graph_a, trigger_graph_b})
+
+    # THEN the combined graph has both trigger edges
+    trigger_edges = list(combined_graph.trigger_edges)
+    assert len(trigger_edges) == 2
+
+    # AND both edges point to the correct nodes
+    target_nodes = {edge.to_node for edge in trigger_edges}
+    assert target_nodes == {MyFirstNode, MySecondNode}
+
+    # AND the graph exposes the trigger
+    triggers = list(combined_graph.triggers)
+    assert len(triggers) == 1
+    assert triggers[0] == MyScheduledTrigger
+
+
+def test_graph__set_of_trigger_graphs_to_node_preserves_trigger_edges():
+    # GIVEN a custom scheduled trigger
+    class MyScheduledTrigger(ScheduleTrigger):
+        class Config:
+            cron = "0 9 * * *"
+
+    # AND two trigger-initiated graphs
+    class MyFirstNode(BaseNode):
+        pass
+
+    class MySecondNode(BaseNode):
+        pass
+
+    class MyThirdNode(BaseNode):
+        pass
+
+    trigger_graph_a = MyScheduledTrigger >> MyFirstNode
+    trigger_graph_b = MyScheduledTrigger >> MySecondNode
+
+    # WHEN we combine them in a set and connect to another node
+    combined_graph = {trigger_graph_a, trigger_graph_b} >> MyThirdNode
+
+    # THEN the combined graph has both trigger edges
+    trigger_edges = list(combined_graph.trigger_edges)
+    assert len(trigger_edges) == 2
+
+    # AND both trigger edges point to the correct initial nodes
+    trigger_target_nodes = {edge.to_node for edge in trigger_edges}
+    assert trigger_target_nodes == {MyFirstNode, MySecondNode}
+
+    # AND the graph has regular edges to the third node
+    regular_edges = list(combined_graph.edges)
+    assert len(regular_edges) == 2
+    assert all(edge.to_node == MyThirdNode for edge in regular_edges)
+
+    # AND the graph has all three nodes
+    nodes = list(combined_graph.nodes)
+    assert len(nodes) == 3
+    assert set(nodes) == {MyFirstNode, MySecondNode, MyThirdNode}
+
+
+def test_graph__graph_rshift_graph_preserves_trigger_edges():
+    """Test that Graph >> Graph preserves trigger edges from the right-hand graph."""
+
+    # GIVEN a regular graph and a trigger-initiated graph
+    class StartNode(BaseNode):
+        pass
+
+    class TriggerNode(BaseNode):
+        pass
+
+    class EndNode(BaseNode):
+        pass
+
+    regular_graph = StartNode >> TriggerNode
+    trigger_graph = ManualTrigger >> EndNode
+
+    # WHEN we combine them with >>
+    combined = regular_graph >> trigger_graph
+
+    # THEN the combined graph has the trigger edge
+    trigger_edges = list(combined.trigger_edges)
+    assert len(trigger_edges) == 1
+    assert trigger_edges[0].to_node == EndNode
+
+    # AND the graph exposes the trigger
+    triggers = list(combined.triggers)
+    assert len(triggers) == 1
+
+
+def test_graph__graph_rshift_set_of_trigger_graphs_preserves_trigger_edges():
+    """Test that Graph >> {TriggerGraph1, TriggerGraph2} preserves trigger edges."""
+
+    # GIVEN a regular graph and two trigger-initiated graphs
+    class StartNode(BaseNode):
+        pass
+
+    class TriggerNodeA(BaseNode):
+        pass
+
+    class TriggerNodeB(BaseNode):
+        pass
+
+    regular_graph = Graph.from_node(StartNode)
+    trigger_graph_a = ManualTrigger >> TriggerNodeA
+    trigger_graph_b = ManualTrigger >> TriggerNodeB
+
+    # WHEN we combine them with >> and a set
+    combined = regular_graph >> {trigger_graph_a, trigger_graph_b}
+
+    # THEN the combined graph has both trigger edges
+    trigger_edges = list(combined.trigger_edges)
+    assert len(trigger_edges) == 2
+
+    # AND both trigger edges point to the correct nodes
+    trigger_target_nodes = {edge.to_node for edge in trigger_edges}
+    assert trigger_target_nodes == {TriggerNodeA, TriggerNodeB}
+
+
+class TestFinalOutputNoPortsNode:
+    """Test that we preserve final output nodes as NoPortsNode when constructing a Graph."""
+
+    def validate_graph(self, graph: Graph, final_output_node: Type[FinalOutputNode]):
+        assert len(list(graph._terminals)) == 1
+        node = list(graph._terminals)[0]
+        assert isinstance(node, NoPortsNode)
+        assert node.node_class == final_output_node
+
+    def test_from_edge(self):
+        # GIVEN
+        class StartNode(BaseNode[BaseState]):
+            pass
+
+        class MyFinalOutput(FinalOutputNode[BaseState, str]):
+            pass
+
+        # WHEN
+        edge = Edge(from_port=StartNode.Ports.default, to_node=MyFinalOutput)
+        graph = Graph.from_edge(edge)
+
+        # THEN
+        self.validate_graph(graph, MyFinalOutput)
+
+    def test_rshift__node(self):
+        # GIVEN
+        class StartNode(BaseNode[BaseState]):
+            pass
+
+        class MyFinalOutput(FinalOutputNode[BaseState, str]):
+            pass
+
+        # WHEN
+        initial_graph = Graph.from_node(StartNode)
+        graph = initial_graph >> MyFinalOutput
+
+        # THEN
+        self.validate_graph(graph, MyFinalOutput)
+
+    def test_rshift__graph(self):
+        # GIVEN
+        class StartNode(BaseNode[BaseState]):
+            pass
+
+        class MyFinalOutput(FinalOutputNode[BaseState, str]):
+            pass
+
+        # WHEN
+        subgraph = Graph.from_node(MyFinalOutput)
+        graph = Graph.from_node(StartNode) >> subgraph
+
+        # THEN
+        self.validate_graph(subgraph, MyFinalOutput)
+        self.validate_graph(graph, MyFinalOutput)
+
+    def test_rshift__set_with_node(self):
+        # GIVEN
+        class StartNode(BaseNode[BaseState]):
+            pass
+
+        class MyFinalOutput(FinalOutputNode[BaseState, str]):
+            pass
+
+        # WHEN
+        graph = Graph.from_node(StartNode) >> {MyFinalOutput}
+
+        # THEN
+        self.validate_graph(graph, MyFinalOutput)
+
+    def test_rshift__set_with_graph(self):
+        # GIVEN
+        class StartNode(BaseNode[BaseState]):
+            pass
+
+        class MyFinalOutput(FinalOutputNode[BaseState, str]):
+            pass
+
+        # WHEN
+        subgraph = Graph.from_node(MyFinalOutput)
+        graph = Graph.from_node(StartNode) >> {subgraph}
+
+        # THEN
+        self.validate_graph(subgraph, MyFinalOutput)
+        self.validate_graph(graph, MyFinalOutput)

vellum/workflows/inputs/base.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Iterator, Set, Tuple, Type, Union, get_args, get_origin
+from typing import Any, Callable, Dict, Iterator, Set, Tuple, Type, Union, cast, get_args, get_origin
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler
@@ -10,7 +10,7 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.references import ExternalInputReference, WorkflowInputReference
 from vellum.workflows.references.input import InputReference
-from vellum.workflows.types.utils import get_class_attr_names, infer_types
+from vellum.workflows.types.utils import coerce_to_declared_type, get_class_attr_names, infer_types
 
 
 @dataclass_transform(kw_only_default=True)
@@ -97,8 +97,7 @@ class BaseInputs(metaclass=_BaseInputsMeta):
                 # Check if default is a FieldInfo with default_factory
                 if isinstance(default_value, FieldInfo):
                     if default_value.default_factory is not None:
-                        # Call the factory function to create a new instance
-                        value = default_value.default_factory()  # type: ignore[call-arg]
+                        value = cast(Callable[[], Any], default_value.default_factory)()
                     elif hasattr(default_value, "default") and default_value.default is not ...:
                         # Use the default value directly
                         value = default_value.default
@@ -114,7 +113,7 @@ class BaseInputs(metaclass=_BaseInputsMeta):
             if value is undefined and not has_default:
                 # All fields without defaults must be provided, even if Optional
                 raise WorkflowInitializationException(
-                    message=f"Required input variables {name} should have defined value",
+                    message=f"Required input variables '{name}' should have defined value",
                     code=WorkflowErrorCode.INVALID_INPUTS,
                     workflow_definition=self.__class__.__parent_class__,
                 )
@@ -122,13 +121,30 @@ class BaseInputs(metaclass=_BaseInputsMeta):
             # Validate that None is not provided for non-Optional fields
             if value is None and not is_optional:
                 raise WorkflowInitializationException(
-                    message=f"Required input variables {name} should have defined value",
+                    message=f"Required input variables '{name}' should have defined value",
                     code=WorkflowErrorCode.INVALID_INPUTS,
                     workflow_definition=self.__class__.__parent_class__,
                 )
 
             # Set the value on the instance (either from kwargs or default)
             if value is not undefined:
+                # Coerce the value to the declared type if needed
+                # For Optional types, extract the non-None type for coercion
+                coercion_type = field_type
+                if is_optional:
+                    non_none_args = [arg for arg in args if arg is not type(None)]
+                    if len(non_none_args) == 1:
+                        coercion_type = non_none_args[0]
+
+                try:
+                    value = coerce_to_declared_type(value, coercion_type, name)
+                except ValueError as e:
+                    raise WorkflowInitializationException(
+                        message=str(e),
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                        workflow_definition=self.__class__.__parent_class__,
+                    )
+
                 setattr(self, name, value)
 
     def __iter__(self) -> Iterator[Tuple[InputReference, Any]]: