vellum-ai 0.14.25__py3-none-any.whl → 0.14.27__py3-none-any.whl

vellum/workflows/nodes/displayable/conftest.py

@@ -0,0 +1,117 @@
+import pytest
+from uuid import UUID
+
+from vellum.workflows.events.types import (
+    CodeResourceDefinition,
+    NodeParentContext,
+    WorkflowDeploymentParentContext,
+    WorkflowParentContext,
+)
+
+
+@pytest.fixture
+def mock_complex_parent_context():
+    # TODO: We were able to confirm that this parent context caused our serialization to hang, but don't know why yet.
+    # We should try to reduce this example further to isolate a minimal example that reproduces the issue.
+    return NodeParentContext(
+        span_id=UUID("d697f8c8-b363-4154-8469-eb4f9fb5e445"),
+        parent=WorkflowParentContext(
+            span_id=UUID("a0c68884-22c3-4ac9-8476-8747884d80e1"),
+            parent=NodeParentContext(
+                span_id=UUID("46163407-71f7-40f2-9f66-872d4b338fcc"),
+                parent=WorkflowParentContext(
+                    span_id=UUID("0ddf01e7-d0c3-426c-af27-d8bfb22fcdd5"),
+                    parent=NodeParentContext(
+                        span_id=UUID("79a6c926-b5f3-4ede-b2f8-4bb6f0c086ba"),
+                        parent=WorkflowParentContext(
+                            span_id=UUID("530a56fe-90fd-4f4c-b905-457975fb3e10"),
+                            parent=WorkflowDeploymentParentContext(
+                                span_id=UUID("3e10a8c2-558c-4ef7-926d-7b79ebc7cba9"),
+                                parent=NodeParentContext(
+                                    span_id=UUID("a3cd4086-c0b9-4dff-88f3-3e2191b8a2a7"),
+                                    parent=WorkflowParentContext(
+                                        span_id=UUID("c2ba7577-8d24-49b1-aa92-b9ace8244090"),
+                                        workflow_definition=CodeResourceDefinition(
+                                            id=UUID("2e2d5c56-49b7-48b5-82fa-e80e72768b9c"),
+                                            name="Workflow",
+                                            module=["e81a6124-2c57-4c39-938c-ab6059059ff2", "workflow"],
+                                        ),
+                                    ),
+                                    node_definition=CodeResourceDefinition(
+                                        id=UUID("23d25675-f377-4450-916f-39ebee5c8ea9"),
+                                        name="SubworkflowDeployment",
+                                        module=[
+                                            "e81a6124-2c57-4c39-938c-ab6059059ff2",
+                                            "nodes",
+                                            "subworkflow_deployment",
+                                        ],
+                                    ),
+                                ),
+                                deployment_id=UUID("cfc99610-2869-4506-b106-3fd7ce0bbb15"),
+                                deployment_name="my-deployment",
+                                deployment_history_item_id=UUID("13f31aae-29fd-4066-a4ec-c7687faebae3"),
+                                release_tag_id=UUID("2d03987a-dcb5-49b9-981e-5e871c8f5d97"),
+                                release_tag_name="LATEST",
+                                external_id=None,
+                                metadata=None,
+                                workflow_version_id=UUID("7eaae816-b5f3-436d-8597-e8c3e4a32958"),
+                            ),
+                            workflow_definition=CodeResourceDefinition(
+                                id=UUID("2e2d5c56-49b7-48b5-82fa-e80e72768b9c"),
+                                name="Workflow",
+                                module=["3e10a8c2-558c-4ef7-926d-7b79ebc7cba9", "workflow"],
+                            ),
+                        ),
+                        node_definition=CodeResourceDefinition(
+                            id=UUID("42c8adc2-a0d6-499e-81a4-e2e02d7beba9"),
+                            name="MyNode",
+                            module=[
+                                "3e10a8c2-558c-4ef7-926d-7b79ebc7cba9",
+                                "nodes",
+                                "my_node",
+                            ],
+                        ),
+                    ),
+                    workflow_definition=CodeResourceDefinition(
+                        id=UUID("b8563da0-7fd4-42e0-a75e-9ef037fca5a1"),
+                        name="MyNodeWorkflow",
+                        module=[
+                            "3e10a8c2-558c-4ef7-926d-7b79ebc7cba9",
+                            "nodes",
+                            "my_node",
+                            "workflow",
+                        ],
+                    ),
+                ),
+                node_definition=CodeResourceDefinition(
+                    id=UUID("d44aee53-3b6e-41fd-8b7a-908cb2c77821"),
+                    name="RetryNode",
+                    module=[
+                        "3e10a8c2-558c-4ef7-926d-7b79ebc7cba9",
+                        "nodes",
+                        "my_node",
+                        "nodes",
+                        "my_prompt",
+                        "MyPrompt",
+                        "<adornment>",
+                    ],
+                ),
+            ),
+            workflow_definition=CodeResourceDefinition(
+                id=UUID("568a28dd-7134-436e-a5f4-790675212b51"),
+                name="Subworkflow",
+                module=["vellum", "workflows", "nodes", "utils"],
+            ),
+        ),
+        node_definition=CodeResourceDefinition(
+            id=UUID("86a34e5c-2652-49f0-9f9e-c653cf70029a"),
+            name="MyPrompt",
+            module=[
+                "3e10a8c2-558c-4ef7-926d-7b79ebc7cba9",
+                "nodes",
+                "my_node",
+                "nodes",
+                "my_prompt",
+            ],
+        ),
+    )

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

