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

vellum/client/types/execute_api_response.py

@@ -2,8 +2,9 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import typing_extensions
-import typing
+from .execute_api_response_json import ExecuteApiResponseJson
 from ..core.serialization import FieldMetadata
+import typing
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -11,9 +12,7 @@ import pydantic
 class ExecuteApiResponse(UniversalBaseModel):
     status_code: int
     text: str
-    json_: typing_extensions.Annotated[
-        typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]], FieldMetadata(alias="json")
-    ] = None
+    json_: typing_extensions.Annotated[ExecuteApiResponseJson, FieldMetadata(alias="json")]
     headers: typing.Dict[str, str]
 
     if IS_PYDANTIC_V2:

vellum/client/types/execute_api_response_json.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+ExecuteApiResponseJson = typing.Union[
+    typing.Dict[str, typing.Optional[typing.Any]], typing.List[typing.Optional[typing.Any]]
+]

vellum/client/types/prompt_settings.py

@@ -8,6 +8,7 @@ import pydantic
 
 class PromptSettings(UniversalBaseModel):
     timeout: typing.Optional[float] = None
+    stream_enabled: typing.Optional[bool] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_event_execution_read.py

@@ -10,8 +10,6 @@ from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
 from .workflow_parent_context import WorkflowParentContext
 from .workflow_sandbox_parent_context import WorkflowSandboxParentContext
 from .array_vellum_value import ArrayVellumValue
-from .node_event_display_context import NodeEventDisplayContext
-from .workflow_event_display_context import WorkflowEventDisplayContext
 import typing
 import datetime as dt
 from .execution_vellum_value import ExecutionVellumValue
