vellum-ai 0.14.16__tar.gz → 0.14.17__tar.gz

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/PKG-INFO

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

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -59,7 +59,16 @@ _NodeDisplayAttrType = TypeVar("_NodeDisplayAttrType")
 
 class BaseNodeDisplayMeta(type):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
-        cls = super().__new__(mcs, name, bases, dct)
+        cls = cast(Type["BaseNodeDisplay"], super().__new__(mcs, name, bases, dct))
+
+        if not dct.get("output_display"):
+            node_class = cls.infer_node_class()
+            cls.output_display = {
+                ref: NodeOutputDisplay(id=node_class.__output_ids__[ref.name], name=ref.name)
+                for ref in node_class.Outputs
+                if ref.name in node_class.__output_ids__
+            }
+
         return cls.__annotate_node__()
 
     def __annotate_node__(cls):
@@ -73,22 +82,36 @@ class BaseNodeDisplayMeta(type):
             # Display classes are able to override the id of the node class it's parameterized by
             node_class.__id__ = display_node_id
 
-        output_display = getattr(cls, "output_display", None)
-        if isinstance(output_display, dict):
-            # And the node class' output ids
-            for reference, node_output_display in output_display.items():
-                if not isinstance(reference, OutputReference):
-                    continue
-                if not isinstance(node_output_display, NodeOutputDisplay):
-                    continue
+        for reference, node_output_display in base_node_display_class.output_display.items():
+            if not isinstance(reference, OutputReference):
+                continue
+            if not isinstance(node_output_display, NodeOutputDisplay):
+                continue
 
-                node_class.__output_ids__[reference.name] = node_output_display.id
+            node_class.__output_ids__[reference.name] = node_output_display.id
 
         return cls
 
+    def infer_node_class(cls) -> Type[BaseNode]:
+        original_base = get_original_base(cls)
+        node_class = get_args(original_base)[0]
+        if isinstance(node_class, TypeVar):
+            bounded_class = node_class.__bound__
+            if inspect.isclass(bounded_class) and issubclass(bounded_class, BaseNode):
+                return bounded_class
+
+            if isinstance(bounded_class, ForwardRef) and bounded_class.__forward_arg__ == BaseNode.__name__:
+                return BaseNode
+
+        if issubclass(node_class, BaseNode):
+            return node_class
+
+        raise ValueError(f"Node {cls.__name__} must be a subclass of {BaseNode.__name__}")
+
 
 class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
-    output_display: Dict[OutputReference, NodeOutputDisplay] = {}
+    # Default values set by the metaclass
+    output_display: Dict[OutputReference, NodeOutputDisplay]
     port_displays: Dict[Port, PortDisplayOverrides] = {}
     node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
@@ -235,23 +258,6 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     def get_from_node_display_registry(cls, node_class: Type[NodeType]) -> Optional[Type["BaseNodeDisplay"]]:
         return cls._node_display_registry.get(node_class)
 
-    @classmethod
-    def infer_node_class(cls) -> Type[NodeType]:
-        original_base = get_original_base(cls)
-        node_class = get_args(original_base)[0]
-        if isinstance(node_class, TypeVar):
-            bounded_class = node_class.__bound__
-            if inspect.isclass(bounded_class) and issubclass(bounded_class, BaseNode):
-                return cast(Type[NodeType], bounded_class)
-
-            if isinstance(bounded_class, ForwardRef) and bounded_class.__forward_arg__ == BaseNode.__name__:
-                return cast(Type[NodeType], BaseNode)
-
-        if issubclass(node_class, BaseNode):
-            return node_class
-
-        raise ValueError(f"Node {cls.__name__} must be a subclass of {BaseNode.__name__}")
-
     @cached_property
     def node_id(self) -> UUID:
         """Can be overridden as a class attribute to specify a custom node id."""
@@ -264,7 +270,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
     @property
     def _node(self) -> Type[NodeType]:
-        return self.infer_node_class()
+        return cast(Type[NodeType], self.__class__.infer_node_class())
 
     @classmethod
     def _get_explicit_node_display_attr(

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/ee/vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING, Any, Dict, Optional, Type
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.generics import NodeType
 from vellum.workflows.utils.uuids import uuid4_from_hash
-from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import NodeDisplayType
@@ -43,14 +42,6 @@ def get_node_display_class(
         return {}
 
     def exec_body(ns: Dict):
-        output_display = {
-            ref: NodeOutputDisplay(id=node_class.__output_ids__[ref.name], name=ref.name)
-            for ref in node_class.Outputs
-            if ref.name in node_class.__output_ids__
-        }
-        if output_display:
-            ns["output_display"] = output_display
-
         node_input_ids_by_name: Dict[str, UUID] = {}
         for ref in node_class:
             node_input_ids_by_name.update(_get_node_input_ids_by_ref(ref.name, ref.instance))

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/ee/vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py

@@ -3,7 +3,6 @@ import types
 from uuid import UUID
 from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar, cast
 
-from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import get_wrapped_node
 from vellum.workflows.types.core import JsonArray, JsonObject
@@ -12,6 +11,7 @@ from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _BaseAdornmentNodeType = TypeVar("_BaseAdornmentNodeType", bound=BaseAdornmentNode)
@@ -44,12 +44,17 @@ class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Ge
         return serialized_wrapped_node
 
     @classmethod
-    def wrap(cls, **kwargs: Any) -> Callable[..., Type[BaseNodeDisplay]]:
+    def wrap(cls, node_id: Optional[UUID] = None, **kwargs: Any) -> Callable[..., Type[BaseNodeDisplay]]:
         NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
 
-        def decorator(inner_cls: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
-            node_class = inner_cls.infer_node_class()
-            wrapped_node_class = cast(Type[BaseNode], node_class.__wrapped_node__)
+        def decorator(wrapped_node_display_class: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
+            node_class = wrapped_node_display_class.infer_node_class()
+            if not issubclass(node_class, BaseAdornmentNode):
+                raise ValueError(f"Node {node_class.__name__} must be wrapped with a {BaseAdornmentNode.__name__}")
+
+            wrapped_node_class = node_class.__wrapped_node__
+            if not wrapped_node_class:
+                raise ValueError(f"Node {node_class.__name__} must be used as an adornment with the `wrap` method.")
 
             # `mypy` is wrong here, `cls` is indexable bc it's Generic
             BaseAdornmentDisplay = cls[node_class]  # type: ignore[index]
@@ -58,36 +63,51 @@ class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Ge
                 for key, kwarg in kwargs.items():
                     ns[key] = kwarg
 
-                if "node_id" not in kwargs:
-                    ns["node_id"] = uuid4_from_hash(node_class.__qualname__)
+                ns["node_id"] = node_id or uuid4_from_hash(node_class.__qualname__)
 
             AdornmentDisplay = types.new_class(
                 re.sub(r"^Base", "", cls.__name__), bases=(BaseAdornmentDisplay,), exec_body=exec_body
             )
 
-            setattr(inner_cls, "__adorned_by__", AdornmentDisplay)
+            setattr(wrapped_node_display_class, "__adorned_by__", AdornmentDisplay)
 
             # We must edit the node display class to use __wrapped_node__ everywhere it
             # references the adorned node class, which is three places:
 
             # 1. The node display class' parameterized type
-            original_base_node_display = get_original_base(inner_cls)
+            original_base_node_display = get_original_base(wrapped_node_display_class)
             original_base_node_display.__args__ = (wrapped_node_class,)
-            inner_cls._node_display_registry[wrapped_node_class] = inner_cls
-            inner_cls.__annotate_node__()
+            wrapped_node_display_class._node_display_registry[wrapped_node_class] = wrapped_node_display_class
+            wrapped_node_display_class.__annotate_node__()
 
             # 2. The node display class' output displays
-            old_outputs = list(inner_cls.output_display.keys())
-            for old_output in old_outputs:
-                new_output = getattr(wrapped_node_class.Outputs, old_output.name)
-                inner_cls.output_display[new_output] = inner_cls.output_display.pop(old_output)
+            for old_output in node_class.Outputs:
+                new_output = getattr(wrapped_node_class.Outputs, old_output.name, None)
+                if new_output is None:
+                    # If the adornment is adding a new output, such as TryNode adding an "error" output,
+                    # we skip it, since it should not be included in the adorned node's output displays
+                    wrapped_node_display_class.output_display.pop(old_output, None)
+                    continue
+
+                if old_output not in wrapped_node_display_class.output_display:
+                    # If the adorned node doesn't have an output display defined for this output, we define one
+                    wrapped_node_display_class.output_display[new_output] = NodeOutputDisplay(
+                        id=wrapped_node_class.__output_ids__[old_output.name],
+                        name=old_output.name,
+                    )
+                else:
+                    wrapped_node_display_class.output_display[new_output] = (
+                        wrapped_node_display_class.output_display.pop(old_output)
+                    )
 
             # 3. The node display class' port displays
-            old_ports = list(inner_cls.port_displays.keys())
+            old_ports = list(wrapped_node_display_class.port_displays.keys())
             for old_port in old_ports:
                 new_port = getattr(wrapped_node_class.Ports, old_port.name)
-                inner_cls.port_displays[new_port] = inner_cls.port_displays.pop(old_port)
+                wrapped_node_display_class.port_displays[new_port] = wrapped_node_display_class.port_displays.pop(
+                    old_port
+                )
 
-            return inner_cls
+            return wrapped_node_display_class
 
         return decorator

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -19,6 +19,7 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
     output_id: ClassVar[Optional[UUID]] = None
     array_output_id: ClassVar[Optional[UUID]] = None
+    json_output_id: ClassVar[Optional[UUID]] = None
     prompt_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
     def serialize(

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -5,9 +5,11 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.retry_node import BaseRetryNodeDisplay
+from vellum_ee.workflows.display.nodes.vellum.try_node import BaseTryNodeDisplay
 from vellum_ee.workflows.display.vellum import NodeDisplayData, NodeDisplayPosition
 from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
@@ -119,6 +121,29 @@ def test_get_event_display_context__node_display_filled_without_base_display():
     assert StartNode.__output_ids__ == node_event_display.output_display
 
 
+def test_get_event_display_context__node_display_filled_without_output_display():
+    # GIVEN a simple workflow
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    class MyWorkflow(BaseWorkflow):
+        graph = StartNode
+
+    class StartNodeDisplay(BaseNodeDisplay[StartNode]):
+        pass
+
+    # WHEN we gather the event display context
+    display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
+
+    # THEN the node display should be included
+    assert str(StartNode.__id__) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(StartNode.__id__)]
+
+    # AND so should their output ids
+    assert node_event_display.output_display.keys() == {"foo"}
+
+
 def test_get_event_display_context__node_display_to_include_subworkflow_display():
     # GIVEN a simple workflow
     class InnerNode(BaseNode):
@@ -145,19 +170,33 @@ def test_get_event_display_context__node_display_to_include_subworkflow_display(
     assert str(InnerNode.__id__) in node_event_display.subworkflow_display.node_displays
 
 
-def test_get_event_display_context__node_display_for_adornment_nodes():
-    # GIVEN a simple workflow with a retry node adornment
-    @RetryNode.wrap(max_attempts=4)
+@pytest.mark.parametrize(
+    ["AdornmentNode", "AdornmentNodeDisplay", "expected_adornment_output_names"],
+    [
+        [RetryNode, BaseRetryNodeDisplay, {"foo"}],
+        [TryNode, BaseTryNodeDisplay, {"foo", "error"}],
+    ],
+    ids=["retry_node", "try_node"],
+)
+def test_get_event_display_context__node_display_for_adornment_nodes(
+    AdornmentNode,
+    AdornmentNodeDisplay,
+    expected_adornment_output_names,
+):
+    # GIVEN a simple workflow with an adornment
+    @AdornmentNode.wrap()
     class MyNode(BaseNode):
-        pass
+        class Outputs(BaseNode.Outputs):
+            foo: str
 
     class MyWorkflow(BaseWorkflow):
         graph = MyNode
 
     # AND a display class for the node
+    adornment_node_id = uuid4()
     inner_node_id = uuid4()
 
-    @BaseRetryNodeDisplay.wrap()
+    @AdornmentNodeDisplay.wrap(node_id=adornment_node_id)
     class MyNodeDisplay(BaseNodeDisplay[MyNode]):
         node_id = inner_node_id
 
@@ -165,11 +204,16 @@ def test_get_event_display_context__node_display_for_adornment_nodes():
     display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
 
     # THEN the subworkflow display should be included
-    assert str(MyNode.__id__) in display_context.node_displays
-    node_event_display = display_context.node_displays[str(MyNode.__id__)]
+    assert str(adornment_node_id) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(adornment_node_id)]
     assert node_event_display.subworkflow_display is not None
     assert str(inner_node_id) in node_event_display.subworkflow_display.node_displays
 
+    # AND the inner node should have the correct outputs
+    inner_node_display = node_event_display.subworkflow_display.node_displays[str(inner_node_id)]
+    assert inner_node_display.output_display.keys() == {"foo"}
+    assert node_event_display.output_display.keys() == expected_adornment_output_names
+
 
 def test_get_event_display_context__templating_node_input_display():
     # GIVEN a simple workflow with a templating node referencing another node output

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.16"
+version = "0.14.17"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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.17",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.17/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.17/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/vellum/workflows/nodes/core/retry_node/node.py

@@ -85,7 +85,7 @@ Message: {terminal_event.error.message}""",
     @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_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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_ai-0.14.16 → vellum_ai-0.14.17}/src/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()