vellum-ai 0.14.73__py3-none-any.whl → 0.14.75__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.14.73",
+            "X-Fern-SDK-Version": "0.14.75",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/client/core/serialization.py

@@ -184,7 +184,6 @@ def _convert_mapping(
             converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
                 convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
             )
-
     return converted_object
 
 

vellum/client/reference.md

@@ -4270,7 +4270,15 @@ client.prompts.push(
 <dl>
 <dd>
 
-**prompt_variant_id:** `typing.Optional[str]` 
+**prompt_variant_id:** `typing.Optional[str]` — If specified, an existing Prompt Variant by the provided ID will be updated. Otherwise, a new Prompt Variant will be created and an ID generated.
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**prompt_variant_label:** `typing.Optional[str]` — If provided, then the created/updated Prompt Variant will have this label.
     
 </dd>
 </dl>

vellum/client/resources/prompts/client.py

@@ -110,6 +110,7 @@ class PromptsClient:
         *,
         exec_config: PromptExecConfig,
         prompt_variant_id: typing.Optional[str] = OMIT,
+        prompt_variant_label: typing.Optional[str] = OMIT,
         prompt_sandbox_id: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> PromptPushResponse:
@@ -121,6 +122,10 @@ class PromptsClient:
         exec_config : PromptExecConfig
 
         prompt_variant_id : typing.Optional[str]
+            If specified, an existing Prompt Variant by the provided ID will be updated. Otherwise, a new Prompt Variant will be created and an ID generated.
+
+        prompt_variant_label : typing.Optional[str]
+            If provided, then the created/updated Prompt Variant will have this label.
 
         prompt_sandbox_id : typing.Optional[str]
 
@@ -169,11 +174,12 @@ class PromptsClient:
             base_url=self._client_wrapper.get_environment().default,
             method="POST",
             json={
+                "prompt_variant_id": prompt_variant_id,
+                "prompt_variant_label": prompt_variant_label,
+                "prompt_sandbox_id": prompt_sandbox_id,
                 "exec_config": convert_and_respect_annotation_metadata(
                     object_=exec_config, annotation=PromptExecConfig, direction="write"
                 ),
-                "prompt_variant_id": prompt_variant_id,
-                "prompt_sandbox_id": prompt_sandbox_id,
             },
             headers={
                 "content-type": "application/json",
@@ -316,6 +322,7 @@ class AsyncPromptsClient:
         *,
         exec_config: PromptExecConfig,
         prompt_variant_id: typing.Optional[str] = OMIT,
+        prompt_variant_label: typing.Optional[str] = OMIT,
         prompt_sandbox_id: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> PromptPushResponse:
@@ -327,6 +334,10 @@ class AsyncPromptsClient:
         exec_config : PromptExecConfig
 
         prompt_variant_id : typing.Optional[str]
+            If specified, an existing Prompt Variant by the provided ID will be updated. Otherwise, a new Prompt Variant will be created and an ID generated.
+
+        prompt_variant_label : typing.Optional[str]
+            If provided, then the created/updated Prompt Variant will have this label.
 
         prompt_sandbox_id : typing.Optional[str]
 
@@ -383,11 +394,12 @@ class AsyncPromptsClient:
             base_url=self._client_wrapper.get_environment().default,
             method="POST",
             json={
+                "prompt_variant_id": prompt_variant_id,
+                "prompt_variant_label": prompt_variant_label,
+                "prompt_sandbox_id": prompt_sandbox_id,
                 "exec_config": convert_and_respect_annotation_metadata(
                     object_=exec_config, annotation=PromptExecConfig, direction="write"
                 ),
-                "prompt_variant_id": prompt_variant_id,
-                "prompt_sandbox_id": prompt_sandbox_id,
             },
             headers={
                 "content-type": "application/json",

vellum/client/types/secret_type_enum.py

@@ -2,4 +2,6 @@
 
 import typing
 
-SecretTypeEnum = typing.Union[typing.Literal["USER_DEFINED", "HMAC", "INTERNAL_API_KEY"], typing.Any]
+SecretTypeEnum = typing.Union[
+    typing.Literal["USER_DEFINED", "HMAC", "INTERNAL_API_KEY", "EXTERNALLY_PROVISIONED"], typing.Any
+]

vellum/workflows/nodes/bases/base.py

@@ -457,21 +457,6 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
             resolved_value = resolve_value(descriptor.instance, self.state, path=descriptor.name, memo=inputs)
             setattr(self, descriptor.name, resolved_value)
 
-        # Resolve descriptors set as defaults to the outputs class
-        def _outputs_post_init(outputs_self: "BaseNode.Outputs", **kwargs: Any) -> None:
-            for node_output_descriptor in self.Outputs:
-                if node_output_descriptor.name in kwargs:
-                    continue
-
-                if isinstance(node_output_descriptor.instance, BaseDescriptor):
-                    setattr(
-                        outputs_self,
-                        node_output_descriptor.name,
-                        node_output_descriptor.instance.resolve(self.state),
-                    )
-
-        setattr(self.Outputs, "_outputs_post_init", _outputs_post_init)
-
         # We only want to store the attributes that were actually set as inputs, not every attribute that exists.
         all_inputs = {}
         for key, value in inputs.items():

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

@@ -3,6 +3,7 @@ import threading
 import time
 
 from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import FinalOutputNode
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.map_node.node import MapNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
@@ -221,3 +222,56 @@ def test_map_node_parallel_execution_with_workflow():
     # AND each item should have run on a different thread
     thread_ids_list = list(thread_ids.values())
     assert len(set(thread_ids_list)) == 3
+
+
+def test_map_node__shared_state_race_condition():
+    processed_items = []
+
+    # GIVEN a templating node that processes items
+    class TemplatingNode(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            processed_item: str
+
+        def run(self) -> Outputs:
+            processed_item = f"{self.item}!"
+            return self.Outputs(processed_item=processed_item)
+
+    # AND a final output node
+    class FinalOutput(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = TemplatingNode.Outputs.processed_item
+
+        def run(self) -> Outputs:
+            outputs = super().run()
+            processed_items.append(outputs.value)
+            return outputs  # type: ignore[return-value]
+
+    # AND a workflow using those nodes
+    class ProcessItemWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = TemplatingNode >> FinalOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = FinalOutput.Outputs.value
+
+    # AND a map node with high concurrency
+    class RaceConditionMapNode(MapNode):
+        items = ["a", "b", "c", "d", "e", "f"]
+        subworkflow = ProcessItemWorkflow
+        max_concurrency = 1
+
+    # WHEN we run the map node multiple times to see pass consistently
+    num_runs = 50
+    for index in range(num_runs):
+        processed_items.clear()
+        node = RaceConditionMapNode(state=BaseState())
+        outputs = list(node.run())
+        final_result = outputs[-1].value
+
+        # THEN the state is unique among each run
+        assert len(set(processed_items)) == 6
+
+        # AND all results should be in correct order
+        expected_result = ["a!", "b!", "c!", "d!", "e!", "f!"]
+        assert final_result == expected_result, f"Failed on run {index}"

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

@@ -33,9 +33,9 @@ from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.definition import DeploymentDefinition
 from vellum.workflows.types.generics import StateType, is_workflow_class
 from vellum.workflows.utils.functions import (
-    compile_deployment_workflow_function_definition,
     compile_function_definition,
     compile_inline_workflow_function_definition,
+    compile_workflow_deployment_function_definition,
 )
 from vellum.workflows.utils.pydantic_schema import normalize_json
 
@@ -115,7 +115,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                     normalized_functions.append(function)
                 elif isinstance(function, DeploymentDefinition):
                     normalized_functions.append(
-                        compile_deployment_workflow_function_definition(
+                        compile_workflow_deployment_function_definition(
                             function.model_dump(),
                             vellum_client=self._context.vellum_client,
                         )

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

@@ -52,6 +52,8 @@ def primitive_to_vellum_value(value: Any) -> VellumValue:
         return StringVellumValue(value=value)
     elif isinstance(value, enum.Enum):
         return StringVellumValue(value=value.value)
+    elif isinstance(value, bool):
+        return JsonVellumValue(value=value)
     elif isinstance(value, (int, float)):
         return NumberVellumValue(value=value)
     elif isinstance(value, list) and (

vellum/workflows/nodes/experimental/tool_calling_node/node.py

@@ -32,6 +32,7 @@ class ToolCallingNode(BaseNode):
         functions: List[Tool] - The functions that can be called
         prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values
         function_configs: Optional[Dict[str, Dict[str, Any]]] - Mapping of function names to their configuration
+        max_prompt_iterations: Optional[int] - Maximum number of prompt iterations before stopping
     """
 
     ml_model: ClassVar[str] = "gpt-4o-mini"
@@ -39,6 +40,7 @@ class ToolCallingNode(BaseNode):
     functions: ClassVar[List[Tool]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     function_configs: ClassVar[Optional[Dict[str, Dict[str, Any]]]] = None
+    max_prompt_iterations: ClassVar[Optional[int]] = 5
 
     class Outputs(BaseOutputs):
         """
@@ -65,6 +67,7 @@ class ToolCallingNode(BaseNode):
 
             class ToolCallingState(BaseState):
                 chat_history: List[ChatMessage] = []
+                prompt_iterations: int = 0
 
             class ToolCallingWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
                 graph = self._graph
@@ -93,7 +96,7 @@ class ToolCallingNode(BaseNode):
 
                 return node_outputs
             elif terminal_event.name == "workflow.execution.rejected":
-                raise Exception(f"Workflow execution rejected: {terminal_event.error}")
+                raise NodeException(message=terminal_event.error.message, code=terminal_event.error.code)
 
             raise Exception(f"Unexpected workflow event: {terminal_event.name}")
 
@@ -103,6 +106,7 @@ class ToolCallingNode(BaseNode):
             blocks=self.blocks,
             functions=self.functions,
             prompt_inputs=self.prompt_inputs,
+            max_prompt_iterations=self.max_prompt_iterations,
         )
 
         self._function_nodes = {}

vellum/workflows/nodes/experimental/tool_calling_node/tests/test_node.py

@@ -12,6 +12,7 @@ from vellum.workflows.nodes.experimental.tool_calling_node.utils import create_f
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.definition import DeploymentDefinition
 
 
 def first_function() -> str:
@@ -127,3 +128,15 @@ def test_tool_calling_node_inline_workflow_context():
     assert isinstance(function_response.content, StringChatMessageContent)
     data = json.loads(function_response.content.value)
     assert data["generated_files"] == {"script.py": "print('hello world')"}
+
+
+def test_deployment_definition_release_tag_defaults_to_latest():
+    """
+    Test that when creating a DeploymentDefinition without specifying release_tag,
+    it defaults to "LATEST".
+    """
+    # WHEN we create a deployment definition without specifying release_tag
+    deployment_config = DeploymentDefinition(deployment="test-deployment")
+
+    # THEN the release_tag should default to "LATEST"
+    assert deployment_config.release_tag == "LATEST"

vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -37,10 +37,16 @@ class FunctionNode(BaseNode):
 
 
 class ToolRouterNode(InlinePromptNode):
+    max_prompt_iterations: Optional[int] = 5
+
     class Trigger(InlinePromptNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
 
     def run(self) -> Iterator[BaseOutput]:
+        if self.state.prompt_iterations >= self.max_prompt_iterations:
+            max_iterations_message = f"Maximum number of prompt iterations `{self.max_prompt_iterations}` reached."
+            raise NodeException(message=max_iterations_message, code=WorkflowErrorCode.NODE_EXECUTION)
+
         self.prompt_inputs = {**self.prompt_inputs, "chat_history": self.state.chat_history}  # type: ignore
         generator = super().run()
         for output in generator:
@@ -50,6 +56,8 @@ class ToolRouterNode(InlinePromptNode):
                     if values[0].type == "STRING":
                         self.state.chat_history.append(ChatMessage(role="ASSISTANT", text=values[0].value))
                     elif values[0].type == "FUNCTION_CALL":
+                        self.state.prompt_iterations += 1
+
                         function_call = values[0].value
                         if function_call is not None:
                             self.state.chat_history.append(
@@ -72,6 +80,7 @@ def create_tool_router_node(
     blocks: List[PromptBlock],
     functions: List[Tool],
     prompt_inputs: Optional[EntityInputsInterface],
+    max_prompt_iterations: Optional[int] = None,
 ) -> Type[ToolRouterNode]:
     if functions and len(functions) > 0:
         # If we have functions, create dynamic ports for each function
@@ -120,6 +129,7 @@ def create_tool_router_node(
                 "blocks": blocks,
                 "functions": functions,
                 "prompt_inputs": prompt_inputs,
+                "max_prompt_iterations": max_prompt_iterations,
                 "Ports": Ports,
                 "__module__": __name__,
             },
@@ -149,7 +159,7 @@ def create_function_node(
         deployment = function.deployment
         release_tag = function.release_tag
 
-        def execute_deployment_workflow_function(self) -> BaseNode.Outputs:
+        def execute_workflow_deployment_function(self) -> BaseNode.Outputs:
             function_call_output = self.state.meta.node_outputs.get(tool_router_node.Outputs.results)
             if function_call_output and len(function_call_output) > 0:
                 function_call = function_call_output[0]
@@ -187,10 +197,10 @@ def create_function_node(
             return self.Outputs()
 
         node = type(
-            f"DeploymentWorkflowNode_{deployment}",
+            f"WorkflowDeploymentNode_{deployment}",
             (FunctionNode,),
             {
-                "run": execute_deployment_workflow_function,
+                "run": execute_workflow_deployment_function,
                 "__module__": __name__,
             },
         )
@@ -219,7 +229,7 @@ def create_function_node(
             elif terminal_event.name == "workflow.execution.fulfilled":
                 result = terminal_event.outputs
             elif terminal_event.name == "workflow.execution.rejected":
-                raise Exception(f"Workflow execution rejected: {terminal_event.error}")
+                raise NodeException(message=terminal_event.error.message, code=terminal_event.error.code)
 
             self.state.chat_history.append(
                 ChatMessage(

vellum/workflows/outputs/base.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import TYPE_CHECKING, Any, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
 from typing_extensions import dataclass_transform
 
@@ -9,6 +10,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.generics import is_node_instance
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
 
 if TYPE_CHECKING:
@@ -198,8 +200,30 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
         for name, value in kwargs.items():
             setattr(self, name, value)
 
-        if hasattr(self, "_outputs_post_init") and callable(self._outputs_post_init):
-            self._outputs_post_init(**kwargs)
+        # If climb up the to the caller's frame, and if it's a BaseNode instance, it should
+        # have a state attribute that we can use to resolve the output descriptors.
+        frame = inspect.currentframe()
+        if not frame:
+            return
+
+        caller_frame = frame.f_back
+        if not caller_frame or "self" not in caller_frame.f_locals:
+            return
+
+        caller_self = caller_frame.f_locals["self"]
+        if not is_node_instance(caller_self):
+            return
+
+        for node_output_descriptor in self.__class__:
+            if node_output_descriptor.name in kwargs:
+                continue
+
+            if isinstance(node_output_descriptor.instance, BaseDescriptor):
+                setattr(
+                    self,
+                    node_output_descriptor.name,
+                    node_output_descriptor.instance.resolve(caller_self.state),
+                )
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, (dict, BaseOutputs)):

vellum/workflows/state/encoder.py

@@ -68,6 +68,8 @@ class DefaultStateEncoder(JSONEncoder):
 
             return {
                 "type": "CODE_EXECUTION",
+                "name": function_definition.name,
+                "description": function_definition.description,
                 "definition": function_definition,
                 "src": source_code,
             }

vellum/workflows/types/definition.py

@@ -74,4 +74,4 @@ VellumCodeResourceDefinition = Annotated[
 
 class DeploymentDefinition(UniversalBaseModel):
     deployment: str
-    release_tag: Optional[str] = "LATEST"
+    release_tag: str = "LATEST"

vellum/workflows/types/generics.py

@@ -42,6 +42,11 @@ def is_node_class(obj: Any) -> TypeGuard[Type["BaseNode"]]:
     return isinstance(obj, type) and issubclass(obj, base_node_class)
 
 
+def is_node_instance(obj: Any) -> TypeGuard["BaseNode"]:
+    base_node_class = _import_node_class()
+    return isinstance(obj, base_node_class)
+
+
 def is_workflow_class(obj: Any) -> TypeGuard[Type["BaseWorkflow"]]:
     base_workflow_class = import_workflow_class()
     return isinstance(obj, type) and issubclass(obj, base_workflow_class)

vellum/workflows/utils/functions.py

@@ -88,7 +88,7 @@ def _compile_default_value(default: Any) -> Any:
     return default
 
 
-def _compile_deployment_workflow_input(input_var: Any) -> dict[str, Any]:
+def _compile_workflow_deployment_input(input_var: Any) -> dict[str, Any]:
     """
     Converts a deployment workflow input variable to a JSON schema type definition.
     """
@@ -168,7 +168,7 @@ def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkfl
     )
 
 
-def compile_deployment_workflow_function_definition(
+def compile_workflow_deployment_function_definition(
     deployment_config: Dict[str, str],
     vellum_client: Vellum,
 ) -> FunctionDefinition:
@@ -193,7 +193,7 @@ def compile_deployment_workflow_function_definition(
     required = []
 
     for input_var in input_variables:
-        properties[input_var.key] = _compile_deployment_workflow_input(input_var)
+        properties[input_var.key] = _compile_workflow_deployment_input(input_var)
 
         if input_var.required and input_var.default is None:
             required.append(input_var.key)

vellum/workflows/utils/tests/test_functions.py

@@ -12,9 +12,9 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.utils.functions import (
-    compile_deployment_workflow_function_definition,
     compile_function_definition,
     compile_inline_workflow_function_definition,
+    compile_workflow_deployment_function_definition,
 )
 
 
@@ -440,7 +440,7 @@ def test_compile_inline_workflow_function_definition__optionals():
     )
 
 
-def test_compile_deployment_workflow_function_definition__just_name():
+def test_compile_workflow_deployment_function_definition__just_name():
     # GIVEN a mock Vellum client and deployment
     mock_client = Mock()
     mock_release = Mock()
@@ -451,7 +451,7 @@ def test_compile_deployment_workflow_function_definition__just_name():
     deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
 
     # WHEN compiling the deployment workflow function
-    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+    compiled_function = compile_workflow_deployment_function_definition(deployment_config, mock_client)
 
     # THEN it should return the compiled function definition (same structure as function test)
     assert compiled_function == FunctionDefinition(
@@ -461,7 +461,7 @@ def test_compile_deployment_workflow_function_definition__just_name():
     )
 
 
-def test_compile_deployment_workflow_function_definition__all_args():
+def test_compile_workflow_deployment_function_definition__all_args():
     # GIVEN a mock Vellum client and deployment
     mock_client = Mock()
     mock_release = Mock()
@@ -497,7 +497,7 @@ def test_compile_deployment_workflow_function_definition__all_args():
     deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
 
     # WHEN compiling the deployment workflow function
-    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+    compiled_function = compile_workflow_deployment_function_definition(deployment_config, mock_client)
 
     # THEN it should return the compiled function definition
     assert compiled_function == FunctionDefinition(
@@ -524,7 +524,7 @@ def test_compile_deployment_workflow_function_definition__all_args():
     )
 
 
-def test_compile_deployment_workflow_function_definition__defaults():
+def test_compile_workflow_deployment_function_definition__defaults():
     # GIVEN a mock Vellum client and deployment
     mock_client = Mock()
     mock_release = Mock()
@@ -565,7 +565,7 @@ def test_compile_deployment_workflow_function_definition__defaults():
     deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
 
     # WHEN compiling the deployment workflow function
-    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+    compiled_function = compile_workflow_deployment_function_definition(deployment_config, mock_client)
 
     # THEN it should return the compiled function definition with proper default handling
     assert compiled_function == FunctionDefinition(

{vellum_ai-0.14.73.dist-info → vellum_ai-0.14.75.dist-info}/METADATA

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