vellum-ai 0.10.3__py3-none-any.whl → 0.10.6__py3-none-any.whl

vellum/workflows/outputs/base.py

@@ -5,6 +5,7 @@ from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
 
@@ -76,6 +77,23 @@ class BaseOutput(Generic[_Delta, _Accumulated]):
 
         return data
 
+    def __repr__(self) -> str:
+        if self.value is not UNDEF:
+            return f"{self.__class__.__name__}({self.name}={self.value})"
+        elif self.delta is not UNDEF:
+            return f"{self.__class__.__name__}({self.name}={self.delta})"
+        else:
+            return f"{self.__class__.__name__}(name='{self.name}')"
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, BaseOutput):
+            return False
+
+        return self.name == other.name and self.value == other.value and self.delta == other.delta
+    
+    def __hash__(self) -> int:
+        return hash((self._name, self._value, self._value))
+
 
 @dataclass_transform(kw_only_default=True)
 class _BaseOutputsMeta(type):
@@ -175,7 +193,9 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
         if not isinstance(other, dict):
             return super().__eq__(other)
 
-        outputs = {name: value for name, value in vars(self).items() if not name.startswith("_") and value is not UNDEF}
+        outputs = {
+            name: value for name, value in vars(self).items() if not name.startswith("_") and value is not UNDEF
+        }
         return outputs == other
 
     def __repr__(self) -> str:
@@ -184,7 +204,11 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
 
     def __iter__(self) -> Iterator[Tuple[OutputReference, Any]]:
         for output_descriptor in self.__class__:
-            yield (output_descriptor, getattr(self, output_descriptor.name, output_descriptor.instance))
+            output_value = getattr(self, output_descriptor.name, UNDEF)
+            if isinstance(output_value, BaseDescriptor):
+                output_value = UNDEF
+
+            yield (output_descriptor, output_value)
 
     def __getitem__(self, key: str) -> Any:
         return getattr(self, key)

vellum/workflows/runner/runner.py

@@ -170,32 +170,37 @@ class WorkflowRunner(Generic[StateType]):
                 streaming_output_queues: Dict[str, Queue] = {}
                 outputs = node.Outputs()
 
+                def initiate_node_streaming_output(output: BaseOutput) -> None:
+                    streaming_output_queues[output.name] = Queue()
+                    output_descriptor = OutputReference(
+                        name=output.name,
+                        types=(type(output.delta),),
+                        instance=None,
+                        outputs_class=node.Outputs,
+                    )
+                    node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
+                    self._work_item_event_queue.put(
+                        WorkItemEvent(
+                            node=node,
+                            event=NodeExecutionStreamingEvent(
+                                trace_id=node.state.meta.trace_id,
+                                span_id=span_id,
+                                body=NodeExecutionStreamingBody(
+                                    node_definition=node.__class__,
+                                    output=BaseOutput(name=output.name),
+                                ),
+                            ),
+                            invoked_ports=invoked_ports,
+                        )
+                    )
+
                 for output in node_run_response:
                     invoked_ports = output > ports
-                    if not output.is_fulfilled:
+                    if output.is_initiated:
+                        initiate_node_streaming_output(output)
+                    elif output.is_streaming:
                         if output.name not in streaming_output_queues:
-                            streaming_output_queues[output.name] = Queue()
-                            output_descriptor = OutputReference(
-                                name=output.name,
-                                types=(type(output.delta),),
-                                instance=None,
-                                outputs_class=node.Outputs,
-                            )
-                            node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
-                            self._work_item_event_queue.put(
-                                WorkItemEvent(
-                                    node=node,
-                                    event=NodeExecutionStreamingEvent(
-                                        trace_id=node.state.meta.trace_id,
-                                        span_id=span_id,
-                                        body=NodeExecutionStreamingBody(
-                                            node_definition=node.__class__,
-                                            output=BaseOutput(name=output.name),
-                                        ),
-                                    ),
-                                    invoked_ports=invoked_ports,
-                                )
-                            )
+                            initiate_node_streaming_output(output)
 
                         streaming_output_queues[output.name].put(output.delta)
                         self._work_item_event_queue.put(
@@ -212,7 +217,7 @@ class WorkflowRunner(Generic[StateType]):
                                 invoked_ports=invoked_ports,
                             )
                         )
