vellum-ai 0.13.20__tar.gz → 0.13.21__tar.gz

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/PKG-INFO

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

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -28,6 +28,7 @@ from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualTo
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
 from vellum.workflows.expressions.or_ import OrExpression
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
@@ -76,6 +77,12 @@ def create_node_input_value_pointer_rule(
     value: Any, display_context: "WorkflowDisplayContext"
 ) -> NodeInputValuePointerRule:
     if isinstance(value, OutputReference):
+        if value not in display_context.global_node_output_displays:
+            if issubclass(value.outputs_class, BaseNode.Outputs):
+                raise ValueError(f"Reference to node '{value.outputs_class._node_class.__name__}' not found in graph.")
+
+            raise ValueError(f"Reference to outputs '{value.outputs_class.__qualname__}' is invalid.")
+
         upstream_node, output_display = display_context.global_node_output_displays[value]
         upstream_node_display = display_context.global_node_displays[upstream_node]
         return NodeOutputPointer(

vellum_ai-0.13.21/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -0,0 +1,65 @@
+import pytest
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_workflow__node_referenced_in_workflow_outputs_not_in_graph():
+    # GIVEN a couple of nodes
+    class InNode(BaseNode):
+        pass
+
+    class OutNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    # AND A workflow that references the OutNode in its outputs but only has the InNode in its graph
+    class Workflow(BaseWorkflow):
+        graph = InNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final = OutNode.Outputs.foo
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+
+    # THEN it should raise an error
+    with pytest.raises(ValueError) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should be user friendly
+    assert str(exc_info.value) == "Failed to serialize output 'final': Reference to node 'OutNode' not found in graph."
+
+
+def test_serialize_workflow__workflow_outputs_reference_non_node_outputs():
+    # GIVEN one Workflow
+    class FirstWorkflow(BaseWorkflow):
+        class Outputs(BaseWorkflow.Outputs):
+            foo = "bar"
+
+    # AND A workflow that references the Outputs of that Workflow
+    class Workflow(BaseWorkflow):
+        class Outputs(BaseWorkflow.Outputs):
+            final = FirstWorkflow.Outputs.foo
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+
+    # THEN it should raise an error
+    with pytest.raises(ValueError) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should be user friendly
+    assert (
+        str(exc_info.value)
+        == """Failed to serialize output 'final': Reference to outputs \
+'test_serialize_workflow__workflow_outputs_reference_non_node_outputs.<locals>.FirstWorkflow.Outputs' is invalid."""
+    )

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/ee/vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -129,13 +129,16 @@ class VellumWorkflowDisplay(
 
             if workflow_output.instance not in final_output_node_outputs:
                 # Create a synthetic terminal node only if there is no terminal node for this output
-                node_input = create_node_input(
-                    final_output_node_id,
-                    "node_input",
-                    # This is currently the wrapper node's output, but we want the wrapped node
-                    workflow_output.instance,
-                    self.display_context,
-                )
+                try:
+                    node_input = create_node_input(
+                        final_output_node_id,
+                        "node_input",
+                        # This is currently the wrapper node's output, but we want the wrapped node
+                        workflow_output.instance,
+                        self.display_context,
+                    )
+                except ValueError as e:
+                    raise ValueError(f"Failed to serialize output '{workflow_output.name}': {str(e)}") from e
 
                 source_node_display: Optional[BaseNodeDisplay]
                 first_rule = node_input.value.rules[0]

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.20"
+version = "0.13.21"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.13.20",
+            "X-Fern-SDK-Version": "0.13.21",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/events/workflow.py

@@ -6,7 +6,7 @@ from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
-from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 from .node import (
     NodeExecutionFulfilledEvent,
@@ -38,20 +38,20 @@ class _BaseWorkflowEvent(BaseEvent):
         return self.body.workflow_definition
 
 
-class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[WorkflowInputsType]):
-    inputs: WorkflowInputsType
+class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType]):
+    inputs: InputsType
 
     @field_serializer("inputs")