@@ -52,19 +52,18 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
                 message="Metric execution must have one output named 'score' with type 'float'",
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
             )
-
-        log = metric_outputs.get("log")
-
-        if log is not None and not isinstance(log, str):
-            raise NodeException(
-                message="Metric execution log output must be of type 'str'",
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-            )
-        if log:
-            metric_outputs.pop("log")
-
         metric_outputs.pop("score")
 
+        if "log" in metric_outputs:
+            log = metric_outputs.pop("log") or ""
+            if not isinstance(log, str):
+                raise NodeException(
+                    message="Metric execution log output must be of type 'str'",
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                )
+        else:
+            log = None
+
         return self.Outputs(score=score, log=log, **metric_outputs)
 
     def _compile_metric_inputs(self) -> List[MetricDefinitionInput]:

vellum/workflows/nodes/displayable/guardrail_node/test_node.py

@@ -0,0 +1,38 @@
+import pytest
+
+from vellum import TestSuiteRunMetricNumberOutput
+from vellum.client.types.metric_definition_execution import MetricDefinitionExecution
+from vellum.client.types.test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
+from vellum.workflows.nodes.displayable.guardrail_node.node import GuardrailNode
+
+
+@pytest.mark.parametrize("log_value", [None, ""], ids=["None", "Empty"])
+def test_run_guardrail_node__empty_log(vellum_client, log_value):
+    """Confirm that we can successfully invoke a Guardrail Node"""
+
+    # GIVEN a Guardrail Node
+    class MyGuard(GuardrailNode):
+        metric_definition = "example_metric_definition"
+        metric_inputs = {}
+
+    # AND we know that the guardrail node will return a blank log
+    mock_metric_execution = MetricDefinitionExecution(
+        outputs=[
+            TestSuiteRunMetricNumberOutput(
+                name="score",
+                value=0.6,
+            ),
+            TestSuiteRunMetricStringOutput(
+                name="log",
+                value=log_value,
+            ),
+        ],
+    )
+    vellum_client.metric_definitions.execute_metric_definition.return_value = mock_metric_execution
+
+    # WHEN we run the Guardrail Node
+    outputs = MyGuard().run()
+
+    # THEN the workflow should have completed successfully
+    assert outputs.score == 0.6
+    assert outputs.log == ""

vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -1,8 +1,11 @@
 import pytest
 from dataclasses import dataclass
+import json
 from uuid import uuid4
 from typing import Any, Iterator, List
 
+from httpx import Response
+
 from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.chat_message import ChatMessage
@@ -17,6 +20,7 @@ from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.prompt_request_chat_history_input import PromptRequestChatHistoryInput
 from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
 from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows.context import execution_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
@@ -230,3 +234,48 @@ def test_inline_prompt_node__chat_history_inputs(vellum_adhoc_prompt_client):
         ),
     ]
     assert mock_api.call_args.kwargs["input_variables"][0].type == "CHAT_HISTORY"
