vellum-ai 0.10.4__py3-none-any.whl → 0.10.7__py3-none-any.whl

vellum/client/resources/test_suites/client.py

@@ -232,25 +232,21 @@ class TestSuitesClient:
             api_key="YOUR_API_KEY",
         )
         response = client.test_suites.test_suite_test_cases_bulk(
-            id="string",
+            id="id",
             request=[
                 TestSuiteTestCaseCreateBulkOperationRequest(
-                    id="string",
+                    id="id",
                     data=CreateTestSuiteTestCaseRequest(
-                        label="string",
                         input_values=[
                             NamedTestCaseStringVariableValueRequest(
-                                value="string",
-                                name="string",
+                                name="name",
                             )
                         ],
                         evaluation_values=[
                             NamedTestCaseStringVariableValueRequest(
-                                value="string",
-                                name="string",
+                                name="name",
                             )
                         ],
-                        external_id="string",
                     ),
                 )
             ],
@@ -571,25 +567,21 @@ class AsyncTestSuitesClient:
 
         async def main() -> None:
             response = await client.test_suites.test_suite_test_cases_bulk(
-                id="string",
+                id="id",
                 request=[
                     TestSuiteTestCaseCreateBulkOperationRequest(
-                        id="string",
+                        id="id",
                         data=CreateTestSuiteTestCaseRequest(
-                            label="string",
                             input_values=[
                                 NamedTestCaseStringVariableValueRequest(
-                                    value="string",
-                                    name="string",
+                                    name="name",
                                 )
                             ],
                             evaluation_values=[
                                 NamedTestCaseStringVariableValueRequest(
-                                    value="string",
-                                    name="string",
+                                    name="name",
                                 )
                             ],
-                            external_id="string",
                         ),
                     )
                 ],

vellum/client/resources/workflows/client.py

@@ -47,18 +47,6 @@ class WorkflowsClient:
         ------
         typing.Iterator[bytes]
 
-
-        Examples
-        --------
-        from vellum import Vellum
-
-        client = Vellum(
-            api_key="YOUR_API_KEY",
-        )
-        client.workflows.pull(
-            id="string",
-            format="json",
-        )
         """
         with self._client_wrapper.httpx_client.stream(
             f"v1/workflows/{jsonable_encoder(id)}/pull",
@@ -196,26 +184,6 @@ class AsyncWorkflowsClient:
         ------
         typing.AsyncIterator[bytes]
 
-
-        Examples
-        --------
-        import asyncio
-
-        from vellum import AsyncVellum
-
-        client = AsyncVellum(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.workflows.pull(
-                id="string",
-                format="json",
-            )
-
-
-        asyncio.run(main())
         """
         async with self._client_wrapper.httpx_client.stream(
             f"v1/workflows/{jsonable_encoder(id)}/pull",

vellum/client/types/__init__.py

@@ -197,6 +197,7 @@ from .metadata_filter_rule_combinator import MetadataFilterRuleCombinator
 from .metadata_filter_rule_request import MetadataFilterRuleRequest
 from .metadata_filters_request import MetadataFiltersRequest
 from .metric_definition_execution import MetricDefinitionExecution
+from .metric_definition_history_item import MetricDefinitionHistoryItem
 from .metric_definition_input import MetricDefinitionInput
 from .metric_node_result import MetricNodeResult
 from .ml_model_read import MlModelRead
@@ -685,6 +686,7 @@ __all__ = [
     "MetadataFilterRuleRequest",
     "MetadataFiltersRequest",
     "MetricDefinitionExecution",
+    "MetricDefinitionHistoryItem",
     "MetricDefinitionInput",
     "MetricNodeResult",
     "MlModelRead",

vellum/client/types/metric_definition_history_item.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
+import pydantic
+import typing
+from .vellum_variable import VellumVariable
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from ..core.pydantic_utilities import update_forward_refs
+
+
+class MetricDefinitionHistoryItem(UniversalBaseModel):
+    id: str
+    label: str = pydantic.Field()
+    """
+    A human-readable label for the metric
+    """
+
+    name: str = pydantic.Field()
+    """
+    A name that uniquely identifies this metric within its workspace
+    """
+
+    description: str
+    input_variables: typing.List[VellumVariable]
+    output_variables: typing.List[VellumVariable]
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow
+
+
+update_forward_refs(ArrayVellumValue, MetricDefinitionHistoryItem=MetricDefinitionHistoryItem)

vellum/types/metric_definition_history_item.py

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

vellum/workflows/events/node.py

@@ -1,13 +1,14 @@
-from typing import Any, Dict, Generic, Literal, Type, Union
+from typing import Any, Dict, Generic, Iterable, List, Literal, Optional, Set, Type, Union
 
-from pydantic import field_serializer
+from pydantic import ConfigDict, SerializerFunctionWrapHandler, field_serializer, model_serializer
+from pydantic.main import IncEx
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
-
 from vellum.workflows.errors import VellumError
 from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.ports.port import Port
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.types.generics import OutputsType
 
@@ -21,6 +22,15 @@ class _BaseNodeExecutionBody(UniversalBaseModel):
     def serialize_node_definition(self, node_definition: Type, _info: Any) -> Dict[str, Any]:
         return serialize_type_encoder(node_definition)
 
+    # Couldn't get this to work with model_config.exclude_none or model_config.exclude_defaults
+    # so we're excluding null invoked_ports manually here for now
+    @model_serializer(mode="wrap", when_used="json")
+    def serialize_model(self, handler: SerializerFunctionWrapHandler) -> Any:
+        serialized = super().serialize_model(handler)  # type: ignore[call-arg, arg-type]
+        if "invoked_ports" in serialized and serialized["invoked_ports"] is None:
+            del serialized["invoked_ports"]
+        return serialized
+
 
 class _BaseNodeEvent(BaseEvent):
     body: _BaseNodeExecutionBody
@@ -31,6 +41,7 @@ class _BaseNodeEvent(BaseEvent):
 
 
 NodeInputName = Union[NodeReference, AccessorExpression]
+InvokedPorts = Optional[Set["Port"]]
 
 
 class NodeExecutionInitiatedBody(_BaseNodeExecutionBody):
@@ -52,11 +63,18 @@ class NodeExecutionInitiatedEvent(_BaseNodeEvent):
 
 class NodeExecutionStreamingBody(_BaseNodeExecutionBody):
     output: BaseOutput
+    invoked_ports: InvokedPorts = None
 
     @field_serializer("output")
     def serialize_output(self, output: BaseOutput, _info: Any) -> Dict[str, Any]:
         return default_serializer(output)
 
+    @field_serializer("invoked_ports")
+    def serialize_invoked_ports(self, invoked_ports: InvokedPorts, _info: Any) -> Optional[List[Dict[str, Any]]]:
+        if not invoked_ports:
+            return None
+        return [default_serializer(port) for port in invoked_ports]
+
 
 class NodeExecutionStreamingEvent(_BaseNodeEvent):
     name: Literal["node.execution.streaming"] = "node.execution.streaming"
@@ -66,14 +84,25 @@ class NodeExecutionStreamingEvent(_BaseNodeEvent):
     def output(self) -> BaseOutput:
         return self.body.output
 
+    @property
+    def invoked_ports(self) -> InvokedPorts:
+        return self.body.invoked_ports
+
 
 class NodeExecutionFulfilledBody(_BaseNodeExecutionBody, Generic[OutputsType]):
     outputs: OutputsType
+    invoked_ports: InvokedPorts = None
 
     @field_serializer("outputs")
     def serialize_outputs(self, outputs: OutputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(outputs)
 
+    @field_serializer("invoked_ports")
+    def serialize_invoked_ports(self, invoked_ports: InvokedPorts, _info: Any) -> Optional[List[Dict[str, Any]]]:
+        if invoked_ports is None:
+            return None
+        return [default_serializer(port) for port in invoked_ports]
+
 
 class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     name: Literal["node.execution.fulfilled"] = "node.execution.fulfilled"
@@ -83,6 +112,10 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     def outputs(self) -> OutputsType:
         return self.body.outputs
 
+    @property
+    def invoked_ports(self) -> InvokedPorts:
+        return self.body.invoked_ports
+
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
     error: VellumError

vellum/workflows/events/tests/test_event.py

@@ -6,7 +6,14 @@ from uuid import UUID
 from deepdiff import DeepDiff
 
 from vellum.workflows.errors.types import VellumError, VellumErrorCode
-from vellum.workflows.events.node import NodeExecutionInitiatedBody, NodeExecutionInitiatedEvent
+from vellum.workflows.events.node import (
+    NodeExecutionFulfilledBody,
+    NodeExecutionFulfilledEvent,
+    NodeExecutionInitiatedBody,
+    NodeExecutionInitiatedEvent,
+    NodeExecutionStreamingBody,
+    NodeExecutionStreamingEvent,
+)
 from vellum.workflows.events.types import NodeParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
     WorkflowExecutionFulfilledBody,
@@ -93,10 +100,9 @@ module_root = name_parts[: name_parts.index("events")]
                     node_definition=MockNode,
                     span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     parent=WorkflowParentContext(
-                        workflow_definition=MockWorkflow,
-                        span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
-                    )
-                )
+                        workflow_definition=MockWorkflow, span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
+                    ),
+                ),
             ),
             {
                 "id": "123e4567-e89b-12d3-a456-426614174000",
@@ -126,10 +132,10 @@ module_root = name_parts[: name_parts.index("events")]
                         },
                         "type": "WORKFLOW",
                         "parent": None,
-                        "span_id": "123e4567-e89b-12d3-a456-426614174000"
+                        "span_id": "123e4567-e89b-12d3-a456-426614174000",
                     },
                     "type": "WORKFLOW_NODE",