-    def serialize_inputs(self, inputs: WorkflowInputsType, _info: Any) -> Dict[str, Any]:
+    def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)
 
 
-class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[WorkflowInputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
-    body: WorkflowExecutionInitiatedBody[WorkflowInputsType]
+    body: WorkflowExecutionInitiatedBody[InputsType]
 
     @property
-    def inputs(self) -> WorkflowInputsType:
+    def inputs(self) -> InputsType:
         return self.body.inputs
 
 

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/graph/graph.py

@@ -118,6 +118,12 @@ class Graph:
         self._terminals = {other}
         return self
 
+    def __rrshift__(cls, other_cls: GraphTarget) -> "Graph":
+        if not isinstance(other_cls, set):
+            other_cls = {other_cls}
+
+        return Graph.from_set(other_cls) >> cls
+
     @property
     def entrypoints(self) -> Iterator[Type["BaseNode"]]:
         return iter(e.node_class for e in self._entrypoints)

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/graph/tests/test_graph.py

@@ -460,3 +460,27 @@ def test_graph__node_to_port():
 
     # AND two edges
     assert len(list(graph.edges)) == 2
+
+
+def test_graph__set_to_graph():
+    # GIVEN three nodes
+    class SourceNode(BaseNode):
+        pass
+
+    class MiddleNode(BaseNode):
+        pass
+
+    class TargetNode(BaseNode):
+        pass
+
+    # WHEN we create a graph from a set to a graph
+    graph: Graph = {SourceNode, MiddleNode} >> Graph.from_node(TargetNode)
+
+    # THEN the graph has the source node and middle node as the entrypoints
+    assert set(graph.entrypoints) == {SourceNode, MiddleNode}
+
+    # AND three nodes
+    assert len(list(graph.nodes)) == 3
+
+    # AND two edges
+    assert len(list(graph.edges)) == 2

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/nodes/bases/base.py

@@ -1,3 +1,4 @@
+from dataclasses import field
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
@@ -192,7 +193,7 @@ class _BaseNodeTriggerMeta(type):
 
 class _BaseNodeExecutionMeta(type):
     def __getattribute__(cls, name: str) -> Any:
-        if name.startswith("count") and issubclass(cls, BaseNode.Execution):
+        if name == "count" and issubclass(cls, BaseNode.Execution):
             return ExecutionCountReference(cls.node_class)
 
         return super().__getattribute__(name)
@@ -230,7 +231,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     #   "Outputs" class inherits from "BaseOutputs" and do so automatically.
     #   https://app.shortcut.com/vellum/story/4008/auto-inherit-basenodeoutputs-in-outputs-classes
     class Outputs(BaseOutputs):
-        _node_class: Optional[Type["BaseNode"]] = None
+        _node_class: Type["BaseNode"] = field(init=False)
 
     class Ports(NodePorts):
         default = Port(default=True)

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -11,7 +11,7 @@ from vellum.workflows.references import OutputReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface
-from vellum.workflows.types.generics import StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
@@ -57,16 +57,16 @@ class _InlineSubworkflowNodeMeta(BaseNodeMeta):
 
 
 class InlineSubworkflowNode(
-    BaseNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType], metaclass=_InlineSubworkflowNodeMeta
+    BaseNode[StateType], Generic[StateType, InputsType, InnerStateType], metaclass=_InlineSubworkflowNodeMeta
 ):
     """
     Used to execute a Subworkflow defined inline.
 
-    subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"] - The Subworkflow to execute
+    subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"] - The Subworkflow to execute
     subworkflow_inputs: ClassVar[EntityInputsInterface] = {}
     """
 
-    subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"]
+    subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"]
     subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[UNDEF]]] = UNDEF
 
     def run(self) -> Iterator[BaseOutput]:
@@ -109,7 +109,7 @@ class InlineSubworkflowNode(
                     value=output_value,
                 )
 
-    def _compile_subworkflow_inputs(self) -> WorkflowInputsType:
+    def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
         if self.subworkflow_inputs is UNDEF:
             inputs_dict = {}

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/runner/runner.py

@@ -65,7 +65,7 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference, OutputReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.cycle_map import CycleMap
-from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 if TYPE_CHECKING:
     from vellum.workflows import BaseWorkflow
