vellum-ai 0.14.16__py3-none-any.whl → 0.14.18__py3-none-any.whl

vellum/__init__.py

@@ -296,6 +296,7 @@ from .types import (
     RejectedExecuteWorkflowWorkflowResultEvent,
     RejectedPromptExecutionMeta,
     RejectedWorkflowNodeResultEvent,
+    Release,
     ReleaseTagSource,
     ReplaceTestSuiteTestCaseRequest,
     RichTextChildBlock,
@@ -844,6 +845,7 @@ __all__ = [
     "RejectedExecuteWorkflowWorkflowResultEvent",
     "RejectedPromptExecutionMeta",
     "RejectedWorkflowNodeResultEvent",
+    "Release",
     "ReleaseTagSource",
     "ReplaceTestSuiteTestCaseRequest",
     "RichTextChildBlock",

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.16",
+            "X-Fern-SDK-Version": "0.14.18",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/types/__init__.py

@@ -304,6 +304,7 @@ from .rejected_execute_prompt_response import RejectedExecutePromptResponse
 from .rejected_execute_workflow_workflow_result_event import RejectedExecuteWorkflowWorkflowResultEvent
 from .rejected_prompt_execution_meta import RejectedPromptExecutionMeta
 from .rejected_workflow_node_result_event import RejectedWorkflowNodeResultEvent
+from .release import Release
 from .release_tag_source import ReleaseTagSource
 from .replace_test_suite_test_case_request import ReplaceTestSuiteTestCaseRequest
 from .rich_text_child_block import RichTextChildBlock
@@ -825,6 +826,7 @@ __all__ = [
     "RejectedExecuteWorkflowWorkflowResultEvent",
     "RejectedPromptExecutionMeta",
     "RejectedWorkflowNodeResultEvent",
+    "Release",
     "ReleaseTagSource",
     "ReplaceTestSuiteTestCaseRequest",
     "RichTextChildBlock",

vellum/client/types/release.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class Release(UniversalBaseModel):
+    id: str
+    timestamp: dt.datetime
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/workflow_release_tag_read.py

@@ -4,6 +4,7 @@ from ..core.pydantic_utilities import UniversalBaseModel
 import pydantic
 from .release_tag_source import ReleaseTagSource
 from .workflow_release_tag_workflow_deployment_history_item import WorkflowReleaseTagWorkflowDeploymentHistoryItem
+from .release import Release
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
 
@@ -24,7 +25,12 @@ class WorkflowReleaseTagRead(UniversalBaseModel):
 
     history_item: WorkflowReleaseTagWorkflowDeploymentHistoryItem = pydantic.Field()
     """
-    The Workflow Deployment History Item that this Release Tag is associated with
+    Deprecated. Reference the `release` field instead.
+    """
+
+    release: Release = pydantic.Field()
+    """
+    The Release that this Release Tag points to.
     """
 
     if IS_PYDANTIC_V2:

vellum/prompts/blocks/compilation.py

@@ -3,11 +3,13 @@ from typing import Sequence, Union, cast
 
 from vellum import (
     ChatMessage,
+    DocumentVellumValue,
     JsonVellumValue,
     PromptBlock,
     PromptRequestInput,
     RichTextPromptBlock,
     StringVellumValue,
+    VellumDocument,
     VellumVariable,
 )
 from vellum.client.types.audio_vellum_value import AudioVellumValue
@@ -159,6 +161,18 @@ def compile_prompt_blocks(
                 cache_config=block.cache_config,
             )
             compiled_blocks.append(audio_block)
+
+        elif block.block_type == "DOCUMENT":
+            document_block = CompiledValuePromptBlock(
+                content=DocumentVellumValue(
+                    value=VellumDocument(
+                        src=block.src,
+                        metadata=block.metadata,
+                    )
+                ),
+                cache_config=block.cache_config,
+            )
+            compiled_blocks.append(document_block)
         else:
             raise PromptCompilationError(f"Unknown block_type: {block.block_type}")
 

vellum/types/release.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.release import *

vellum/workflows/events/workflow.py

@@ -48,7 +48,7 @@ class NodeEventDisplayContext(UniversalBaseModel):
 
 
 class WorkflowEventDisplayContext(UniversalBaseModel):
-    node_displays: Dict[str, NodeEventDisplayContext]
+    node_displays: Dict[UUID, NodeEventDisplayContext]
     workflow_inputs: Dict[str, UUID]
     workflow_outputs: Dict[str, UUID]
 
@@ -194,6 +194,12 @@ WorkflowExecutionEvent = Union[
     WorkflowExecutionSnapshottedEvent,
 ]
 
+TerminalWorkflowExecutionEvent = Union[
+    WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionRejectedEvent,
+    WorkflowExecutionPausedEvent,
+]
+
 
 def is_workflow_event(event: WorkflowEvent) -> TypeGuard[WorkflowExecutionEvent]:
     return (
@@ -205,3 +211,11 @@ def is_workflow_event(event: WorkflowEvent) -> TypeGuard[WorkflowExecutionEvent]
         or event.name == "workflow.execution.resumed"
         or event.name == "workflow.execution.rejected"
     )
+
+
+def is_terminal_workflow_execution_event(event: WorkflowEvent) -> TypeGuard[TerminalWorkflowExecutionEvent]:
+    return (
+        event.name == "workflow.execution.fulfilled"
+        or event.name == "workflow.execution.rejected"
+        or event.name == "workflow.execution.paused"
+    )

vellum/workflows/nodes/bases/base.py

@@ -293,14 +293,14 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ALL:
                 """
-                A node utilizing an AWAIT_ALL merge strategy will only be considered ready for the Nth time
-                when all of its dependencies have been executed N times.
+                A node utilizing an AWAIT_ALL merge strategy will only be considered ready
+                when all of its dependencies have invoked this node.
                 """
-                current_node_execution_count = state.meta.node_execution_cache.get_execution_count(cls.node_class)
-                return all(
-                    state.meta.node_execution_cache.get_execution_count(dep) == current_node_execution_count + 1
-                    for dep in dependencies
-                )
+                # Check if all dependencies have invoked this node
+                dependencies_invoked = state.meta.node_execution_cache._dependencies_invoked.get(node_span_id, set())
+                all_deps_invoked = all(dep in dependencies_invoked for dep in dependencies)
+
+                return all_deps_invoked
 
             raise NodeException(
                 message="Invalid Trigger Node Specification",

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -73,3 +73,5 @@ class BaseAdornmentNode(
         # Subclasses of BaseAdornableNode can override this method to provider their own
         # approach to annotating the outputs class based on the `subworkflow.Outputs`
         setattr(outputs_class, reference.name, reference)
+        if cls.__wrapped_node__:
+            cls.__output_ids__[reference.name] = cls.__wrapped_node__.__output_ids__[reference.name]

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

@@ -1,9 +1,11 @@
 import time
 from typing import Callable, Generic, Optional, Type
 
+from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.workflow import is_terminal_workflow_execution_event
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
@@ -11,6 +13,7 @@ from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
@@ -38,54 +41,71 @@ class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
 
         for index in range(self.max_attempts):
             attempt_number = index + 1
-            context = WorkflowContext(vellum_client=self._context.vellum_client)
-            subworkflow = self.subworkflow(
-                parent_state=self.state,
-                context=context,
-            )
-            terminal_event = subworkflow.run(
-                inputs=self.SubworkflowInputs(attempt_number=attempt_number),
-                node_output_mocks=self._context._get_all_node_output_mocks(),
-            )
-            if terminal_event.name == "workflow.execution.fulfilled":
-                node_outputs = self.Outputs()
-                workflow_output_vars = vars(terminal_event.outputs)
-
-                for output_name in workflow_output_vars:
-                    setattr(node_outputs, output_name, workflow_output_vars[output_name])
-
-                return node_outputs
-            elif terminal_event.name == "workflow.execution.paused":
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=f"Subworkflow unexpectedly paused on attempt {attempt_number}",
-                )
-            elif self.retry_on_error_code and self.retry_on_error_code != terminal_event.error.code:
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=f"""Unexpected rejection on attempt {attempt_number}: {terminal_event.error.code.value}.
-Message: {terminal_event.error.message}""",
+            parent_context = get_parent_context()
+            with execution_context(parent_context=parent_context):
+                subworkflow = self.subworkflow(
+                    parent_state=self.state,
+                    context=WorkflowContext(vellum_client=self._context.vellum_client),
                 )
-            elif self.retry_on_condition and not resolve_value(self.retry_on_condition, self.state):
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=f"""Rejection failed on attempt {attempt_number}: {terminal_event.error.code.value}.
-Message: {terminal_event.error.message}""",
+                subworkflow_stream = subworkflow.stream(
+                    inputs=self.SubworkflowInputs(attempt_number=attempt_number),
+                    event_filter=all_workflow_event_filter,
+                    node_output_mocks=self._context._get_all_node_output_mocks(),
                 )
-            else:
-                last_exception = NodeException(
-                    terminal_event.error.message,
-                    code=terminal_event.error.code,
-                )
-                if self.delay:
-                    time.sleep(self.delay)
+
+            node_outputs: Optional[BaseNode.Outputs] = None
+            exception: Optional[NodeException] = None
+            for event in subworkflow_stream:
+                self._context._emit_subworkflow_event(event)
+
+                if not is_terminal_workflow_execution_event(event):
+                    continue
+
+                if event.workflow_definition != self.subworkflow:
+                    continue
+
+                if event.name == "workflow.execution.fulfilled":
+                    node_outputs = self.Outputs()
+
+                    for output_descriptor, output_value in event.outputs:
+                        setattr(node_outputs, output_descriptor.name, output_value)
+                elif event.name == "workflow.execution.paused":
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message=f"Subworkflow unexpectedly paused on attempt {attempt_number}",
+                    )
+                elif self.retry_on_error_code and self.retry_on_error_code != event.error.code:
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message=f"""Unexpected rejection on attempt {attempt_number}: {event.error.code.value}.
+Message: {event.error.message}""",
+                    )
+                elif self.retry_on_condition and not resolve_value(self.retry_on_condition, self.state):
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message=f"""Rejection failed on attempt {attempt_number}: {event.error.code.value}.
+Message: {event.error.message}""",
+                    )
+                else:
+                    last_exception = NodeException(
+                        event.error.message,
+                        code=event.error.code,
+                    )
+                    if self.delay:
+                        time.sleep(self.delay)
+
+            if exception:
+                raise exception
+
+            if node_outputs:
+                return node_outputs
 
         raise last_exception
 
     @classmethod
     def wrap(
         cls,
-        max_attempts: int,
+        max_attempts: int = 3,
         delay: Optional[float] = None,
         retry_on_error_code: Optional[WorkflowErrorCode] = None,
         retry_on_condition: Optional[BaseDescriptor] = None,

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

@@ -48,10 +48,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     """
 
     # The Jinja template to render.
-    template: ClassVar[str]
+    template: ClassVar[str] = ""
 
     # The inputs to render the template with.
-    inputs: ClassVar[EntityInputsInterface]
+    inputs: ClassVar[EntityInputsInterface] = {}
 
     jinja_globals: Dict[str, Any] = DEFAULT_JINJA_GLOBALS
     jinja_custom_filters: Mapping[str, FilterFunc] = DEFAULT_JINJA_CUSTOM_FILTERS

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

@@ -102,4 +102,4 @@ Message: {event.error.message}""",
         if reference.name == "error":
             raise ValueError("`error` is a reserved name for TryNode.Outputs")
 
-        setattr(outputs_class, reference.name, reference)
+        super().__annotate_outputs_class__(outputs_class, reference)

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

@@ -28,6 +28,9 @@ class BasePromptNode(BaseNode, Generic[StateType]):
     def _get_prompt_event_stream(self) -> Union[Iterator[AdHocExecutePromptEvent], Iterator[ExecutePromptEvent]]:
         pass
 
+    def _validate(self) -> None:
+        pass
+
     def run(self) -> Iterator[BaseOutput]:
         outputs = yield from self._process_prompt_event_stream()
         if outputs is None:
@@ -37,6 +40,7 @@ class BasePromptNode(BaseNode, Generic[StateType]):
             )
 
     def _process_prompt_event_stream(self) -> Generator[BaseOutput, None, Optional[List[PromptOutput]]]:
+        self._validate()
         try:
             prompt_event_stream = self._get_prompt_event_stream()
         except ApiError as e:

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

@@ -1,6 +1,6 @@
 import json
 from uuid import uuid4
-from typing import Callable, ClassVar, Generic, Iterator, List, Optional, Tuple, Union
+from typing import Callable, ClassVar, Generic, Iterator, List, Optional, Set, Tuple, Union
 
 from vellum import (
     AdHocExecutePromptEvent,
@@ -18,6 +18,7 @@ from vellum import (
 from vellum.client import RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.prompt_settings import PromptSettings
+from vellum.client.types.rich_text_child_block import RichTextChildBlock
 from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_execution_context
 from vellum.workflows.errors import WorkflowErrorCode
@@ -59,6 +60,31 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
     class Trigger(BasePromptNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
+    def _extract_required_input_variables(self, blocks: Union[List[PromptBlock], List[RichTextChildBlock]]) -> Set[str]:
+        required_variables = set()
+
+        for block in blocks:
+            if block.block_type == "VARIABLE":
+                required_variables.add(block.input_variable)
+            elif block.block_type == "CHAT_MESSAGE" and block.blocks:
+                required_variables.update(self._extract_required_input_variables(block.blocks))
+            elif block.block_type == "RICH_TEXT" and block.blocks:
+                required_variables.update(self._extract_required_input_variables(block.blocks))
+
+        return required_variables
+
+    def _validate(self) -> None:
+        required_variables = self._extract_required_input_variables(self.blocks)
+        provided_variables = set(self.prompt_inputs.keys() if self.prompt_inputs else set())
+
+        missing_variables = required_variables - provided_variables
+        if missing_variables:
+            missing_vars_str = ", ".join(f"'{var}'" for var in missing_variables)
+            raise NodeException(
+                message=f"Missing required input variables by VariablePromptBlock: {missing_vars_str}",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
     def _get_prompt_event_stream(self) -> Iterator[AdHocExecutePromptEvent]:
         input_variables, input_values = self._compile_prompt_inputs()
         current_context = get_execution_context()