-                    "span_id": "123e4567-e89b-12d3-a456-426614174000"
+                    "span_id": "123e4567-e89b-12d3-a456-426614174000",
                 },
             },
         ),
@@ -164,7 +170,7 @@ module_root = name_parts[: name_parts.index("events")]
                         "value": "foo",
                     },
                 },
-                "parent": None
+                "parent": None,
             },
         ),
         (
@@ -233,6 +239,78 @@ module_root = name_parts[: name_parts.index("events")]
                 "parent": None,
             },
         ),
+        (
+            NodeExecutionStreamingEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionStreamingBody(
+                    node_definition=MockNode,
+                    output=BaseOutput(
+                        name="example",
+                        value="foo",
+                    ),
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.streaming",
+                "body": {
+                    "node_definition": {
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "output": {
+                        "name": "example",
+                        "value": "foo",
+                    },
+                },
+                "parent": None,
+            },
+        ),
+        (
+            NodeExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionFulfilledBody(
+                    node_definition=MockNode,
+                    outputs=MockNode.Outputs(
+                        example="foo",
+                    ),
+                    invoked_ports={MockNode.Ports.default},
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.fulfilled",
+                "body": {
+                    "node_definition": {
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {
+                        "example": "foo",
+                    },
+                    "invoked_ports": [
+                        {
+                            "name": "default",
+                        }
+                    ],
+                },
+                "parent": None,
+            },
+        ),
     ],
     ids=[
         "workflow.execution.initiated",
@@ -240,7 +318,9 @@ module_root = name_parts[: name_parts.index("events")]
         "workflow.execution.streaming",
         "workflow.execution.fulfilled",
         "workflow.execution.rejected",
+        "node.execution.streaming",
+        "node.execution.fulfilled",
     ],
 )
 def test_event_serialization(event, expected_json):