+
+
+@pytest.mark.timeout(5)
+def test_inline_prompt_node__parent_context(mock_httpx_transport, mock_complex_parent_context):
+    # GIVEN a prompt node
+    class MyNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {}
+
+    # AND a known response from the httpx client
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Test"),
+    ]
+    execution_id = str(uuid4())
+    events: List[ExecutePromptEvent] = [
+        InitiatedExecutePromptEvent(execution_id=execution_id),
+        FulfilledExecutePromptEvent(
+            execution_id=execution_id,
+            outputs=expected_outputs,
+        ),
+    ]
+    text = "\n".join(e.model_dump_json() for e in events)
+
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=text,
+    )
+
+    # WHEN the node is run with the complex parent context
+    trace_id = uuid4()
+    with execution_context(
+        parent_context=mock_complex_parent_context,
+        trace_id=trace_id,
+    ):
+        outputs = list(MyNode().run())
+
+    # THEN the last output is as expected
+    assert outputs[-1].value == "Test"
+
+    # AND the prompt is executed with the correct execution context
+    call_request_args = mock_httpx_transport.handle_request.call_args_list[0][0][0]
+    request_execution_context = json.loads(call_request_args.read().decode("utf-8"))["execution_context"]
+    assert request_execution_context["trace_id"] == str(trace_id)
+    assert request_execution_context["parent_context"]

vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py

@@ -1,7 +1,10 @@
 import pytest
+import json
 from uuid import uuid4
 from typing import Any, Iterator, List
 
+from httpx import Response
+
 from vellum.client.types.chat_history_input_request import ChatHistoryInputRequest
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.chat_message_request import ChatMessageRequest
@@ -9,7 +12,9 @@ from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
 from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
 from vellum.client.types.json_input_request import JsonInputRequest
+from vellum.client.types.prompt_output import PromptOutput
 from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows.context import execution_context
 from vellum.workflows.nodes.displayable.prompt_deployment_node.node import PromptDeploymentNode
 
 
@@ -94,3 +99,47 @@ def test_run_node__any_array_input(vellum_client):
     assert call_kwargs["inputs"] == [
         JsonInputRequest(name="fruits", value=["apple", "banana", "cherry"]),
     ]
+
+
+@pytest.mark.timeout(5)
+def test_prompt_deployment_node__parent_context_serialization(mock_httpx_transport, mock_complex_parent_context):
+    # GIVEN a prompt deployment node
+    class MyNode(PromptDeploymentNode):
+        deployment = "example_prompt_deployment"
+        prompt_inputs = {}
+
+    # AND a known response from the httpx client
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Test"),
+    ]
+    execution_id = str(uuid4())
+    events: List[ExecutePromptEvent] = [
+        InitiatedExecutePromptEvent(execution_id=execution_id),
+        FulfilledExecutePromptEvent(
+            execution_id=execution_id,
+            outputs=expected_outputs,
+        ),
+    ]
+    text = "\n".join(e.model_dump_json() for e in events)
+
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=text,
+    )
+
+    # WHEN the node is run with a complex parent context
+    trace_id = uuid4()
+    with execution_context(
+        parent_context=mock_complex_parent_context,
+        trace_id=trace_id,
+    ):
+        outputs = list(MyNode().run())
+
+    # THEN the last output is as expected
+    assert outputs[-1].value == "Test"
+
+    # AND the prompt is executed with the correct execution context
+    call_request_args = mock_httpx_transport.handle_request.call_args_list[0][0][0]
+    request_execution_context = json.loads(call_request_args.read().decode("utf-8"))["execution_context"]
+    assert request_execution_context["trace_id"] == str(trace_id)
+    assert request_execution_context["parent_context"]

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

@@ -122,13 +122,10 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
         return compiled_inputs
 
     def run(self) -> Iterator[BaseOutput]:
-        current_context = get_execution_context()
-        parent_context = (
-            current_context.parent_context.model_dump(mode="json") if current_context.parent_context else None
-        )
+        execution_context = get_execution_context()
         request_options = self.request_options or RequestOptions()
         request_options["additional_body_parameters"] = {
-            "execution_context": {"parent_context": parent_context, "trace_id": current_context.trace_id},
+            "execution_context": execution_context.model_dump(mode="json"),
             **request_options.get("additional_body_parameters", {}),
         }
 

vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py

@@ -1,8 +1,11 @@
 import pytest
 from datetime import datetime
+import json
 from uuid import uuid4
 from typing import Any, Iterator, List
 
+from httpx import Response
+
 from vellum.client.core.api_error import ApiError
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.chat_message_request import ChatMessageRequest
@@ -13,6 +16,7 @@ from vellum.client.types.workflow_request_json_input_request import WorkflowRequ
 from vellum.client.types.workflow_request_number_input_request import WorkflowRequestNumberInputRequest
 from vellum.client.types.workflow_result_event import WorkflowResultEvent
 from vellum.client.types.workflow_stream_event import WorkflowStreamEvent
+from vellum.workflows.context import execution_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
@@ -405,3 +409,62 @@ def test_subworkflow_deployment_node__immediate_api_error__node_exception(vellum
     # THEN the node raises the correct NodeException
     assert e.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert e.value.message == "Not found"
+
+
+@pytest.mark.timeout(5)
+def test_prompt_deployment_node__parent_context_serialization(mock_httpx_transport, mock_complex_parent_context):
+    # GIVEN a prompt deployment node
+    class MyNode(SubworkflowDeploymentNode):
+        deployment = "example_subworkflow_deployment"
+        subworkflow_inputs = {}
+
+    # AND a known response from the httpx client
+    execution_id = str(uuid4())
+    events: List[WorkflowStreamEvent] = [
+        WorkflowExecutionWorkflowResultEvent(
+            execution_id=execution_id,
+            data=WorkflowResultEvent(
+                id=str(uuid4()),
+                state="INITIATED",
+                ts=datetime.now(),
+            ),
+        ),
+        WorkflowExecutionWorkflowResultEvent(
+            execution_id=execution_id,
+            data=WorkflowResultEvent(
+                id=str(uuid4()),
+                state="FULFILLED",
+                ts=datetime.now(),
+                outputs=[
+                    WorkflowOutputString(
+                        id=str(uuid4()),
+                        name="final-output_copy",  # Note the hyphen here
+                        value="Test",
+                    )
+                ],
+            ),
+        ),
+    ]
+    text = "\n".join(e.model_dump_json() for e in events)
+
+    mock_httpx_transport.handle_request.return_value = Response(
+        status_code=200,
+        text=text,
+    )
+
+    # WHEN the node is run with a complex parent context
+    trace_id = uuid4()
+    with execution_context(
+        parent_context=mock_complex_parent_context,
+        trace_id=trace_id,
+    ):
+        outputs = list(MyNode().run())
+
+    # THEN the last output is as expected
+    assert outputs[-1].value == "Test"
+
+    # AND the prompt is executed with the correct execution context
+    call_request_args = mock_httpx_transport.handle_request.call_args_list[0][0][0]
+    request_execution_context = json.loads(call_request_args.read().decode("utf-8"))["execution_context"]
+    assert request_execution_context["trace_id"] == str(trace_id)
+    assert request_execution_context["parent_context"]

vellum/workflows/references/workflow_input.py

@@ -35,6 +35,9 @@ class WorkflowInputReference(BaseDescriptor[_InputType], Generic[_InputType]):
         if state.meta.parent:
             return self.resolve(state.meta.parent)
 
+        if type(None) in self.types:
+            return cast(_InputType, None)
+
         raise NodeException(f"Missing required Workflow input: {self._name}", code=WorkflowErrorCode.INVALID_INPUTS)
 
     def __repr__(self) -> str:

vellum/workflows/runner/runner.py

@@ -321,6 +321,7 @@ class WorkflowRunner(Generic[StateType]):
                 )
             )
         except NodeException as e:
+            logger.info(e)
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
                     trace_id=node.state.meta.trace_id,
@@ -333,6 +334,7 @@ class WorkflowRunner(Generic[StateType]):
                 )
             )
         except WorkflowInitializationException as e:
+            logger.info(e)
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
                     trace_id=node.state.meta.trace_id,

{vellum_ai-0.14.25.dist-info → vellum_ai-0.14.27.dist-info}/METADATA

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