vellum-ai 0.13.0__py3-none-any.whl → 0.13.1__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.13.0",
+            "X-Fern-SDK-Version": "0.13.1",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/core/pydantic_utilities.py

@@ -133,6 +133,11 @@ class UniversalBaseModel(pydantic.BaseModel):
         #
         # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
         # that we have less control over, and this is less intrusive than custom serializers for now.
+        kwargs = {
+            **kwargs,
+            "warnings": False,
+        }
+
         if IS_PYDANTIC_V2:
             kwargs_with_defaults_exclude_unset: typing.Any = {
                 **kwargs,

vellum/client/resources/workflows/client.py

@@ -101,6 +101,7 @@ class WorkflowsClient:
         deployment_config: typing.Optional[WorkflowPushDeploymentConfigRequest] = OMIT,
         artifact: typing.Optional[core.File] = OMIT,
         dry_run: typing.Optional[bool] = OMIT,
+        strict: typing.Optional[bool] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> WorkflowPushResponse:
         """
@@ -120,6 +121,8 @@ class WorkflowsClient:
 
         dry_run : typing.Optional[bool]
 
+        strict : typing.Optional[bool]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -150,6 +153,7 @@ class WorkflowsClient:
                 "workflow_sandbox_id": workflow_sandbox_id,
                 "deployment_config": deployment_config,
                 "dry_run": dry_run,
+                "strict": strict,
             },
             files={
                 "artifact": artifact,
@@ -254,6 +258,7 @@ class AsyncWorkflowsClient:
         deployment_config: typing.Optional[WorkflowPushDeploymentConfigRequest] = OMIT,
         artifact: typing.Optional[core.File] = OMIT,
         dry_run: typing.Optional[bool] = OMIT,
+        strict: typing.Optional[bool] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> WorkflowPushResponse:
         """
@@ -273,6 +278,8 @@ class AsyncWorkflowsClient:
 
         dry_run : typing.Optional[bool]
 
+        strict : typing.Optional[bool]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -311,6 +318,7 @@ class AsyncWorkflowsClient:
                 "workflow_sandbox_id": workflow_sandbox_id,
                 "deployment_config": deployment_config,
                 "dry_run": dry_run,
+                "strict": strict,
             },
             files={
                 "artifact": artifact,

vellum/client/types/logical_operator.py

@@ -26,6 +26,8 @@ LogicalOperator = typing.Union[
         "notBlank",
         "coalesce",
         "accessField",
+        "and",
+        "or",
     ],
     typing.Any,
 ]

vellum/workflows/descriptors/base.py

@@ -121,7 +121,7 @@ class BaseDescriptor(Generic[_T]):
 
         return CoalesceExpression(lhs=self, rhs=other)
 
-    def __getitem__(self, field: str) -> "AccessorExpression":
+    def __getitem__(self, field: Union[str, int]) -> "AccessorExpression":
         from vellum.workflows.expressions.accessor import AccessorExpression
 
         return AccessorExpression(base=self, field=field)

vellum/workflows/descriptors/tests/test_utils.py

@@ -19,6 +19,7 @@ class FixtureState(BaseState):
     }
 
     eta = None
+    theta = ["baz"]
 
 
 class DummyNode(BaseNode[FixtureState]):
@@ -75,6 +76,7 @@ class DummyNode(BaseNode[FixtureState]):
         ),
         (FixtureState.zeta["foo"], "bar"),
         (ConstantValueReference(1), 1),