-    assert not DeepDiff(json.loads(event.model_dump_json()), expected_json)
+    assert not DeepDiff(event.model_dump(mode="json"), expected_json)

vellum/workflows/nodes/__init__.py

@@ -1,5 +1,5 @@
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.core import (ErrorNode, InlineSubworkflowNode, MapNode, RetryNode, TemplatingNode, TryNode,)
+from vellum.workflows.nodes.core import ErrorNode, InlineSubworkflowNode, MapNode, RetryNode, TemplatingNode, TryNode
 from vellum.workflows.nodes.displayable import (
     APINode,
     CodeExecutionNode,
@@ -7,6 +7,7 @@ from vellum.workflows.nodes.displayable import (
     FinalOutputNode,
     GuardrailNode,
     InlinePromptNode,
+    NoteNode,
     PromptDeploymentNode,
     SearchNode,
     SubworkflowDeploymentNode,
@@ -28,20 +29,18 @@ __all__ = [
     "TemplatingNode",
     "TryNode",
     # Displayable Base Nodes
-    "BaseSearchNode",
     "BaseInlinePromptNode",
     "BasePromptDeploymentNode",
+    "BaseSearchNode",
     # Displayable Nodes
     "APINode",
     "CodeExecutionNode",
+    "ConditionalNode",
+    "FinalOutputNode",
     "GuardrailNode",
     "InlinePromptNode",
+    "NoteNode",
     "PromptDeploymentNode",
     "SearchNode",
-    "ConditionalNode",
-    "GuardrailNode",
     "SubworkflowDeploymentNode",
-    "FinalOutputNode",
-    "PromptDeploymentNode",
-    "SearchNode",
 ]

vellum/workflows/nodes/bases/base.py

@@ -215,7 +215,6 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     #   https://app.shortcut.com/vellum/story/4008/auto-inherit-basenodeoutputs-in-outputs-classes
     class Outputs(BaseOutputs):
         _node_class: Optional[Type["BaseNode"]] = None
-        pass
 
     class Ports(NodePorts):
         default = Port(default=True)

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

@@ -57,7 +57,7 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
         if outputs is None:
             raise NodeException(
                 message="Expected to receive outputs from Workflow Deployment",
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=VellumErrorCode.INVALID_OUTPUTS,
             )
 
         # For any outputs somehow in our final fulfilled outputs array,

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

@@ -49,7 +49,11 @@ class _TemplatingNodeMeta(BaseNodeMeta):
         if not isinstance(parent, _TemplatingNodeMeta):
             raise ValueError("TemplatingNode must be created with the TemplatingNodeMeta metaclass")
 
-        parent.__dict__["Outputs"].__annotations__["result"] = parent.get_output_type()
+        annotations = parent.__dict__["Outputs"].__annotations__
+        parent.__dict__["Outputs"].__annotations__ = {
+            **annotations,
+            "result": parent.get_output_type(),
+        }
         return parent
 
     def get_output_type(cls) -> Type:

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

@@ -1,10 +1,13 @@
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Optional, Tuple, Type, TypeVar
+import sys
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, cast
 
 from vellum.workflows.errors.types import VellumError, VellumErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
@@ -56,34 +59,60 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     class Outputs(BaseNode.Outputs):
         error: Optional[VellumError] = None
 
-    def run(self) -> Outputs:
+    def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
             parent_state=self.state,
             context=self._context,
         )
-        terminal_event = subworkflow.run()
-
-        if terminal_event.name == "workflow.execution.fulfilled":
-            outputs = self.Outputs()
-            for descriptor, value in terminal_event.outputs:
-                setattr(outputs, descriptor.name, value)
-            return outputs
-        elif terminal_event.name == "workflow.execution.paused":
+        subworkflow_stream = subworkflow.stream()
+
+        outputs: Optional[BaseOutputs] = None
+        exception: Optional[NodeException] = None
+        fulfilled_output_names: Set[str] = set()
+
+        for event in subworkflow_stream:
+            if exception:
+                continue
+
+            if event.name == "workflow.execution.streaming":
+                if event.output.is_fulfilled:
+                    fulfilled_output_names.add(event.output.name)
+                yield event.output
+            elif event.name == "workflow.execution.fulfilled":
+                outputs = event.outputs
+            elif event.name == "workflow.execution.paused":
+                exception = NodeException(
+                    code=VellumErrorCode.INVALID_OUTPUTS,
+                    message="Subworkflow unexpectedly paused within Try Node",
+                )
+            elif event.name == "workflow.execution.rejected":
+                if self.on_error_code and self.on_error_code != event.error.code:
+                    exception = NodeException(
+                        code=VellumErrorCode.INVALID_OUTPUTS,
+                        message=f"""Unexpected rejection: {event.error.code.value}.
+Message: {event.error.message}""",
+                    )
+                else:
+                    outputs = self.Outputs(error=event.error)
+
+        if exception:
+            raise exception
+
+        if outputs is None:
             raise NodeException(
                 code=VellumErrorCode.INVALID_OUTPUTS,
-                message="Subworkflow unexpectedly paused within Try Node",
-            )
-        elif self.on_error_code and self.on_error_code != terminal_event.error.code:
-            raise NodeException(
-                code=VellumErrorCode.INVALID_OUTPUTS,
-                message=f"""Unexpected rejection: {terminal_event.error.code.value}.
-Message: {terminal_event.error.message}""",
-            )
-        else:
-            return self.Outputs(
-                error=terminal_event.error,
+                message="Expected to receive outputs from Try Node's subworkflow",
             )
 
+        # For any outputs somehow in our final fulfilled outputs array,
+        # but not fulfilled by the stream.
+        for descriptor, value in outputs:
+            if descriptor.name not in fulfilled_output_names:
+                yield BaseOutput(
+                    name=descriptor.name,
+                    value=value,
+                )
+
     @classmethod
     def wrap(cls, on_error_code: Optional[VellumErrorCode] = None) -> Callable[..., Type["TryNode"]]:
         _on_error_code = on_error_code
@@ -101,11 +130,20 @@ Message: {terminal_event.error.message}""",
                 class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
                     pass
 
-            class WrappedNode(TryNode[StateType]):
-                on_error_code = _on_error_code
-
-                subworkflow = Subworkflow
-
+            dynamic_module = f"{inner_cls.__module__}.{inner_cls.__name__}.{ADORNMENT_MODULE_NAME}"
+            # This dynamic module allows calls to `type_hints` to work
+            sys.modules[dynamic_module] = ModuleType(dynamic_module)
+
+            # We use a dynamic wrapped node class to be uniquely tied to this `inner_cls` node during serialization
+            WrappedNode = type(
+                cls.__name__,
+                (TryNode,),
+                {
+                    "__module__": dynamic_module,
+                    "on_error_code": _on_error_code,
+                    "subworkflow": Subworkflow,
+                },
+            )
             return WrappedNode
 
         return decorator

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

@@ -7,6 +7,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 
@@ -23,11 +24,15 @@ def test_try_node__on_error_code__successfully_caught():
 
     # WHEN the node is run and throws a PROVIDER_ERROR
     node = TestNode(state=BaseState())
-    outputs = node.run()
-
-    # THEN the exception is retried
-    assert outputs == {
-        "error": VellumError(message="This will be caught", code=VellumErrorCode.PROVIDER_ERROR),
+    outputs = [o for o in node.run()]
+
+    # THEN the exception is caught and returned
+    assert len(outputs) == 2
+    assert set(outputs) == {
+        BaseOutput(name="value"),
+        BaseOutput(
+            name="error", value=VellumError(message="This will be caught", code=VellumErrorCode.PROVIDER_ERROR)
+        ),
     }
 
 
@@ -44,7 +49,7 @@ def test_try_node__retry_on_error_code__missed():
     # WHEN the node is run and throws a different exception
     node = TestNode(state=BaseState())
     with pytest.raises(NodeException) as exc_info:
-        node.run()
+        list(node.run())
 
     # THEN the exception is not caught
     assert exc_info.value.message == "Unexpected rejection: INTERNAL_ERROR.\nMessage: This will be missed"
@@ -78,10 +83,11 @@ def test_try_node__use_parent_inputs_and_state():
             meta=StateMeta(workflow_inputs=Inputs(foo="foo")),
         ),
     )
-    outputs = node.run()
+    outputs = list(node.run())
 
     # THEN the data is used successfully
-    assert outputs == {"value": "foo bar"}
+    assert len(outputs) == 1
+    assert outputs[-1] == BaseOutput(name="value", value="foo bar")
 
 
 def test_try_node__use_parent_execution_context():
@@ -100,7 +106,8 @@ def test_try_node__use_parent_execution_context():
             _vellum_client=Vellum(api_key="test-key"),
         )
     )
-    outputs = node.run()
+    outputs = list(node.run())
 
     # THEN the inner node had access to the key
-    assert outputs == {"key": "test-key"}
+    assert len(outputs) == 1
+    assert outputs[-1] == BaseOutput(name="key", value="test-key")