@@ -56,5 +54,3 @@ update_forward_refs(WorkflowDeploymentParentContext, WorkflowEventExecutionRead=
 update_forward_refs(WorkflowParentContext, WorkflowEventExecutionRead=WorkflowEventExecutionRead)
 update_forward_refs(WorkflowSandboxParentContext, WorkflowEventExecutionRead=WorkflowEventExecutionRead)
 update_forward_refs(ArrayVellumValue, WorkflowEventExecutionRead=WorkflowEventExecutionRead)
-update_forward_refs(NodeEventDisplayContext, WorkflowEventExecutionRead=WorkflowEventExecutionRead)
-update_forward_refs(WorkflowEventDisplayContext, WorkflowEventExecutionRead=WorkflowEventExecutionRead)

vellum/client/types/workflow_execution_initiated_body.py

@@ -1,19 +1,14 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from __future__ import annotations
 from ..core.pydantic_utilities import UniversalBaseModel
-from .node_event_display_context import NodeEventDisplayContext
-from .workflow_event_display_context import WorkflowEventDisplayContext
 from .vellum_code_resource_definition import VellumCodeResourceDefinition
 import typing
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
-from ..core.pydantic_utilities import update_forward_refs
 
 
 class WorkflowExecutionInitiatedBody(UniversalBaseModel):
     workflow_definition: VellumCodeResourceDefinition
-    display_context: typing.Optional[WorkflowEventDisplayContext] = None
     inputs: typing.Dict[str, typing.Optional[typing.Any]]
 
     if IS_PYDANTIC_V2:
@@ -24,7 +19,3 @@ class WorkflowExecutionInitiatedBody(UniversalBaseModel):
             frozen = True
             smart_union = True
             extra = pydantic.Extra.allow
-
-
-update_forward_refs(NodeEventDisplayContext, WorkflowExecutionInitiatedBody=WorkflowExecutionInitiatedBody)
-update_forward_refs(WorkflowEventDisplayContext, WorkflowExecutionInitiatedBody=WorkflowExecutionInitiatedBody)

vellum/client/types/workflow_execution_initiated_event.py

@@ -9,8 +9,6 @@ from .span_link import SpanLink
 from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
 from .workflow_parent_context import WorkflowParentContext
 from .workflow_sandbox_parent_context import WorkflowSandboxParentContext
-from .node_event_display_context import NodeEventDisplayContext
-from .workflow_event_display_context import WorkflowEventDisplayContext
 import typing
 from .parent_context import ParentContext
 from .workflow_execution_initiated_body import WorkflowExecutionInitiatedBody
@@ -49,5 +47,3 @@ update_forward_refs(SpanLink, WorkflowExecutionInitiatedEvent=WorkflowExecutionI
 update_forward_refs(WorkflowDeploymentParentContext, WorkflowExecutionInitiatedEvent=WorkflowExecutionInitiatedEvent)
 update_forward_refs(WorkflowParentContext, WorkflowExecutionInitiatedEvent=WorkflowExecutionInitiatedEvent)
 update_forward_refs(WorkflowSandboxParentContext, WorkflowExecutionInitiatedEvent=WorkflowExecutionInitiatedEvent)
-update_forward_refs(NodeEventDisplayContext, WorkflowExecutionInitiatedEvent=WorkflowExecutionInitiatedEvent)
-update_forward_refs(WorkflowEventDisplayContext, WorkflowExecutionInitiatedEvent=WorkflowExecutionInitiatedEvent)

vellum/client/types/workflow_execution_span.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 from ..core.pydantic_utilities import UniversalBaseModel
 from .api_request_parent_context import ApiRequestParentContext
-from .node_event_display_context import NodeEventDisplayContext
 from .node_parent_context import NodeParentContext
 from .prompt_deployment_parent_context import PromptDeploymentParentContext
 from .span_link import SpanLink
 from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
-from .workflow_event_display_context import WorkflowEventDisplayContext
 from .workflow_parent_context import WorkflowParentContext
 from .workflow_sandbox_parent_context import WorkflowSandboxParentContext
 import typing
@@ -40,11 +38,9 @@ class WorkflowExecutionSpan(UniversalBaseModel):
 
 
 update_forward_refs(ApiRequestParentContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
-update_forward_refs(NodeEventDisplayContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
 update_forward_refs(NodeParentContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
 update_forward_refs(PromptDeploymentParentContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
 update_forward_refs(SpanLink, WorkflowExecutionSpan=WorkflowExecutionSpan)
 update_forward_refs(WorkflowDeploymentParentContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
-update_forward_refs(WorkflowEventDisplayContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
 update_forward_refs(WorkflowParentContext, WorkflowExecutionSpan=WorkflowExecutionSpan)
 update_forward_refs(WorkflowSandboxParentContext, WorkflowExecutionSpan=WorkflowExecutionSpan)

vellum/types/{node_event_display_context.py → execute_api_response_json.py}

@@ -1,3 +1,3 @@
 # WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
 
-from vellum.client.types.node_event_display_context import *
+from vellum.client.types.execute_api_response_json import *

vellum/workflows/inputs/base.py

@@ -1,4 +1,4 @@
-from typing import Any, Iterator, Tuple, Type, Union, get_args, get_origin
+from typing import Any, Dict, Iterator, Set, Tuple, Type, Union, get_args, get_origin
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler
@@ -14,11 +14,28 @@ from vellum.workflows.types.utils import get_class_attr_names, infer_types
 
 @dataclass_transform(kw_only_default=True)
 class _BaseInputsMeta(type):
+    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        dct["__parent_class__"] = type(None)
+        return super().__new__(cls, name, bases, dct)
+
     def __getattribute__(cls, name: str) -> Any:
-        if not name.startswith("_") and name in cls.__annotations__ and issubclass(cls, BaseInputs):
+        if name.startswith("_") or not issubclass(cls, BaseInputs):
+            return super().__getattribute__(name)
+
+        attr_names = get_class_attr_names(cls)
+        if name in attr_names:
+            # We first try to resolve the instance that this class attribute name is mapped to. If it's not found,
+            # we iterate through its inheritance hierarchy to find the first base class that has this attribute
+            # and use its mapping.
             instance = vars(cls).get(name, undefined)
-            types = infer_types(cls, name)
+            if instance is undefined:
+                for base in cls.__mro__[1:]:
+                    inherited_input_reference = getattr(base, name, undefined)
+                    if isinstance(inherited_input_reference, (ExternalInputReference, WorkflowInputReference)):
+                        instance = inherited_input_reference.instance
+                        break
 
+            types = infer_types(cls, name)
             if getattr(cls, "__descriptor_class__", None) is ExternalInputReference:
                 return ExternalInputReference(name=name, types=types, instance=instance, inputs_class=cls)
             else:
@@ -29,14 +46,20 @@ class _BaseInputsMeta(type):
     def __iter__(cls) -> Iterator[InputReference]:
         # We iterate through the inheritance hierarchy to find all the WorkflowInputReference attached to this
         # Inputs class. __mro__ is the method resolution order, which is the order in which base classes are resolved.
+        yielded_attr_names: Set[str] = set()
+
         for resolved_cls in cls.__mro__:
             attr_names = get_class_attr_names(resolved_cls)
             for attr_name in attr_names:
+                if attr_name in yielded_attr_names:
+                    continue
+
                 attr_value = getattr(resolved_cls, attr_name)
                 if not isinstance(attr_value, (WorkflowInputReference, ExternalInputReference)):
                     continue
 
                 yield attr_value
+                yielded_attr_names.add(attr_name)
 
 
 class BaseInputs(metaclass=_BaseInputsMeta):

vellum/workflows/inputs/tests/test_inputs.py

@@ -47,3 +47,18 @@ def test_base_inputs_with_default():
 
     # THEN it should use the default value
     assert inputs.string_with_default == "default_value"
+
+
+def test_base_inputs__supports_inherited_inputs():
+    # GIVEN an inputs class
+    class TopInputs(BaseInputs):
+        first: str
+
+    # WHEN we inherit from the base inputs class
+    class BottomInputs(TopInputs):
+        second: int
+
+    # THEN both references should be available
+    assert BottomInputs.first.name == "first"
+    assert BottomInputs.second.name == "second"
+    assert len([ref for ref in BottomInputs]) == 2

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
 
+from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.output import OutputReference
@@ -13,6 +14,14 @@ class _BaseAdornmentNodeMeta(BaseNodeMeta):
     def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         node_class = super().__new__(cls, name, bases, dct)
 
+        SubworkflowInputs = dct.get("SubworkflowInputs")
+        if (
+            isinstance(SubworkflowInputs, type)
+            and issubclass(SubworkflowInputs, BaseInputs)
+            and SubworkflowInputs.__parent_class__ is type(None)
+        ):
+            SubworkflowInputs.__parent_class__ = node_class
+
         subworkflow_attribute = dct.get("subworkflow")
         if not subworkflow_attribute:
             return node_class

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

@@ -62,7 +62,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
 
         item: MapNodeItemType  # type: ignore[valid-type]
         index: int
-        all_items: List[MapNodeItemType]  # type: ignore[valid-type]
+        items: List[MapNodeItemType]  # type: ignore[valid-type]
 
     def run(self) -> Iterator[BaseOutput]:
         mapped_items: Dict[str, List] = defaultdict(list)
@@ -176,8 +176,9 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
             parent_state=self.state,
             context=context,
         )
+        SubworkflowInputsClass = self.subworkflow.get_inputs_class()
         events = subworkflow.stream(
-            inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),
+            inputs=SubworkflowInputsClass(index=index, item=item, items=self.items),
             node_output_mocks=self._context._get_all_node_output_mocks(),
             event_filter=all_workflow_event_filter,
         )

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

@@ -116,3 +116,59 @@ def test_map_node__inner_try():
     # THEN the workflow should succeed
     assert outputs[-1].name == "final_output"
     assert len(outputs[-1].value) == 2
+
+
+def test_map_node__nested_map_node():
+    # GIVEN the inner map node's inputs
+    class VegetableMapNodeInputs(MapNode.SubworkflowInputs):
+        item: str
+
+    # AND the outer map node's inputs
+    class FruitMapNodeInputs(MapNode.SubworkflowInputs):
+        item: str
+
+    # AND a simple node that concats both attributes
+    class SimpleConcatNode(BaseNode):
+        fruit = FruitMapNodeInputs.item
+        vegetable = VegetableMapNodeInputs.item
+
+        class Outputs(BaseNode.Outputs):
+            medley: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(medley=f"{self.fruit} {self.vegetable}")
+
+    # AND a workflow using that node
+    class VegetableMapNodeWorkflow(BaseWorkflow[VegetableMapNodeInputs, BaseState]):
+        graph = SimpleConcatNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = SimpleConcatNode.Outputs.medley
+
+    # AND an inner map node referencing that workflow
+    class VegetableMapNode(MapNode):
+        items = ["carrot", "potato"]
+        subworkflow = VegetableMapNodeWorkflow
+
+    # AND an outer subworkflow referencing the inner map node
+    class FruitMapNodeWorkflow(BaseWorkflow[FruitMapNodeInputs, BaseState]):
+        graph = VegetableMapNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = VegetableMapNode.Outputs.final_output
+
+    # AND an outer map node referencing the outer subworkflow
+    class FruitMapNode(MapNode):
+        items = ["apple", "banana"]
+        subworkflow = FruitMapNodeWorkflow
+
+    # WHEN we run the workflow
+    stream = FruitMapNode().run()
+    outputs = list(stream)
+
+    # THEN the workflow should succeed
+    assert outputs[-1].name == "final_output"
+    assert outputs[-1].value == [
+        ["apple carrot", "apple potato"],
+        ["banana carrot", "banana potato"],
+    ]

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

@@ -47,8 +47,9 @@ class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
                     parent_state=self.state,
                     context=WorkflowContext.create_from(self._context),
                 )
+                inputs_class = subworkflow.get_inputs_class()
                 subworkflow_stream = subworkflow.stream(
-                    inputs=self.SubworkflowInputs(attempt_number=attempt_number),
+                    inputs=inputs_class(attempt_number=attempt_number),
                     event_filter=all_workflow_event_filter,
                     node_output_mocks=self._context._get_all_node_output_mocks(),
                 )

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

@@ -1,8 +1,7 @@
 from collections.abc import Callable
-from typing import Any, ClassVar, Dict, List, Optional, cast
+from typing import Any, ClassVar, List, Optional
 
-from vellum import ChatMessage, FunctionDefinition, PromptBlock
-from vellum.client.types.chat_message_request import ChatMessageRequest
+from vellum import ChatMessage, PromptBlock
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -35,8 +34,7 @@ class ToolCallingNode(BaseNode):
 
     ml_model: ClassVar[str] = "gpt-4o-mini"
     blocks: ClassVar[List[PromptBlock]] = []
-    functions: ClassVar[List[FunctionDefinition]] = []
-    function_callables: ClassVar[Dict[str, Callable[..., Any]]] = {}
+    functions: ClassVar[List[Callable[..., Any]]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     # TODO: https://linear.app/vellum/issue/APO-342/support-tool-call-max-retries
     max_tool_calls: ClassVar[int] = 1
@@ -59,27 +57,13 @@ class ToolCallingNode(BaseNode):
         This dynamically builds a graph with router and function nodes,
         then executes the workflow.
         """
-        self._validate_functions()
-
-        initial_chat_history = []
-
-        # Extract chat history from prompt inputs if available
-        if self.prompt_inputs and "chat_history" in self.prompt_inputs:
-            chat_history_input = self.prompt_inputs["chat_history"]
-            if isinstance(chat_history_input, list) and all(
-                isinstance(msg, (ChatMessage, ChatMessageRequest)) for msg in chat_history_input
-            ):
-                initial_chat_history = [
-                    msg if isinstance(msg, ChatMessage) else ChatMessage.model_validate(msg.model_dump())
-                    for msg in chat_history_input
-                ]
 
         self._build_graph()
 
         with execution_context(parent_context=get_parent_context()):
 
             class ToolCallingState(BaseState):
-                chat_history: List[ChatMessage] = initial_chat_history
+                chat_history: List[ChatMessage] = []
 
             class ToolCallingWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
                 graph = self._graph
@@ -121,9 +105,8 @@ class ToolCallingNode(BaseNode):
         )
 
         self._function_nodes = {
-            function.name: create_function_node(
+            function.__name__: create_function_node(
                 function=function,
-                function_callable=cast(Callable[..., Any], self.function_callables[function.name]),  # type: ignore
             )
             for function in self.functions
         }
@@ -132,7 +115,7 @@ class ToolCallingNode(BaseNode):
 
         # Add connections from ports of router to function nodes and back to router
         for function_name, FunctionNodeClass in self._function_nodes.items():
-            router_port = getattr(self.tool_router_node.Ports, function_name)  # type: ignore  # mypy thinks name is still optional # noqa: E501
+            router_port = getattr(self.tool_router_node.Ports, function_name)
             edge_graph = router_port >> FunctionNodeClass >> self.tool_router_node
             graph_set.add(edge_graph)
 
@@ -140,8 +123,3 @@ class ToolCallingNode(BaseNode):
         graph_set.add(default_port)
 
         self._graph = Graph.from_set(graph_set)
-
-    def _validate_functions(self) -> None:
-        for function in self.functions:
-            if function.name is None:
-                raise ValueError("Function name is required")

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

@@ -35,7 +35,7 @@ class ToolRouterNode(InlinePromptNode):
                         if function_call is not None:
                             self.state.chat_history.append(
                                 ChatMessage(
-                                    role="FUNCTION",
+                                    role="ASSISTANT",
                                     content=FunctionCallChatMessageContent(
                                         value=FunctionCallChatMessageContentValue(
                                             name=function_call.name,
@@ -51,16 +51,12 @@ class ToolRouterNode(InlinePromptNode):
 def create_tool_router_node(
     ml_model: str,
     blocks: List[PromptBlock],
-    functions: List[FunctionDefinition],
+    functions: List[Callable[..., Any]],
     prompt_inputs: Optional[EntityInputsInterface],
 ) -> Type[ToolRouterNode]:
     Ports = type("Ports", (), {})
     for function in functions:
-        if function.name is None:
-            # We should not raise an error here since we filter out functions without names
-            raise ValueError("Function name is required")
-
-        function_name = function.name
+        function_name = function.__name__
         port_condition = LazyReference(
             lambda: (
                 ToolRouterNode.Outputs.results[0]["type"].equals("FUNCTION_CALL")
@@ -98,7 +94,7 @@ def create_tool_router_node(
     return node
 
 
-def create_function_node(function: FunctionDefinition, function_callable: Callable[..., Any]) -> Type[FunctionNode]:
+def create_function_node(function: Callable[..., Any]) -> Type[FunctionNode]:
     """
     Create a FunctionNode class for a given function.
 
@@ -113,14 +109,14 @@ def create_function_node(function: FunctionDefinition, function_callable: Callab
         arguments = outputs["arguments"]
 
         # Call the original function directly with the arguments
-        result = function_callable(**arguments)
+        result = function(**arguments)
 
         self.state.chat_history.append(ChatMessage(role="FUNCTION", text=result))
 
         return self.Outputs()
 
     node = type(
-        f"FunctionNode_{function.name}",
+        f"FunctionNode_{function.__name__}",
         (FunctionNode,),
         {
             "function": function,

vellum/workflows/nodes/utils.py

@@ -9,9 +9,11 @@ from pydantic import BaseModel, create_model
 from vellum.client.types.function_call import FunctionCall
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.ports.port import Port
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import Json
 from vellum.workflows.types.generics import NodeType
 
@@ -54,7 +56,18 @@ def create_adornment(
         # https://app.shortcut.com/vellum/story/4116
         from vellum.workflows import BaseWorkflow
 
-        class Subworkflow(BaseWorkflow):
+        SubworkflowInputs = getattr(adornable_cls, "SubworkflowInputs", None)
+        BaseSubworkflowInputs = (
+            SubworkflowInputs
+            if isinstance(SubworkflowInputs, type) and issubclass(SubworkflowInputs, BaseInputs)
+            else BaseInputs
+        )
+
+        # mypy is too conservative here - you can absolutely inherit from dynamic classes in python
+        class Inputs(BaseSubworkflowInputs):  # type: ignore[misc, valid-type]
+            pass
+
+        class Subworkflow(BaseWorkflow[Inputs, BaseState]):
             graph = inner_cls
 
             class Outputs(BaseWorkflow.Outputs):

vellum/workflows/references/workflow_input.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Generic, Optional, Tuple, Type, TypeVar, cast
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.types.generics import import_workflow_class
 
 if TYPE_CHECKING:
     from vellum.workflows.inputs.base import BaseInputs
@@ -29,7 +30,10 @@ class WorkflowInputReference(BaseDescriptor[_InputType], Generic[_InputType]):
         return self._inputs_class
 
     def resolve(self, state: "BaseState") -> _InputType:
-        if hasattr(state.meta.workflow_inputs, self._name):
+        if hasattr(state.meta.workflow_inputs, self._name) and (
+            state.meta.workflow_definition == self._inputs_class.__parent_class__
+            or not issubclass(self._inputs_class.__parent_class__, import_workflow_class())
+        ):
             return cast(_InputType, getattr(state.meta.workflow_inputs, self._name))
 
         if state.meta.parent:

vellum/workflows/runner/runner.py

@@ -101,6 +101,7 @@ class WorkflowRunner(Generic[StateType]):
             if state:
                 self._initial_state = deepcopy(state)
                 self._initial_state.meta.span_id = uuid4()
+                self._initial_state.meta.workflow_definition = self.workflow.__class__
             else:
                 self._initial_state = self.workflow.get_state_at_node(node)
             self._entrypoints = entrypoint_nodes
@@ -126,6 +127,7 @@ class WorkflowRunner(Generic[StateType]):
                 self._initial_state = deepcopy(state)
                 self._initial_state.meta.workflow_inputs = normalized_inputs
                 self._initial_state.meta.span_id = uuid4()
+                self._initial_state.meta.workflow_definition = self.workflow.__class__
             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

vellum/workflows/workflows/base.py

@@ -133,6 +133,11 @@ class _BaseWorkflowMeta(type):
         cls = super().__new__(mcs, name, bases, dct)
         workflow_class = cast(Type["BaseWorkflow"], cls)
         workflow_class.__id__ = uuid4_from_hash(workflow_class.__qualname__)
+
+        inputs_class = workflow_class.get_inputs_class()
+        if inputs_class is not BaseInputs and inputs_class.__parent_class__ is type(None):
+            inputs_class.__parent_class__ = workflow_class
+
         return workflow_class
 
 

{vellum_ai-0.14.40.dist-info → vellum_ai-0.14.42.dist-info}/METADATA

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