+        (FixtureState.theta[0], "baz"),
     ],
     ids=[
         "or",
@@ -119,6 +121,7 @@ class DummyNode(BaseNode[FixtureState]):
         "or_and",
         "accessor",
         "constants",
+        "list_index",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

vellum/workflows/expressions/accessor.py

@@ -1,6 +1,6 @@
 from collections.abc import Mapping
 import dataclasses
-from typing import Any, Sequence, Type, TypeVar
+from typing import Any, Sequence, Type, TypeVar, Union
 
 from pydantic import BaseModel, GetCoreSchemaHandler
 from pydantic_core import core_schema
@@ -17,7 +17,7 @@ class AccessorExpression(BaseDescriptor[Any]):
         self,
         *,
         base: BaseDescriptor[LHS],
-        field: str,
+        field: Union[str, int],
     ) -> None:
         super().__init__(
             name=f"{base.name}.{field}",
@@ -31,9 +31,15 @@ class AccessorExpression(BaseDescriptor[Any]):
         base = resolve_value(self._base, state)
 
         if dataclasses.is_dataclass(base):
+            if isinstance(self._field, int):
+                raise ValueError("Cannot access field by index on a dataclass")
+
             return getattr(base, self._field)
 
         if isinstance(base, BaseModel):
+            if isinstance(self._field, int):
+                raise ValueError("Cannot access field by index on a BaseModel")
+
             return getattr(base, self._field)
 
         if isinstance(base, Mapping):

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

@@ -1,7 +1,20 @@
 from collections import defaultdict
 from queue import Empty, Queue
 from threading import Thread
-from typing import TYPE_CHECKING, Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union, overload
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    Generic,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -12,6 +25,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
@@ -29,11 +43,11 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
 
     items: List[MapNodeItemType] - The items to map over
     subworkflow: Type["BaseWorkflow[SubworkflowInputs, BaseState]"] - The Subworkflow to execute on each iteration
-    concurrency: Optional[int] = None - The maximum number of concurrent subworkflow executions
+    max_concurrency: Optional[int] = None - The maximum number of concurrent subworkflow executions
     """
 
     items: List[MapNodeItemType]
-    concurrency: Optional[int] = None
+    max_concurrency: Optional[int] = None
 
     class Outputs(BaseAdornmentNode.Outputs):
         pass
@@ -47,7 +61,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         index: int
         all_items: List[MapNodeItemType]  # type: ignore[valid-type]
 
-    def run(self) -> Outputs:
+    def run(self) -> Iterator[BaseOutput]:
         mapped_items: Dict[str, List] = defaultdict(list)
         for output_descripter in self.subworkflow.Outputs:
             mapped_items[output_descripter.name] = [None] * len(self.items)
@@ -66,14 +80,14 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
                     "parent_context": parent_context,
                 },
             )
-            if self.concurrency is None:
+            if self.max_concurrency is None:
                 thread.start()
             else:
                 self._concurrency_queue.put(thread)
 
-        if self.concurrency is not None:
+        if self.max_concurrency is not None:
             concurrency_count = 0
-            while concurrency_count < self.concurrency:
+            while concurrency_count < self.max_concurrency:
                 is_empty = self._start_thread()
                 if is_empty:
                     break
@@ -83,40 +97,45 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         try:
             while map_node_event := self._event_queue.get():
                 index = map_node_event[0]
-                terminal_event = map_node_event[1]
-                self._context._emit_subworkflow_event(terminal_event)
+                subworkflow_event = map_node_event[1]
+                self._context._emit_subworkflow_event(subworkflow_event)
 
-                if terminal_event.name == "workflow.execution.fulfilled":
-                    workflow_output_vars = vars(terminal_event.outputs)
+                if subworkflow_event.name == "workflow.execution.initiated":
+                    for output_name in mapped_items.keys():
+                        yield BaseOutput(name=output_name, delta=(None, index, "INITIATED"))
+
+                elif subworkflow_event.name == "workflow.execution.fulfilled":
+                    workflow_output_vars = vars(subworkflow_event.outputs)
 
                     for output_name in workflow_output_vars:
                         output_mapped_items = mapped_items[output_name]
                         output_mapped_items[index] = workflow_output_vars[output_name]
+                        yield BaseOutput(
+                            name=output_name,
+                            delta=(output_mapped_items[index], index, "FULFILLED"),
+                        )
 
                     fulfilled_iterations[index] = True
                     if all(fulfilled_iterations):
                         break
 
-                    if self.concurrency is not None:
+                    if self.max_concurrency is not None:
                         self._start_thread()
-                elif terminal_event.name == "workflow.execution.paused":
+                elif subworkflow_event.name == "workflow.execution.paused":
                     raise NodeException(
                         code=WorkflowErrorCode.INVALID_OUTPUTS,
                         message=f"Subworkflow unexpectedly paused on iteration {index}",
                     )
-                elif terminal_event.name == "workflow.execution.rejected":
+                elif subworkflow_event.name == "workflow.execution.rejected":
                     raise NodeException(
-                        f"Subworkflow failed on iteration {index} with error: {terminal_event.error.message}",
-                        code=terminal_event.error.code,
+                        f"Subworkflow failed on iteration {index} with error: {subworkflow_event.error.message}",
+                        code=subworkflow_event.error.code,
                     )
         except Empty:
             pass
 
-        outputs = self.Outputs()
         for output_name, output_list in mapped_items.items():
-            setattr(outputs, output_name, output_list)
-
-        return outputs
+            yield BaseOutput(name=output_name, value=output_list)
 
     def _context_run_subworkflow(
         self, *, item: MapNodeItemType, index: int, parent_context: Optional[ParentContext] = None
@@ -149,21 +168,27 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
 
     @overload
     @classmethod
-    def wrap(cls, items: List[MapNodeItemType]) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]: ...
+    def wrap(
+        cls, items: List[MapNodeItemType], max_concurrency: Optional[int] = None
+    ) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]: ...
 
     # TODO: We should be able to do this overload automatically as we do with node attributes
     # https://app.shortcut.com/vellum/story/5289
     @overload
     @classmethod
     def wrap(
-        cls, items: BaseDescriptor[List[MapNodeItemType]]
+        cls,
+        items: BaseDescriptor[List[MapNodeItemType]],
+        max_concurrency: Optional[int] = None,
     ) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]: ...
 
     @classmethod
     def wrap(
-        cls, items: Union[List[MapNodeItemType], BaseDescriptor[List[MapNodeItemType]]]
+        cls,
+        items: Union[List[MapNodeItemType], BaseDescriptor[List[MapNodeItemType]]],
+        max_concurrency: Optional[int] = None,
     ) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]:
-        return create_adornment(cls, attributes={"items": items})
+        return create_adornment(cls, attributes={"items": items, "max_concurrency": max_concurrency})
 
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:

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

@@ -3,7 +3,7 @@ import time
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.map_node.node import MapNode
-from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -35,10 +35,10 @@ def test_map_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 1", "foo bar 2", "foo bar 3"]
+    assert outputs[-1] == BaseOutput(name="value", value=["foo bar 1", "foo bar 2", "foo bar 3"])
 
 
 def test_map_node__use_parallelism():
@@ -62,4 +62,4 @@ def test_map_node__use_parallelism():
 
     # THEN the node should have ran in parallel
     run_time = (end_ts - start_ts) / 10**9
-    assert run_time < 0.1
+    assert run_time < 0.2

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

@@ -13,7 +13,7 @@ from vellum.workflows.types.generics import StateType
 
 class BasePromptNode(BaseNode, Generic[StateType]):
     # Inputs that are passed to the Prompt
-    prompt_inputs: ClassVar[EntityInputsInterface]
+    prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
 
     request_options: Optional[RequestOptions] = None
 

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

@@ -53,8 +53,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
 
     def _get_prompt_event_stream(self) -> Iterator[AdHocExecutePromptEvent]:
         input_variables, input_values = self._compile_prompt_inputs()
-        current_parent_context = get_parent_context()
-        parent_context = current_parent_context.model_dump_json() if current_parent_context else None
+        parent_context = get_parent_context()
         request_options = self.request_options or RequestOptions()
         request_options["additional_body_parameters"] = {
             "execution_context": {"parent_context": parent_context},
@@ -77,13 +76,16 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
             blocks=self.blocks,
             functions=normalized_functions,
             expand_meta=self.expand_meta,
-            request_options=self.request_options,
+            request_options=request_options,
         )
 
     def _compile_prompt_inputs(self) -> Tuple[List[VellumVariable], List[PromptRequestInput]]:
         input_variables: List[VellumVariable] = []
         input_values: List[PromptRequestInput] = []
 
+        if not self.prompt_inputs:
+            return input_variables, input_values
+
         for input_name, input_value in self.prompt_inputs.items():
             if isinstance(input_value, str):
                 input_variables.append(

vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -74,6 +74,9 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
 
         compiled_inputs: List[PromptDeploymentInputRequest] = []
 
+        if not self.prompt_inputs:
+            return compiled_inputs
+
         for input_name, input_value in self.prompt_inputs.items():
             if isinstance(input_value, str):
                 compiled_inputs.append(

vellum/workflows/nodes/displayable/bases/search_node.py

@@ -15,6 +15,7 @@ from vellum.core import ApiError, RequestOptions
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable.bases.types import SearchFilters
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.types.generics import StateType
 
@@ -33,7 +34,11 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
     document_index: Union[UUID, str] - Either the UUID or name of the Vellum Document Index that you'd like to search
         against
     query: str - The query to search for
-    options: Optional[SearchRequestOptionsRequest] = None - Runtime configuration for the search
+    limit: Optional[int] = None - The maximum number of results to return.
+    weights: Optional[SearchWeightsRequest] = None - The weights to use for the search. Must add up to 1.0.
+    result_merging: Optional[SearchResultMergingRequest] = None - The configuration for merging results.
+    filters: Optional[SearchFiltersRequest] = None - The filters to apply to the search.
+    options: Optional[SearchRequestOptionsRequest] = None - [DEPRECATED] Runtime configuration for the search
     request_options: Optional[RequestOptions] = None - The request options to use for the search
     """
 
@@ -43,11 +48,24 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
     # The Document Index to Search against. Identified by either its UUID or its name.
     document_index: ClassVar[Union[UUID, str]]
 
+    # The maximum number of results to return.
+    limit: ClassVar[Optional[int]] = None
+
+    # The weights to use for the search. Must add up to 1.0.
+    weights: ClassVar[Optional[SearchWeightsRequest]] = None
+
+    # The configuration for merging results.
+    result_merging: ClassVar[Optional[SearchResultMergingRequest]] = None
+
+    # The filters to apply to the search.
+    filters: ClassVar[Optional[SearchFilters]] = None
+
     # Ideally we could reuse node descriptors to derive other node descriptor values. Two action items are
     # blocking us from doing so in this use case:
     # 1. Node Descriptor resolution during runtime - https://app.shortcut.com/vellum/story/4781
     # 2. Math operations between descriptors - https://app.shortcut.com/vellum/story/4782
     # search_weights = DEFAULT_SEARCH_WEIGHTS
+    # Deprecated: Use the top level `limit`, `weights`, `result_merging`, and `filters` attributes instead
     options = SearchRequestOptionsRequest(
         limit=DEFAULT_SEARCH_LIMIT,
         weights=SearchWeightsRequest(
@@ -77,7 +95,7 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
             return self._context.vellum_client.search(
                 query=self.query,
                 document_index=str(self.document_index),
-                options=self.options,
+                options=self._get_options_request(),
             )
         except NotFoundError:
             raise NodeException(
@@ -90,6 +108,23 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
+    def _get_options_request(self) -> SearchRequestOptionsRequest:
+        return SearchRequestOptionsRequest(
+            limit=self.limit if self.limit is not None else self.options.limit,
+            weights=self.weights if self.weights is not None else self.options.weights,
+            result_merging=self.result_merging if self.result_merging is not None else self.options.result_merging,
+            filters=self._get_filters_request(),
+        )
+
+    def _get_filters_request(self) -> Optional[SearchFiltersRequest]:
+        if self.filters is None:
+            return self.options.filters
+
+        return SearchFiltersRequest(
+            external_ids=self.filters.external_ids,
+            metadata=self.filters.metadata.to_request() if self.filters.metadata is not None else None,
+        )
+
     def run(self) -> Outputs:
         response = self._perform_search()
         return self.Outputs(results=response.results)

vellum/workflows/nodes/displayable/bases/tests/test_utils.py

@@ -0,0 +1,61 @@
+import pytest
+import enum
+
+from vellum.client.types.chat_history_vellum_value import ChatHistoryVellumValue
+from vellum.client.types.chat_message import ChatMessage
+from vellum.client.types.json_vellum_value import JsonVellumValue
+from vellum.client.types.number_vellum_value import NumberVellumValue
+from vellum.client.types.search_result import SearchResult
+from vellum.client.types.search_result_document import SearchResultDocument
+from vellum.client.types.search_results_vellum_value import SearchResultsVellumValue
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value, primitive_to_vellum_value_request
+
+
+class MockEnum(enum.Enum):
+    FOO = "foo"
+
+
+@pytest.mark.parametrize(
+    ["value", "expected_output"],
+    [
+        ("hello", StringVellumValue(value="hello")),
+        (MockEnum.FOO, StringVellumValue(value="foo")),
+        (1, NumberVellumValue(value=1)),
+        (1.0, NumberVellumValue(value=1.0)),
+        (
+            [ChatMessage(role="USER", text="hello")],
+            ChatHistoryVellumValue(value=[ChatMessage(role="USER", text="hello")]),
+        ),
+        (
+            [
+                SearchResult(
+                    text="Search query",
+                    score="0.0",
+                    keywords=["keywords"],
+                    document=SearchResultDocument(label="label"),
+                )
+            ],
+            SearchResultsVellumValue(
+                value=[
+                    SearchResult(
+                        text="Search query",
+                        score="0.0",
+                        keywords=["keywords"],
+                        document=SearchResultDocument(label="label"),
+                    )
+                ]
+            ),
+        ),
+        (StringVellumValue(value="hello"), StringVellumValue(value="hello")),
+        (StringVellumValueRequest(value="hello"), StringVellumValueRequest(value="hello")),
+        ({"foo": "bar"}, JsonVellumValue(value={"foo": "bar"})),
+    ],
+)
+def test_primitive_to_vellum_value(value, expected_output):
+    assert primitive_to_vellum_value(value) == expected_output
+
+
+def test_primitive_to_vellum_value_request():
+    assert primitive_to_vellum_value_request("hello") == StringVellumValueRequest(value="hello")

vellum/workflows/nodes/displayable/bases/types.py

@@ -0,0 +1,42 @@
+from typing import Any, List, Optional, Union
+
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.condition_combinator import ConditionCombinator
+from vellum.client.types.logical_operator import LogicalOperator
+from vellum.client.types.vellum_value_logical_condition_group_request import VellumValueLogicalConditionGroupRequest
+from vellum.client.types.vellum_value_logical_condition_request import VellumValueLogicalConditionRequest
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value_request
+
+
+class MetadataLogicalConditionGroup(UniversalBaseModel):
+    combinator: ConditionCombinator
+    negated: bool
+    conditions: List["MetadataLogicalExpression"]
+
+    def to_request(self) -> VellumValueLogicalConditionGroupRequest:
+        return VellumValueLogicalConditionGroupRequest(
+            combinator=self.combinator,
+            negated=self.negated,
+            conditions=[c.to_request() for c in self.conditions],
+        )
+
+
+class MetadataLogicalCondition(UniversalBaseModel):
+    lhs_variable: Any
+    operator: LogicalOperator
+    rhs_variable: Any
+
+    def to_request(self) -> VellumValueLogicalConditionRequest:
+        return VellumValueLogicalConditionRequest(
+            lhs_variable=primitive_to_vellum_value_request(self.lhs_variable),
+            operator=self.operator,
+            rhs_variable=primitive_to_vellum_value_request(self.rhs_variable),
+        )
+
+
+MetadataLogicalExpression = Union[MetadataLogicalConditionGroup, MetadataLogicalCondition]
+
+
+class SearchFilters(UniversalBaseModel):
+    external_ids: Optional[List[str]] = None
+    metadata: Optional[MetadataLogicalConditionGroup] = None