@@ -82,8 +82,8 @@ class WorkflowRunner(Generic[StateType]):
 
     def __init__(
         self,
-        workflow: "BaseWorkflow[WorkflowInputsType, StateType]",
-        inputs: Optional[WorkflowInputsType] = None,
+        workflow: "BaseWorkflow[InputsType, StateType]",
+        inputs: Optional[InputsType] = None,
         state: Optional[StateType] = None,
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/types/generics.py

@@ -10,5 +10,5 @@ if TYPE_CHECKING:
 NodeType = TypeVar("NodeType", bound="BaseNode")
 StateType = TypeVar("StateType", bound="BaseState")
 WorkflowType = TypeVar("WorkflowType", bound="BaseWorkflow")
-WorkflowInputsType = TypeVar("WorkflowInputsType", bound="BaseInputs")
+InputsType = TypeVar("InputsType", bound="BaseInputs")
 OutputsType = TypeVar("OutputsType", bound="BaseOutputs")

{vellum_ai-0.13.20 → vellum_ai-0.13.21}/src/vellum/workflows/workflows/base.py

@@ -68,7 +68,7 @@ from vellum.workflows.runner.runner import ExternalInputsArg, RunFromNodeArg
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.state.store import Store
-from vellum.workflows.types.generics import StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, StateType
 from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.event_filters import workflow_event_filter
@@ -88,7 +88,7 @@ class _BaseWorkflowMeta(type):
 GraphAttribute = Union[Type[BaseNode], Graph, Set[Type[BaseNode]], Set[Graph]]
 
 
-class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkflowMeta):
+class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
     graph: ClassVar[GraphAttribute]
     emitters: List[BaseWorkflowEmitter]
@@ -99,7 +99,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     WorkflowEvent = Union[  # type: ignore
         GenericWorkflowEvent,
-        WorkflowExecutionInitiatedEvent[WorkflowInputsType],  # type: ignore[valid-type]
+        WorkflowExecutionInitiatedEvent[InputsType],  # type: ignore[valid-type]
         WorkflowExecutionFulfilledEvent[Outputs],
         WorkflowExecutionSnapshottedEvent[StateType],  # type: ignore[valid-type]
     ]
@@ -181,7 +181,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     def run(
         self,
-        inputs: Optional[WorkflowInputsType] = None,
+        inputs: Optional[InputsType] = None,
         *,
         state: Optional[StateType] = None,
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
@@ -198,7 +198,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
         Parameters
         ----------
-        inputs: Optional[WorkflowInputsType] = None
+        inputs: Optional[InputsType] = None
             The Inputs instance used to initiate the Workflow Execution.
 
         state: Optional[StateType] = None
@@ -288,7 +288,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     def stream(
         self,
-        inputs: Optional[WorkflowInputsType] = None,
+        inputs: Optional[InputsType] = None,
         *,
         event_filter: Optional[Callable[[Type["BaseWorkflow"], WorkflowEvent], bool]] = None,
         state: Optional[StateType] = None,
@@ -307,7 +307,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
             A filter that can be used to filter events based on the Workflow Class and the event itself. If the method
             returns `False`, the event will not be yielded.
 
-        inputs: Optional[WorkflowInputsType] = None
+        inputs: Optional[InputsType] = None
             The Inputs instance used to initiate the Workflow Execution.
 
         state: Optional[StateType] = None
@@ -359,7 +359,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
     @lru_cache
     def _get_parameterized_classes(
         cls,
-    ) -> Tuple[Type[WorkflowInputsType], Type[StateType]]:
+    ) -> Tuple[Type[InputsType], Type[StateType]]:
         original_base = get_original_base(cls)
 
         inputs_type, state_type = get_args(original_base)
@@ -378,17 +378,17 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
         return (inputs_type, state_type)
 
     @classmethod
-    def get_inputs_class(cls) -> Type[WorkflowInputsType]:
+    def get_inputs_class(cls) -> Type[InputsType]:
         return cls._get_parameterized_classes()[0]
 
     @classmethod
     def get_state_class(cls) -> Type[StateType]:
         return cls._get_parameterized_classes()[1]
 
-    def get_default_inputs(self) -> WorkflowInputsType:
+    def get_default_inputs(self) -> InputsType:
         return self.get_inputs_class()()
 
-    def get_default_state(self, workflow_inputs: Optional[WorkflowInputsType] = None) -> StateType:
+    def get_default_state(self, workflow_inputs: Optional[InputsType] = None) -> StateType:
         return self.get_state_class()(
             meta=StateMeta(
                 parent=self._parent_state,