vellum-ai 1.8.1__py3-none-any.whl → 1.8.3__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.8.1",
+            "User-Agent": "vellum-ai/1.8.3",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.8.1",
+            "X-Fern-SDK-Version": "1.8.3",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/client/types/integration_name.py

@@ -41,6 +41,7 @@ IntegrationName = typing.Union[
         "JIRA",
         "KLAVIYO",
         "PAGERDUTY",
+        "PARSERA",
         "PEOPLEDATALABS",
         "PERPLEXITY",
         "POSTHOG",

vellum/workflows/expressions/concat.py

@@ -26,7 +26,10 @@ class ConcatExpression(BaseDescriptor[list], Generic[LHS, RHS]):
 
         if not isinstance(lval, list):
             raise InvalidExpressionException(f"Expected LHS to be a list, got {type(lval)}")
-        if not isinstance(rval, list):
-            raise InvalidExpressionException(f"Expected RHS to be a list, got {type(rval)}")
 
-        return lval + rval
+        # If RHS is a list, concatenate normally
+        if isinstance(rval, list):
+            return lval + rval
+        # If RHS is not a list, append it as a single item
+        else:
+            return lval + [rval]

vellum/workflows/expressions/tests/test_concat.py

@@ -38,16 +38,71 @@ def test_concat_expression_lhs_fail():
     assert "Expected LHS to be a list, got <class 'int'>" in str(exc_info.value)
 
 
-def test_concat_expression_rhs_fail():
-    # GIVEN a list lhs and a non-list rhs
+def test_concat_expression_with_single_item():
+    # GIVEN a list and a single item
     state = TestState()
     lhs_ref = ConstantValueReference([1, 2, 3])
-    rhs_ref = ConstantValueReference(False)
+    rhs_ref = ConstantValueReference(4)
     concat_expr = lhs_ref.concat(rhs_ref)
 
-    # WHEN we attempt to resolve the expression
-    with pytest.raises(InvalidExpressionException) as exc_info:
-        concat_expr.resolve(state)
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
 
-    # THEN an exception should be raised
-    assert "Expected RHS to be a list, got <class 'bool'>" in str(exc_info.value)
+    # THEN the item should be appended to the list
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_with_string():
+    # GIVEN a list and a string item
+    state = TestState()
+    lhs_ref = ConstantValueReference(["hello", "world"])
+    rhs_ref = ConstantValueReference("!")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the string should be appended to the list
+    assert result == ["hello", "world", "!"]
+
+
+def test_concat_expression_with_none():
+    # GIVEN a list and None item
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference(None)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN None should be appended to the list
+    assert result == [1, 2, None]
+
+
+def test_concat_expression_with_list_item():
+    # GIVEN a list and another list
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference([3, 4])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated normally
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_empty_list():
+    # GIVEN an empty list and an item
+    state = TestState()
+    lhs_ref: ConstantValueReference[list] = ConstantValueReference([])
+    rhs_ref = ConstantValueReference("first")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the item should be appended to the empty list
+    assert result == ["first"]

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

@@ -1,5 +1,6 @@
 from abc import abstractmethod
-from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union
+from itertools import chain
+from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union, cast
 
 from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
 from vellum.client.core import RequestOptions
@@ -60,15 +61,26 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
         except ApiError as e:
             self._handle_api_error(e)
 
-        # We don't use the INITIATED event anyway, so we can just skip it
-        # and use the exception handling to catch other api level errors
         try:
-            next(prompt_event_stream)
+            first_event = next(prompt_event_stream)
         except ApiError as e:
             self._handle_api_error(e)
+        else:
+            if first_event.state == "REJECTED":
+                workflow_error = vellum_error_to_workflow_error(first_event.error)
+                raise NodeException.of(workflow_error)
+            if first_event.state != "INITIATED":
+                prompt_event_stream = cast(
+                    Union[Iterator[AdHocExecutePromptEvent], Iterator[ExecutePromptEvent]],
+                    chain([first_event], prompt_event_stream),
+                )
 
         outputs: Optional[List[PromptOutput]] = None
+        exception: Optional[NodeException] = None
         for event in prompt_event_stream:
+            if exception:
+                continue
+
             if event.state == "INITIATED":
                 continue
             elif event.state == "STREAMING":
@@ -78,7 +90,10 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
                 yield BaseOutput(name="results", value=event.outputs)
             elif event.state == "REJECTED":
                 workflow_error = vellum_error_to_workflow_error(event.error)
-                raise NodeException.of(workflow_error)
+                exception = NodeException.of(workflow_error)
+
+        if exception:
+            raise exception
 
         return outputs
 

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

@@ -1,3 +1,4 @@
+from itertools import chain
 import json
 from uuid import uuid4
 from typing import Callable, ClassVar, Generator, Generic, Iterator, List, Optional, Set, Tuple, Union
@@ -225,13 +226,16 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         except ApiError as e:
             self._handle_api_error(e)
 
-        if not self.settings or (self.settings and self.settings.stream_enabled):
-            # We don't use the INITIATED event anyway, so we can just skip it
-            # and use the exception handling to catch other api level errors
-            try:
-                next(prompt_event_stream)
-            except ApiError as e:
-                self._handle_api_error(e)
+        try:
+            first_event = next(prompt_event_stream)
+        except ApiError as e:
+            self._handle_api_error(e)
+        else:
+            if first_event.state == "REJECTED":
+                workflow_error = vellum_error_to_workflow_error(first_event.error)
+                raise NodeException.of(workflow_error)
+            if first_event.state != "INITIATED":
+                prompt_event_stream = chain([first_event], prompt_event_stream)
 
         outputs: Optional[List[PromptOutput]] = None
         for event in prompt_event_stream:

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -25,6 +25,7 @@ from vellum import (
     PromptRequestStringInput,
     PromptRequestVideoInput,
     PromptSettings,
+    RejectedExecutePromptEvent,
     RichTextPromptBlock,
     StringVellumValue,
     VariablePromptBlock,
@@ -32,6 +33,7 @@ from vellum import (
     VellumAudioRequest,
     VellumDocument,
     VellumDocumentRequest,
+    VellumError,
     VellumImage,
     VellumImageRequest,
     VellumVideo,
@@ -896,3 +898,43 @@ def test_inline_prompt_node__json_output_with_markdown_code_blocks(vellum_adhoc_
     json_output = outputs[2]
     assert json_output.name == "json"
     assert json_output.value == expected_json
+
+
+def test_inline_prompt_node__provider_error_from_api(vellum_adhoc_prompt_client):
+    """
+    Tests that InlinePromptNode raises NodeException with PROVIDER_ERROR code when first event is REJECTED.
+    """
+
+    # GIVEN an InlinePromptNode with basic configuration
+    class TestNode(InlinePromptNode):
+        ml_model = "test-model"
+        blocks = []
+        prompt_inputs = {}
+
+    # AND the API returns a REJECTED event as the first event with a provider error
+    provider_error = VellumError(
+        code="PROVIDER_ERROR",
+        message="Provider rate limit exceeded",
+    )
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            RejectedExecutePromptEvent(
+                execution_id=execution_id,
+                error=provider_error,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = TestNode()
+
+    # THEN it should raise a NodeException with PROVIDER_ERROR error code
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # AND the exception should have the correct error code
+    assert excinfo.value.code == WorkflowErrorCode.PROVIDER_ERROR

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

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Generic, Tuple, Type, TypeVar, get_args
+from typing import Any, Dict, Generic, Tuple, Type, TypeVar, get_args, get_origin
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
@@ -74,6 +74,12 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
                 if descriptor_type == declared_output_type:
                     type_mismatch = False
                     break
+                if (
+                    get_origin(descriptor_type) == declared_output_type
+                    or get_origin(declared_output_type) == descriptor_type
+                ):
+                    type_mismatch = False
+                    break
                 try:
                     if issubclass(descriptor_type, declared_output_type) or issubclass(
                         declared_output_type, descriptor_type

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

@@ -1,8 +1,10 @@
 import pytest
+from typing import Any, Dict
 
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
 from vellum.workflows.nodes.displayable.inline_prompt_node import InlinePromptNode
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState
 
 
@@ -57,3 +59,29 @@ def test_final_output_node__matching_output_type_should_pass_validation():
         CorrectOutput.__validate__()
     except ValueError:
         pytest.fail("Validation should not raise an exception for correct type matching")
+
+
+def test_final_output_node__dict_and_Dict_should_be_compatible():
+    """
+    Tests that FinalOutputNode validation recognizes dict and Dict[str, Any] as compatible types.
+    """
+
+    # GIVEN a FinalOutputNode declared with dict output type
+    # AND the value descriptor has Dict[str, Any] type
+    class DictOutputNode(FinalOutputNode[BaseState, dict]):
+        """Output with dict type."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = OutputReference(
+                name="value",
+                types=(Dict[str, Any],),
+                instance=None,
+                outputs_class=FinalOutputNode.Outputs,
+            )
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        DictOutputNode.__validate__()
+    except ValueError as e:
+        pytest.fail(f"Validation should not raise an exception for dict/Dict compatibility: {e}")

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

@@ -1,6 +1,6 @@
 import json
-from uuid import UUID
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
+from uuid import UUID, uuid4
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Type, Union, cast
 
 from vellum import (
     ChatMessage,
@@ -19,12 +19,13 @@ from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT, undefined
 from vellum.workflows.context import execution_context, get_execution_context, get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
-from vellum.workflows.events.types import default_serializer
+from vellum.workflows.events.types import WorkflowDeploymentParentContext, default_serializer
 from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.state.context import WorkflowContext, WorkflowDeploymentMetadata
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
@@ -155,69 +156,95 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             filtered_inputs = {k: v for k, v in self.subworkflow_inputs.items() if v is not None}
             return inputs_class(**filtered_inputs)
 
-    def _run_resolved_workflow(self, resolved_workflow: "BaseWorkflow") -> Iterator[BaseOutput]:
+    def _run_resolved_workflow(
+        self,
+        workflow_class: Type["BaseWorkflow"],
+        deployment_metadata: Optional[WorkflowDeploymentMetadata],
+    ) -> Iterator[BaseOutput]:
         """Execute resolved workflow directly (similar to InlineSubworkflowNode)."""
-        with execution_context(parent_context=get_parent_context()):
+        # Construct the parent context hierarchy for the subworkflow
+        parent_context = get_parent_context()
+
+        # If we have deployment metadata, wrap the parent context with WorkflowDeploymentParentContext
+        if deployment_metadata:
+            parent_context = WorkflowDeploymentParentContext(
+                span_id=uuid4(),
+                deployment_id=deployment_metadata.deployment_id,
+                deployment_name=deployment_metadata.deployment_name,
+                deployment_history_item_id=deployment_metadata.deployment_history_item_id,
+                release_tag_id=deployment_metadata.release_tag_id,
+                release_tag_name=deployment_metadata.release_tag_name,
+                workflow_version_id=deployment_metadata.workflow_version_id,
+                external_id=self.external_id if self.external_id is not OMIT else None,
+                metadata=self.metadata if self.metadata is not OMIT else None,
+                parent=parent_context,
+            )
+
+        with execution_context(parent_context=parent_context):
+            # Instantiate the workflow inside the execution context so it captures the correct parent context
+            resolved_workflow = workflow_class(
+                context=WorkflowContext.create_from(self._context), parent_state=self.state
+            )
             subworkflow_stream = resolved_workflow.stream(
                 inputs=self._compile_subworkflow_inputs_for_direct_invocation(resolved_workflow),
                 event_filter=all_workflow_event_filter,
                 node_output_mocks=self._context._get_all_node_output_mocks(),
             )
 
-        try:
-            first_event = next(subworkflow_stream)
-            self._context._emit_subworkflow_event(first_event)
-        except WorkflowInitializationException as e:
-            hashed_module = e.definition.__module__
-            raise NodeException(
-                message=e.message,
-                code=e.code,
-                raw_data={"hashed_module": hashed_module},
-            ) from e
-
-        outputs = None
-        exception = None
-        fulfilled_output_names: Set[str] = set()
+            try:
+                first_event = next(subworkflow_stream)
+                self._context._emit_subworkflow_event(first_event)
+            except WorkflowInitializationException as e:
+                hashed_module = e.definition.__module__
+                raise NodeException(
+                    message=e.message,
+                    code=e.code,
+                    raw_data={"hashed_module": hashed_module},
+                ) from e
+
+            outputs = None
+            exception = None
+            fulfilled_output_names: Set[str] = set()
+
+            for event in subworkflow_stream:
+                self._context._emit_subworkflow_event(event)
+                if exception:
+                    continue
+
+                if not is_workflow_event(event):
+                    continue
+                if event.workflow_definition != resolved_workflow.__class__:
+                    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.rejected":
+                    exception = NodeException.of(event.error)
+                elif event.name == "workflow.execution.paused":
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message="Subworkflow unexpectedly paused",
+                    )
 
-        for event in subworkflow_stream:
-            self._context._emit_subworkflow_event(event)
             if exception:
-                continue
+                raise exception
 
-            if not is_workflow_event(event):
-                continue
-            if event.workflow_definition != resolved_workflow.__class__:
-                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.rejected":
-                exception = NodeException.of(event.error)
-            elif event.name == "workflow.execution.paused":
-                exception = NodeException(
+            if outputs is None:
+                raise NodeException(
+                    message="Expected to receive outputs from Workflow Deployment",
                     code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message="Subworkflow unexpectedly paused",
                 )
 
-        if exception:
-            raise exception
-
-        if outputs is None:
-            raise NodeException(
-                message="Expected to receive outputs from Workflow Deployment",
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-            )
-
-        for output_descriptor, output_value in outputs:
-            if output_descriptor.name not in fulfilled_output_names:
-                yield BaseOutput(
-                    name=output_descriptor.name,
-                    value=output_value,
-                )
+            for output_descriptor, output_value in outputs:
+                if output_descriptor.name not in fulfilled_output_names:
+                    yield BaseOutput(
+                        name=output_descriptor.name,
+                        value=output_value,
+                    )
 
     def run(self) -> Iterator[BaseOutput]:
         execution_context = get_execution_context()
@@ -248,11 +275,12 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                 message="Expected deployment name to be provided for subworkflow execution.",
             )
 
-        resolved_workflow = self._context.resolve_workflow_deployment(
+        resolved_result = self._context.resolve_workflow_deployment(
             deployment_name=deployment_name, release_tag=self.release_tag, state=self.state
         )
-        if resolved_workflow:
-            yield from self._run_resolved_workflow(resolved_workflow)
+        if resolved_result:
+            workflow_class, deployment_metadata = resolved_result
+            yield from self._run_resolved_workflow(workflow_class, deployment_metadata)
             return
 
         try:

vellum/workflows/nodes/experimental/__init__.py

@@ -1,3 +1 @@
-from .openai_chat_completion_node import OpenAIChatCompletionNode
-
-__all__ = ["OpenAIChatCompletionNode"]
+__all__: list[str] = []