vellum-ai 0.14.38__py3-none-any.whl → 0.14.40__py3-none-any.whl

vellum/workflows/runner/runner.py

@@ -4,11 +4,11 @@ from dataclasses import dataclass
 import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
-from uuid import UUID
+from uuid import UUID, uuid4
 from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Iterator, Optional, Sequence, Set, Tuple, Type, Union
 
 from vellum.workflows.constants import undefined
-from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context, get_parent_context
+from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
@@ -30,7 +30,7 @@ from vellum.workflows.events.node import (
     NodeExecutionRejectedBody,
     NodeExecutionStreamingBody,
 )
-from vellum.workflows.events.types import BaseEvent, NodeParentContext, WorkflowParentContext
+from vellum.workflows.events.types import BaseEvent, NodeParentContext, ParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
     WorkflowExecutionFulfilledBody,
     WorkflowExecutionInitiatedBody,
@@ -90,6 +90,7 @@ class WorkflowRunner(Generic[StateType]):
 
         self.workflow = workflow
         self._is_resuming = False
+        self._should_emit_initial_state = True
         if entrypoint_nodes:
             if len(list(entrypoint_nodes)) > 1:
                 raise ValueError("Cannot resume from multiple nodes")
@@ -98,7 +99,8 @@ class WorkflowRunner(Generic[StateType]):
             # https://app.shortcut.com/vellum/story/4408
             node = next(iter(entrypoint_nodes))
             if state:
-                self._initial_state = state
+                self._initial_state = deepcopy(state)
+                self._initial_state.meta.span_id = uuid4()
             else:
                 self._initial_state = self.workflow.get_state_at_node(node)
             self._entrypoints = entrypoint_nodes
@@ -123,8 +125,13 @@ class WorkflowRunner(Generic[StateType]):
             if state:
                 self._initial_state = deepcopy(state)
                 self._initial_state.meta.workflow_inputs = normalized_inputs
+                self._initial_state.meta.span_id = uuid4()
             else:
                 self._initial_state = self.workflow.get_default_state(normalized_inputs)
+                # We don't want to emit the initial state on the base case of Workflow Runs, since
+                # all of that data is redundant and is derivable. It also clearly communicates that
+                # there was no initial state provided by the user to invoke the workflow.
+                self._should_emit_initial_state = False
             self._entrypoints = self.workflow.get_entrypoints()
 
         # This queue is responsible for sending events from WorkflowRunner to the outside world
@@ -239,7 +246,8 @@ class WorkflowRunner(Generic[StateType]):
                         instance=None,
                         outputs_class=node.Outputs,
                     )
