vellum-ai 0.14.7__py3-none-any.whl → 0.14.9__py3-none-any.whl

vellum/workflows/expressions/tests/test_expressions.py

@@ -0,0 +1,310 @@
+import pytest
+
+from vellum.workflows.expressions.greater_than import GreaterThanExpression
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+from vellum.workflows.expressions.less_than import LessThanExpression
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.state.base import BaseState
+
+
+class Comparable:
+    """A custom class with two values, where comparisons use a computed metric (multiplication)."""
+
+    def __init__(self, value1, value2):
+        self.value1 = value1  # First numerical value
+        self.value2 = value2  # Second numerical value
+
+    def computed_value(self):
+        return self.value1 * self.value2  # Multiply for comparison
+
+    def __ge__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() >= other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() >= other
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() > other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() > other
+        return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() <= other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() <= other
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() < other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() < other
+        return NotImplemented
+
+
+class NonComparable:
+    """A custom class that does not support comparisons."""
+
+    def __init__(self, value1, value2):
+        self.value1 = value1
+        self.value2 = value2
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_greater_than_or_equal_to():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state) is True  # 20 >= 20
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj3).resolve(state) is True  # 20 >= 18
+    assert GreaterThanOrEqualToExpression(lhs=obj3, rhs=obj4).resolve(state) is False  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=19).resolve(state) is True  # 20 >= 19
+    assert GreaterThanOrEqualToExpression(lhs=obj3, rhs=20).resolve(state) is False  # 18 < 20
+
+
+def test_greater_than_or_equal_to_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_greater_than_or_equal_to_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_greater_than():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state) is False  # 20 > 20
+    assert GreaterThanExpression(lhs=obj1, rhs=obj3).resolve(state) is True  # 20 > 18
+    assert GreaterThanExpression(lhs=obj3, rhs=obj4).resolve(state) is False  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert GreaterThanExpression(lhs=obj1, rhs=19).resolve(state) is True  # 20 > 19
+    assert GreaterThanExpression(lhs=obj3, rhs=20).resolve(state) is False  # 18 < 20
+
+
+def test_greater_than_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_greater_than_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_less_than_or_equal_to():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state) is True  # 20 <= 20
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=obj3).resolve(state) is False  # 20 > 18
+    assert LessThanOrEqualToExpression(lhs=obj3, rhs=obj4).resolve(state) is True  # 18 <= 25
+
+    # WHEN comparing to raw numbers
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=21).resolve(state) is True  # 20 <= 21
+    assert LessThanOrEqualToExpression(lhs=obj3, rhs=17).resolve(state) is False  # 18 > 17
+
+
+def test_less_than_or_equal_to_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_less_than_or_equal_to_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_less_than():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert LessThanExpression(lhs=obj1, rhs=obj2).resolve(state) is False  # 20 < 20
+    assert LessThanExpression(lhs=obj1, rhs=obj3).resolve(state) is False  # 20 < 18
+    assert LessThanExpression(lhs=obj3, rhs=obj4).resolve(state) is True  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert LessThanExpression(lhs=obj1, rhs=21).resolve(state) is True  # 20 < 21
+    assert LessThanExpression(lhs=obj3, rhs=17).resolve(state) is False  # 18 > 17
+
+
+def test_less_than_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_less_than_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'NonComparable' and 'Comparable'"

vellum/workflows/expressions/tests/test_parse_json.py

@@ -0,0 +1,31 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+def test_parse_json_invalid_json():
+    # GIVEN an invalid JSON string
+    state = BaseState()
+    expression = ConstantValueReference('{"key": value}').parse_json()
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Failed to parse JSON" in str(exc_info.value)
+
+
+def test_parse_json_invalid_type():
+    # GIVEN a non-string value
+    state = BaseState()
+    expression = ConstantValueReference(123).parse_json()
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected a string, but got 123 of type <class 'int'>" == str(exc_info.value)

vellum/workflows/nodes/bases/base.py

@@ -318,9 +318,12 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
             original_base = get_original_base(self.__class__)
 
             args = get_args(original_base)
-            state_type = args[0]
 
-            if isinstance(state_type, TypeVar):
+            if args and len(args) > 0:
+                state_type = args[0]
+                if isinstance(state_type, TypeVar):
+                    state_type = BaseState
+            else:
                 state_type = BaseState
 
             self.state = state_type()

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -1,7 +1,10 @@
+import pytest
+
 from vellum import ExecuteApiResponse, VellumSecret as ClientVellumSecret
+from vellum.client.core.api_error import ApiError
 from vellum.workflows.constants import APIRequestMethod, AuthorizationType
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes import APINode
-from vellum.workflows.state import BaseState
 from vellum.workflows.types.core import VellumSecret
 
 