-                    else:
+                    elif output.is_fulfilled:
                         if output.name in streaming_output_queues:
                             streaming_output_queues[output.name].put(UNDEF)
 
@@ -233,6 +238,11 @@ class WorkflowRunner(Generic[StateType]):
                         )
 
             for descriptor, output_value in outputs:
+                if output_value is UNDEF:
+                    if descriptor in node.state.meta.node_outputs:
+                        del node.state.meta.node_outputs[descriptor]
+                    continue
+
                 node.state.meta.node_outputs[descriptor] = output_value
 
             invoked_ports = ports(outputs, node.state)
@@ -540,11 +550,15 @@ class WorkflowRunner(Generic[StateType]):
         )
 
     def stream(self) -> WorkflowEventStream:
-        background_thread = Thread(target=self._run_background_thread)
+        background_thread = Thread(
+            target=self._run_background_thread, name=f"{self.workflow.__class__.__name__}.background_thread"
+        )
         background_thread.start()
 
         if self._cancel_signal:
-            cancel_thread = Thread(target=self._run_cancel_thread)
+            cancel_thread = Thread(
+                target=self._run_cancel_thread, name=f"{self.workflow.__class__.__name__}.cancel_thread"
+            )
             cancel_thread.start()
 
         event: WorkflowEvent
@@ -557,7 +571,7 @@ class WorkflowRunner(Generic[StateType]):
         self._initial_state.meta.is_terminated = False
 
         # The extra level of indirection prevents the runner from waiting on the caller to consume the event stream
-        stream_thread = Thread(target=self._stream)
+        stream_thread = Thread(target=self._stream, name=f"{self.workflow.__class__.__name__}.stream_thread")
         stream_thread.start()
 
         while stream_thread.is_alive():

vellum/workflows/state/tests/test_state.py

@@ -1,3 +1,4 @@
+import pytest
 from collections import defaultdict
 from copy import deepcopy
 import json
@@ -76,6 +77,7 @@ 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")

vellum/workflows/types/tests/test_utils.py

@@ -1,6 +1,8 @@
 import pytest
 from typing import ClassVar, Generic, List, TypeVar, Union
 
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
@@ -30,6 +32,11 @@ class ExampleGenericClass(Generic[T]):
 class ExampleInheritedClass(ExampleClass):
     theta: int
 
+@TryNode.wrap()
+class ExampleNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        iota: str
+
 
 @pytest.mark.parametrize(
     "cls, attr_name, expected_type",
@@ -45,6 +52,7 @@ class ExampleInheritedClass(ExampleClass):
         (ExampleInheritedClass, "theta", (int,)),
         (ExampleInheritedClass, "alpha", (str,)),
         (ExampleInheritedClass, "beta", (int,)),
+        (ExampleNode.Outputs, "iota", (str,)),
     ],
     ids=[
         "str",
@@ -58,6 +66,7 @@ class ExampleInheritedClass(ExampleClass):
         "inherited_int",
         "inherited_parent_annotation",
         "inherited_parent_class_var",
+        "try_node_output",
     ],
 )
 def test_infer_types(cls, attr_name, expected_type):

vellum/workflows/types/utils.py

@@ -1,6 +1,7 @@
 from copy import deepcopy
 from datetime import datetime
 import importlib