-                    node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
+                    with node.state.__quiet__():
+                        node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
                     initiated_output: BaseOutput = BaseOutput(name=output.name)
                     initiated_ports = initiated_output > ports
                     self._workflow_event_inner_queue.put(
@@ -297,13 +305,14 @@ class WorkflowRunner(Generic[StateType]):
 
             node.state.meta.node_execution_cache.fulfill_node_execution(node.__class__, span_id)
 
-            for descriptor, output_value in outputs:
-                if output_value is undefined:
-                    if descriptor in node.state.meta.node_outputs:
-                        del node.state.meta.node_outputs[descriptor]
-                    continue
+            with node.state.__atomic__():
+                for descriptor, output_value in outputs:
+                    if output_value is undefined:
+                        if descriptor in node.state.meta.node_outputs:
+                            del node.state.meta.node_outputs[descriptor]
+                        continue
 
-                node.state.meta.node_outputs[descriptor] = output_value
+                    node.state.meta.node_outputs[descriptor] = output_value
 
             invoked_ports = ports(outputs, node.state)
             self._workflow_event_inner_queue.put(
@@ -365,11 +374,16 @@ class WorkflowRunner(Generic[StateType]):
 
         logger.debug(f"Finished running node: {node.__class__.__name__}")
 
-    def _context_run_work_item(self, node: BaseNode[StateType], span_id: UUID, parent_context=None) -> None:
-        execution = get_execution_context()
+    def _context_run_work_item(
+        self,
+        node: BaseNode[StateType],
+        span_id: UUID,
+        parent_context: ParentContext,
+        trace_id: UUID,
+    ) -> None:
         with execution_context(
-            parent_context=parent_context or execution.parent_context,
-            trace_id=execution.trace_id,
+            parent_context=parent_context,
+            trace_id=trace_id,
         ):
             self._run_work_item(node, span_id)
 
@@ -419,14 +433,19 @@ class WorkflowRunner(Generic[StateType]):
             if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
                 return
 
-            current_parent = get_parent_context()
+            execution = get_execution_context()
             node = node_class(state=state, context=self.workflow.context)
             state.meta.node_execution_cache.initiate_node_execution(node_class, node_span_id)
             self._active_nodes_by_execution_id[node_span_id] = ActiveNode(node=node)
 
             worker_thread = Thread(
                 target=self._context_run_work_item,
-                kwargs={"node": node, "span_id": node_span_id, "parent_context": current_parent},
+                kwargs={
+                    "node": node,
+                    "span_id": node_span_id,
+                    "parent_context": execution.parent_context,
+                    "trace_id": execution.trace_id,
+                },
             )
             worker_thread.start()
 
@@ -500,6 +519,7 @@ class WorkflowRunner(Generic[StateType]):
             body=WorkflowExecutionInitiatedBody(
                 workflow_definition=self.workflow.__class__,
                 inputs=self._initial_state.meta.workflow_inputs,
+                initial_state=deepcopy(self._initial_state) if self._should_emit_initial_state else None,
             ),
             parent=self._execution_context.parent_context,
         )

vellum/workflows/state/base.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from contextlib import contextmanager
 from copy import deepcopy
 from dataclasses import field
 from datetime import datetime
@@ -6,13 +7,14 @@ import logging
 from queue import Queue
 from threading import Lock
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, cast
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union, cast
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler, ValidationInfo, field_serializer, field_validator
 from pydantic_core import core_schema
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.constants import undefined
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.inputs.base import BaseInputs
@@ -108,18 +110,30 @@ class NodeExecutionCache:
         self._node_executions_queued = defaultdict(list)
 
     @classmethod
-    def deserialize(cls, raw_data: dict, nodes: Dict[str, Type["BaseNode"]]):
+    def deserialize(cls, raw_data: dict, nodes: Dict[Union[str, UUID], Type["BaseNode"]]):
         cache = cls()
 
+        def get_node_class(node_id: Any) -> Optional[Type["BaseNode"]]:
+            if not isinstance(node_id, str):
+                return None
+
+            if is_valid_uuid(node_id):
+                return nodes.get(UUID(node_id))
+
+            return nodes.get(node_id)
+
         dependencies_invoked = raw_data.get("dependencies_invoked")
         if isinstance(dependencies_invoked, dict):
             for execution_id, dependencies in dependencies_invoked.items():
-                cache._dependencies_invoked[UUID(execution_id)] = {nodes[dep] for dep in dependencies if dep in nodes}
+                dependency_classes = {get_node_class(dep) for dep in dependencies}
+                cache._dependencies_invoked[UUID(execution_id)] = {
+                    dep_class for dep_class in dependency_classes if dep_class is not None
+                }
 
         node_executions_fulfilled = raw_data.get("node_executions_fulfilled")
         if isinstance(node_executions_fulfilled, dict):
             for node, execution_ids in node_executions_fulfilled.items():
-                node_class = nodes.get(node)
+                node_class = get_node_class(node)
                 if not node_class:
                     continue
 
@@ -130,7 +144,7 @@ class NodeExecutionCache:
         node_executions_initiated = raw_data.get("node_executions_initiated")
         if isinstance(node_executions_initiated, dict):
             for node, execution_ids in node_executions_initiated.items():
-                node_class = nodes.get(node)
+                node_class = get_node_class(node)
                 if not node_class:
                     continue
 
@@ -141,7 +155,7 @@ class NodeExecutionCache:
         node_executions_queued = raw_data.get("node_executions_queued")
         if isinstance(node_executions_queued, dict):
             for node, execution_ids in node_executions_queued.items():
-                node_class = nodes.get(node)
+                node_class = get_node_class(node)
                 if not node_class:
                     continue
 
@@ -192,17 +206,18 @@ class NodeExecutionCache:
     def dump(self) -> Dict[str, Any]:
         return {
             "dependencies_invoked": {
-                str(execution_id): [str(dep) for dep in dependencies]
+                str(execution_id): [str(dep.__id__) for dep in dependencies]
                 for execution_id, dependencies in self._dependencies_invoked.items()
             },
             "node_executions_initiated": {
-                str(node): list(execution_ids) for node, execution_ids in self._node_executions_initiated.items()
+                str(node.__id__): list(execution_ids) for node, execution_ids in self._node_executions_initiated.items()
             },
             "node_executions_fulfilled": {
-                str(node): execution_ids.dump() for node, execution_ids in self._node_executions_fulfilled.items()
+                str(node.__id__): execution_ids.dump()
+                for node, execution_ids in self._node_executions_fulfilled.items()
             },
             "node_executions_queued": {
-                str(node): execution_ids for node, execution_ids in self._node_executions_queued.items()
+                str(node.__id__): execution_ids for node, execution_ids in self._node_executions_queued.items()
             },
         }
 
@@ -278,7 +293,7 @@ class StateMeta(UniversalBaseModel):
 
     @field_serializer("node_outputs")
     def serialize_node_outputs(self, node_outputs: Dict[OutputReference, Any], _info: Any) -> Dict[str, Any]:
-        return {str(descriptor): value for descriptor, value in node_outputs.items()}
+        return {str(descriptor.id): value for descriptor, value in node_outputs.items()}
 
     @field_validator("node_outputs", mode="before")
     @classmethod
@@ -289,15 +304,22 @@ class StateMeta(UniversalBaseModel):
                 return node_outputs
 
             raw_workflow_nodes = workflow_definition.get_nodes()
-            workflow_node_outputs = {}
+            workflow_node_outputs: Dict[Union[str, UUID], OutputReference] = {}
             for node in raw_workflow_nodes:
                 for output in node.Outputs:
                     workflow_node_outputs[str(output)] = output
+                    output_id = node.__output_ids__.get(output.name)
+                    if output_id:
+                        workflow_node_outputs[output_id] = output
 
             node_output_keys = list(node_outputs.keys())
             deserialized_node_outputs = {}
             for node_output_key in node_output_keys:
-                output_reference = workflow_node_outputs.get(node_output_key)
+                if is_valid_uuid(node_output_key):
+                    output_reference = workflow_node_outputs.get(UUID(node_output_key))
+                else:
+                    output_reference = workflow_node_outputs.get(node_output_key)
+
                 if not output_reference:
                     continue
 
@@ -315,10 +337,11 @@ class StateMeta(UniversalBaseModel):
             if not workflow_definition:
                 return node_execution_cache
 
-            nodes_cache: Dict[str, Type["BaseNode"]] = {}
+            nodes_cache: Dict[Union[str, UUID], Type["BaseNode"]] = {}
             raw_workflow_nodes = workflow_definition.get_nodes()
             for node in raw_workflow_nodes:
                 nodes_cache[str(node)] = node
+                nodes_cache[node.__id__] = node
 
             return NodeExecutionCache.deserialize(node_execution_cache, nodes_cache)
 
@@ -404,11 +427,11 @@ class BaseState(metaclass=_BaseStateMeta):
     meta: StateMeta = field(init=False)
 
     __lock__: Lock = field(init=False)
-    __is_initializing__: bool = field(init=False)
+    __is_quiet__: bool = field(init=False)
     __snapshot_callback__: Callable[["BaseState"], None] = field(init=False)
 
     def __init__(self, meta: Optional[StateMeta] = None, **kwargs: Any) -> None:
-        self.__is_initializing__ = True
+        self.__is_quiet__ = True
         self.__snapshot_callback__ = lambda state: None
         self.__lock__ = Lock()
 
@@ -418,14 +441,14 @@ class BaseState(metaclass=_BaseStateMeta):
         # Make all class attribute values snapshottable
         for name, value in self.__class__.__dict__.items():
             if not name.startswith("_") and name != "meta":
-                # Bypass __is_initializing__ instead of `setattr`
+                # Bypass __is_quiet__ instead of `setattr`
                 snapshottable_value = _make_snapshottable(value, self.__snapshot__)
                 super().__setattr__(name, snapshottable_value)
 
         for name, value in kwargs.items():
             setattr(self, name, value)
 
-        self.__is_initializing__ = False
+        self.__is_quiet__ = False
 
     def __deepcopy__(self, memo: Any) -> "BaseState":
         new_state = deepcopy_with_exclusions(
@@ -472,7 +495,7 @@ class BaseState(metaclass=_BaseStateMeta):
         return self.__dict__[key]
 
     def __setattr__(self, name: str, value: Any) -> None:
-        if name.startswith("_") or self.__is_initializing__:
+        if name.startswith("_"):
             super().__setattr__(name, value)
             return
 
@@ -513,11 +536,33 @@ class BaseState(metaclass=_BaseStateMeta):
         Snapshots the current state to the workflow emitter. The invoked callback is overridden by the
         workflow runner.
         """
+        if self.__is_quiet__:
+            return
+
         try:
             self.__snapshot_callback__(deepcopy(self))
         except Exception:
             logger.exception("Failed to snapshot Workflow state.")
 
+    @contextmanager
+    def __quiet__(self):
+        prev = self.__is_quiet__
+        self.__is_quiet__ = True
+        try:
+            yield
+        finally:
+            self.__is_quiet__ = prev
+
+    @contextmanager
+    def __atomic__(self):
+        prev = self.__is_quiet__
+        self.__is_quiet__ = True
+        try:
+            yield
+        finally:
+            self.__is_quiet__ = prev
+            self.__snapshot__()
+
     @classmethod
     def __get_pydantic_core_schema__(
         cls, source_type: Type[Any], handler: GetCoreSchemaHandler

vellum/workflows/state/tests/test_state.py

@@ -1,17 +1,14 @@
 import pytest
-from collections import defaultdict
 from copy import deepcopy
 import json
 from queue import Queue
-from typing import Dict
+from typing import Dict, cast
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 
-snapshot_count: Dict[int, int] = defaultdict(int)
-
 
 @pytest.fixture()
 def mock_deepcopy(mocker):
@@ -27,9 +24,19 @@ class MockState(BaseState):
     foo: str
     nested_dict: Dict[str, int] = {}
 
-    def __snapshot__(self) -> None:
-        global snapshot_count
-        snapshot_count[id(self)] += 1
+    __snapshot_count__: int = 0
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.__snapshot_callback__ = lambda _: self.__mock_snapshot__()
+
+    def __mock_snapshot__(self) -> None:
+        self.__snapshot_count__ += 1
+
+    def __deepcopy__(self, memo: dict) -> "MockState":
+        new_state = cast(MockState, super().__deepcopy__(memo))
+        new_state.__snapshot_count__ = 0
+        return new_state
 
 
 class MockNode(BaseNode):
@@ -40,53 +47,56 @@ class MockNode(BaseNode):
         baz: str
 
 
+MOCK_NODE_OUTPUT_ID = "e4dc3136-0c27-4bda-b3ab-ea355d5219d6"
+
+
 def test_state_snapshot__node_attribute_edit():
     # GIVEN an initial state instance
     state = MockState(foo="bar")
-    assert snapshot_count[id(state)] == 0
+    assert state.__snapshot_count__ == 0
 
     # WHEN we edit an attribute
     state.foo = "baz"
 
     # THEN the snapshot is emitted
-    assert snapshot_count[id(state)] == 1
+    assert state.__snapshot_count__ == 1
 
 
 def test_state_snapshot__node_output_edit():
     # GIVEN an initial state instance
     state = MockState(foo="bar")
-    assert snapshot_count[id(state)] == 0
+    assert state.__snapshot_count__ == 0
 
     # WHEN we add a Node Output to state
     for output in MockNode.Outputs:
         state.meta.node_outputs[output] = "hello"
 
     # THEN the snapshot is emitted
-    assert snapshot_count[id(state)] == 1
+    assert state.__snapshot_count__ == 1
 
 
 def test_state_snapshot__nested_dictionary_edit():
     # GIVEN an initial state instance
     state = MockState(foo="bar")
-    assert snapshot_count[id(state)] == 0
+    assert state.__snapshot_count__ == 0
 
     # WHEN we edit a nested dictionary
     state.nested_dict["hello"] = 1
 
     # THEN the snapshot is emitted
-    assert snapshot_count[id(state)] == 1
+    assert state.__snapshot_count__ == 1
 
 
 def test_state_snapshot__external_input_edit():
     # GIVEN an initial state instance
     state = MockState(foo="bar")
-    assert snapshot_count[id(state)] == 0
+    assert state.__snapshot_count__ == 0
 
     # WHEN we add an external input to state
     state.meta.external_inputs[MockNode.ExternalInputs.message] = "hello"
 
     # THEN the snapshot is emitted
-    assert snapshot_count[id(state)] == 1
+    assert state.__snapshot_count__ == 1
 
 
 def test_state_deepcopy():
@@ -103,7 +113,6 @@ def test_state_deepcopy():
     assert deepcopied_state.meta.node_outputs == state.meta.node_outputs
 
 
-@pytest.mark.skip(reason="https://app.shortcut.com/vellum/story/5654")
 def test_state_deepcopy__with_node_output_updates():
     # GIVEN an initial state instance
     state = MockState(foo="bar")
@@ -121,10 +130,10 @@ def test_state_deepcopy__with_node_output_updates():
     assert deepcopied_state.meta.node_outputs[MockNode.Outputs.baz] == "hello"
 
     # AND the original state has had the correct number of snapshots
-    assert snapshot_count[id(state)] == 2
+    assert state.__snapshot_count__ == 2
 
     # AND the copied state has had the correct number of snapshots
-    assert snapshot_count[id(deepcopied_state)] == 0
+    assert deepcopied_state.__snapshot_count__ == 0
 
 
 def test_state_json_serialization__with_node_output_updates():
@@ -138,7 +147,7 @@ def test_state_json_serialization__with_node_output_updates():
     json_state = json.loads(json.dumps(state, cls=DefaultStateEncoder))
 
     # THEN the state is serialized correctly
-    assert json_state["meta"]["node_outputs"] == {"MockNode.Outputs.baz": "hello"}
+    assert json_state["meta"]["node_outputs"] == {MOCK_NODE_OUTPUT_ID: "hello"}
 
 
 def test_state_deepcopy__with_external_input_updates():
@@ -158,10 +167,10 @@ def test_state_deepcopy__with_external_input_updates():
     assert deepcopied_state.meta.external_inputs[MockNode.ExternalInputs.message] == "hello"
 
     # AND the original state has had the correct number of snapshots
-    assert snapshot_count[id(state)] == 2
+    assert state.__snapshot_count__ == 2
 
     # AND the copied state has had the correct number of snapshots
-    assert snapshot_count[id(deepcopied_state)] == 0
+    assert deepcopied_state.__snapshot_count__ == 0
 
 
 def test_state_json_serialization__with_queue():
@@ -179,7 +188,7 @@ def test_state_json_serialization__with_queue():
     json_state = json.loads(json.dumps(state, cls=DefaultStateEncoder))
 
     # THEN the state is serialized correctly with the queue turned into a list
-    assert json_state["meta"]["node_outputs"] == {"MockNode.Outputs.baz": ["test1", "test2"]}
+    assert json_state["meta"]["node_outputs"] == {MOCK_NODE_OUTPUT_ID: ["test1", "test2"]}
 
 
 def test_state_snapshot__deepcopy_fails__logs_error(mock_deepcopy, mock_logger):

vellum/workflows/types/stack.py

@@ -37,3 +37,14 @@ class Stack(Generic[_T]):
 
     def dump(self) -> List[_T]:
         return [item for item in self._items][::-1]
+
+    @classmethod
+    def from_list(cls, items: List[_T]) -> "Stack[_T]":
+        stack = cls()
+        stack.extend(items)
+        return stack
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Stack):
+            return False
+        return self._items == other._items

vellum/workflows/workflows/base.py

@@ -80,6 +80,11 @@ class _BaseWorkflowMeta(type):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         if "graph" not in dct:
             dct["graph"] = set()
+            for base in bases:
+                base_graph = getattr(base, "graph", None)
+                if base_graph:
+                    dct["graph"] = base_graph
+                    break
 
         if "Outputs" in dct:
             outputs_class = dct["Outputs"]
@@ -146,7 +151,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
 
     WorkflowEvent = Union[  # type: ignore
         GenericWorkflowEvent,
-        WorkflowExecutionInitiatedEvent[InputsType],  # type: ignore[valid-type]
+        WorkflowExecutionInitiatedEvent[InputsType, StateType],  # type: ignore[valid-type]
         WorkflowExecutionFulfilledEvent[Outputs],
         WorkflowExecutionSnapshottedEvent[StateType],  # type: ignore[valid-type]
     ]
@@ -335,7 +340,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
 
         if not last_event:
             return WorkflowExecutionRejectedEvent(
-                trace_id=uuid4(),
+                trace_id=self._execution_context.trace_id,
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
                     error=WorkflowError(
@@ -348,7 +353,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
 
         if not first_event:
             return WorkflowExecutionRejectedEvent(
-                trace_id=uuid4(),
+                trace_id=self._execution_context.trace_id,
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
                     error=WorkflowError(
@@ -367,7 +372,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
             return last_event
 
         return WorkflowExecutionRejectedEvent(
-            trace_id=first_event.trace_id,
+            trace_id=self._execution_context.trace_id,
             span_id=first_event.span_id,
             body=WorkflowExecutionRejectedBody(
                 workflow_definition=self.__class__,
@@ -482,21 +487,11 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         return self.get_inputs_class()()
 
     def get_default_state(self, workflow_inputs: Optional[InputsType] = None) -> StateType:
-        execution_context = self._execution_context
         return self.get_state_class()(
-            meta=(
-                StateMeta(
-                    parent=self._parent_state,
-                    workflow_inputs=workflow_inputs or self.get_default_inputs(),
-                    trace_id=execution_context.trace_id,
-                    workflow_definition=self.__class__,
-                )
-                if execution_context and int(execution_context.trace_id)
-                else StateMeta(
-                    parent=self._parent_state,
-                    workflow_inputs=workflow_inputs or self.get_default_inputs(),
-                    workflow_definition=self.__class__,
-                )
+            meta=StateMeta(
+                parent=self._parent_state,
+                workflow_inputs=workflow_inputs or self.get_default_inputs(),
+                workflow_definition=self.__class__,
             )
         )