@@ -25,10 +28,39 @@ def test_run_workflow__secrets(vellum_client):
         }
         bearer_token_value = VellumSecret(name="secret")
 
-    node = SimpleBaseAPINode(state=BaseState())
+    node = SimpleBaseAPINode()
     terminal = node.run()
 
     assert vellum_client.execute_api.call_count == 1
     bearer_token = vellum_client.execute_api.call_args.kwargs["bearer_token"]
     assert bearer_token == ClientVellumSecret(name="secret")
     assert terminal.headers == {"X-Response-Header": "bar"}
+
+
+def test_api_node_raises_error_when_api_call_fails(vellum_client):
+    # GIVEN an API call that fails
+    vellum_client.execute_api.side_effect = ApiError(status_code=400, body="API Error")
+
+    class SimpleAPINode(APINode):
+        method = APIRequestMethod.GET
+        authorization_type = AuthorizationType.BEARER_TOKEN
+        url = "https://api.vellum.ai"
+        body = {
+            "key": "value",
+        }
+        headers = {
+            "X-Test-Header": "foo",
+        }
+        bearer_token_value = VellumSecret(name="api_key")
+
+    node = SimpleAPINode()
+
+    # WHEN we run the node
+    with pytest.raises(NodeException) as excinfo:
+        node.run()
+
+    # THEN an exception should be raised
+    assert "Failed to prepare HTTP request" in str(excinfo.value)
+
+    # AND the API call should have been made
+    assert vellum_client.execute_api.call_count == 1

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -89,7 +89,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
                 url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
             )
         except ApiError as e:
-            NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.NODE_EXECUTION)
+            raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.NODE_EXECUTION)
 
         return self.Outputs(
             json=vellum_response.json_,

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -19,6 +19,7 @@ from vellum import (
     VellumError,
     VellumValue,
 )
+from vellum.client.core.api_error import ApiError
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -103,14 +104,23 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
             input_values = self._compile_code_inputs()
             expected_output_type = primitive_type_to_vellum_variable_type(output_type)
 
-            code_execution_result = self._context.vellum_client.execute_code(
-                input_values=input_values,
-                code=code,
-                runtime=self.runtime,
-                output_type=expected_output_type,
-                packages=self.packages or [],
-                request_options=self.request_options,
-            )
+            try:
+                code_execution_result = self._context.vellum_client.execute_code(
+                    input_values=input_values,
+                    code=code,
+                    runtime=self.runtime,
+                    output_type=expected_output_type,
+                    packages=self.packages or [],
+                    request_options=self.request_options,
+                )
+            except ApiError as e:
+                if e.status_code == 400 and isinstance(e.body, dict) and "message" in e.body:
+                    raise NodeException(
+                        message=e.body["message"],
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
+
+                raise
 
             if code_execution_result.output.type != expected_output_type:
                 actual_type = code_execution_result.output.type

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -5,6 +5,7 @@ from typing import Any, List, Union
 from pydantic import BaseModel
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum.client.errors.bad_request_error import BadRequestError
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
@@ -17,6 +18,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.types.core import Json
 
 
 def test_run_node__happy_path(vellum_client):
@@ -690,3 +692,54 @@ def main():
         "result": [ChatMessage(role="USER", content=StringChatMessageContent(value="Hello, world!"))],
         "log": "",
     }
+
+
+def test_run_node__execute_code_api_fails__node_exception(vellum_client):
+    # GIVEN a node that will throw a JSON.parse error
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Json]):
+        code = """\
+async function main(inputs: {
+  data: string,
+}): Promise<string> {
+  return JSON.parse(inputs.data)
+}
+"""
+        code_inputs = {
+            "data": "not a valid json string",
+        }
+        runtime = "TYPESCRIPT_5_3_3"
+
+    # AND the execute_code API will fail
+    message = """\
+Code execution error (exit code 1): undefined:1
+not a valid json string
+ ^
+
+SyntaxError: Unexpected token 'o', \"not a valid\"... is not valid JSON
+    at JSON.parse (<anonymous>)
+    at Object.eval (eval at execute (/workdir/runner.js:16:18), <anonymous>:40:40)
+    at step (eval at execute (/workdir/runner.js:16:18), <anonymous>:32:23)
+    at Object.eval [as next] (eval at execute (/workdir/runner.js:16:18), <anonymous>:13:53)
+    at eval (eval at execute (/workdir/runner.js:16:18), <anonymous>:7:71)
+    at new Promise (<anonymous>)
+    at __awaiter (eval at execute (/workdir/runner.js:16:18), <anonymous>:3:12)
+    at Object.main (eval at execute (/workdir/runner.js:16:18), <anonymous>:38:12)
+    at execute (/workdir/runner.js:17:33)
+    at Interface.<anonymous> (/workdir/runner.js:58:5)
+
+Node.js v21.7.3
+"""
+    vellum_client.execute_code.side_effect = BadRequestError(
+        body={
+            "message": message,
+            "log": "",
+        }
+    )
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # AND the error should contain the execution error details
+    assert exc_info.value.message == message