+import sys
 from typing import (
     Any,
     ClassVar,
@@ -18,7 +19,6 @@ from typing import (
 )
 
 from vellum import ArrayVellumValue, ArrayVellumValueRequest, ChatMessagePromptBlock
-
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.core import Json, SpecialGenericAlias, UnderGenericAlias, UnionGenericAlias
 

vellum/workflows/utils/vellum_variables.py

@@ -1,3 +1,4 @@
+import typing
 from typing import List, Tuple, Type, Union, get_args, get_origin
 
 from vellum import (
@@ -17,8 +18,8 @@ from vellum import (
     VellumValueRequest,
     VellumVariableType,
 )
-
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.types.core import Json
 
 
 def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -> VellumVariableType:
@@ -32,6 +33,17 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
             return "JSON"
 
         if len(types) != 1:
+            # Check explicitly for our internal JSON type.
+            # Matches the type found at vellum.workflows.utils.vellum_variables.Json
+            if types == [
+                bool,
+                int,
+                float,
+                str,
+                typing.List[typing.ForwardRef('Json')],  # type: ignore [misc]
+                typing.Dict[str, typing.ForwardRef('Json')],  # type: ignore [misc]
+            ]:
+                return "JSON"
             raise ValueError(f"Expected Descriptor to only have one type, got {types}")
 
         type_ = type_.types[0]

vellum/workflows/workflows/base.py

@@ -35,11 +35,17 @@ from vellum.workflows.emitters.base import BaseWorkflowEmitter
 from vellum.workflows.errors import VellumError, VellumErrorCode
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
+    NodeExecutionFulfilledEvent,
     NodeExecutionInitiatedBody,
+    NodeExecutionInitiatedEvent,
     NodeExecutionPausedBody,
+    NodeExecutionPausedEvent,
     NodeExecutionRejectedBody,
+    NodeExecutionRejectedEvent,
     NodeExecutionResumedBody,
+    NodeExecutionResumedEvent,
     NodeExecutionStreamingBody,
+    NodeExecutionStreamingEvent,
 )
 from vellum.workflows.events.types import WorkflowEventType
 from vellum.workflows.events.workflow import (
@@ -55,6 +61,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionResumedBody,
     WorkflowExecutionResumedEvent,
     WorkflowExecutionStreamingBody,
+    WorkflowExecutionStreamingEvent,
 )
 from vellum.workflows.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
@@ -204,7 +211,9 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
                 trace_id=uuid4(),
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
-                    error=VellumError(code=VellumErrorCode.INTERNAL_ERROR, message="Initiated event was never emitted"),
+                    error=VellumError(
+                        code=VellumErrorCode.INTERNAL_ERROR, message="Initiated event was never emitted"
+                    ),
                     workflow_definition=self.__class__,
                 ),
             )
@@ -363,3 +372,17 @@ NodeExecutionRejectedBody.model_rebuild()
 NodeExecutionPausedBody.model_rebuild()
 NodeExecutionResumedBody.model_rebuild()
 NodeExecutionStreamingBody.model_rebuild()
+
+WorkflowExecutionInitiatedEvent.model_rebuild()
+WorkflowExecutionFulfilledEvent.model_rebuild()
+WorkflowExecutionRejectedEvent.model_rebuild()
+WorkflowExecutionPausedEvent.model_rebuild()
+WorkflowExecutionResumedEvent.model_rebuild()
+WorkflowExecutionStreamingEvent.model_rebuild()
+
+NodeExecutionInitiatedEvent.model_rebuild()
+NodeExecutionFulfilledEvent.model_rebuild()
+NodeExecutionRejectedEvent.model_rebuild()
+NodeExecutionPausedEvent.model_rebuild()
+NodeExecutionResumedEvent.model_rebuild()
+NodeExecutionStreamingEvent.model_rebuild()

{vellum_ai-0.10.3.dist-info → vellum_ai-0.10.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.10.3
+Version: 0.10.6
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -63,7 +63,6 @@ Description-Content-Type: text/markdown
 
 # Introduction
 
-
 [Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications
 
 ### Core Features
@@ -85,22 +84,21 @@ Description-Content-Type: text/markdown
 - [Contributing](#contributing)
 - [Open-source vs paid](#open-source-vs-paid)
 
-
 ## Get Started
+
 Most functionality within the SDKs here requires a Vellum account and API key. To sign up, [talk to us](https://www.vellum.ai/landing-pages/request-demo)
 or visit our [pricing page](https://www.vellum.ai/pricing).
 
 Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
 more below](#workflows-sdk).
 
-
-
 ## Client SDK
+
 The Vellum Client SDK, found within `src/client` is a low-level client used to interact directly with the Vellum API.
 Learn more and get started by visiting the [Vellum Client SDK README](/src/vellum/client/README.md).
 
-
 ## Workflows SDK
+
 The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
 it's core, it's a powerful workflow engine with syntactic sugar for intuitively defining graphs, the nodes within,
 and the relationships between them.
@@ -111,6 +109,9 @@ and debugging via a UI.
 
 To learn more and get started, visit the [Vellum Workflows SDK README](/src/vellum/workflows/README.md).
 
+## Contributing
+
+See the [CONTRIBUTING.md](/CONTRIBUTING.md) for information on how to contribute to the Vellum SDKs.
 
 ## Open-Source vs. Paid
 
@@ -118,3 +119,4 @@ This repo is available under the [MIT expat license](https://github.com/vellum-a
 for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
 
 To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).
+