vellum/workflows/runner/runner.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
 from copy import deepcopy
+from dataclasses import dataclass
 import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
@@ -63,6 +64,12 @@ ExternalInputsArg = Dict[ExternalInputReference, Any]
 BackgroundThreadItem = Union[BaseState, WorkflowEvent, None]
 
 
+@dataclass
+class ActiveNode(Generic[StateType]):
+    node: BaseNode[StateType]
+    was_outputs_streamed: bool = False
+
+
 class WorkflowRunner(Generic[StateType]):
     _entrypoints: Iterable[Type[BaseNode]]
 
@@ -136,7 +143,7 @@ class WorkflowRunner(Generic[StateType]):
         self._dependencies: Dict[Type[BaseNode], Set[Type[BaseNode]]] = defaultdict(set)
         self._state_forks: Set[StateType] = {self._initial_state}
 
-        self._active_nodes_by_execution_id: Dict[UUID, BaseNode[StateType]] = {}
+        self._active_nodes_by_execution_id: Dict[UUID, ActiveNode[StateType]] = {}
         self._cancel_signal = cancel_signal
         self._execution_context = init_execution_context or get_execution_context()
         self._parent_context = self._execution_context.parent_context
@@ -404,7 +411,7 @@ class WorkflowRunner(Generic[StateType]):
             current_parent = get_parent_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] = node
+            self._active_nodes_by_execution_id[node_span_id] = ActiveNode(node=node)
 
             worker_thread = Thread(
                 target=self._context_run_work_item,
@@ -413,10 +420,11 @@ class WorkflowRunner(Generic[StateType]):
             worker_thread.start()
 
     def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[WorkflowError]:
-        node = self._active_nodes_by_execution_id.get(event.span_id)
-        if not node:
+        active_node = self._active_nodes_by_execution_id.get(event.span_id)
+        if not active_node:
             return None
 
+        node = active_node.node
         if event.name == "node.execution.rejected":
             self._active_nodes_by_execution_id.pop(event.span_id)
             return event.error
@@ -431,6 +439,7 @@ class WorkflowRunner(Generic[StateType]):
                 if node_output_descriptor.name != event.output.name:
                     continue
 
+                active_node.was_outputs_streamed = True
                 self._workflow_event_outer_queue.put(
                     self._stream_workflow_event(
                         BaseOutput(
@@ -447,6 +456,26 @@ class WorkflowRunner(Generic[StateType]):
 
         if event.name == "node.execution.fulfilled":
             self._active_nodes_by_execution_id.pop(event.span_id)
+            if not active_node.was_outputs_streamed:
+                for event_node_output_descriptor, node_output_value in event.outputs:
+                    for workflow_output_descriptor in self.workflow.Outputs:
+                        node_output_descriptor = workflow_output_descriptor.instance
+                        if not isinstance(node_output_descriptor, OutputReference):
+                            continue
+                        if node_output_descriptor.outputs_class != event.node_definition.Outputs:
+                            continue
+                        if node_output_descriptor.name != event_node_output_descriptor.name:
+                            continue
+
+                        self._workflow_event_outer_queue.put(
+                            self._stream_workflow_event(
+                                BaseOutput(
+                                    name=workflow_output_descriptor.name,
+                                    value=node_output_value,
+                                )
+                            )
+                        )
+
             self._handle_invoked_ports(node.state, event.invoked_ports)
 
             return None

vellum/workflows/state/encoder.py

@@ -8,6 +8,7 @@ from typing import Any, Callable, Dict, Type
 
 from pydantic import BaseModel
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.ports.port import Port
@@ -22,7 +23,7 @@ class DefaultStateEncoder(JSONEncoder):
             return dict(obj)
 
         if isinstance(obj, (BaseInputs, BaseOutputs)):
-            return {descriptor.name: value for descriptor, value in obj}
+            return {descriptor.name: value for descriptor, value in obj if value is not undefined}
 
         if isinstance(obj, (BaseOutput, Port)):
             return obj.serialize()

{vellum_ai-0.14.7.dist-info → vellum_ai-0.14.9.dist-info}/METADATA

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