vellum-ai 0.14.17__py3-none-any.whl → 0.14.19__py3-none-any.whl

vellum/__init__.py

@@ -229,6 +229,7 @@ from .types import (
     NodeInputCompiledJsonValue,
     NodeInputCompiledNumberValue,
     NodeInputCompiledSearchResultsValue,
+    NodeInputCompiledSecretValue,
     NodeInputCompiledStringValue,
     NodeInputVariableCompiledValue,
     NodeOutputCompiledArrayValue,
@@ -777,6 +778,7 @@ __all__ = [
     "NodeInputCompiledJsonValue",
     "NodeInputCompiledNumberValue",
     "NodeInputCompiledSearchResultsValue",
+    "NodeInputCompiledSecretValue",
     "NodeInputCompiledStringValue",
     "NodeInputVariableCompiledValue",
     "NodeOutputCompiledArrayValue",

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

vellum/client/types/__init__.py

@@ -237,6 +237,7 @@ from .node_input_compiled_function_call_value import NodeInputCompiledFunctionCa
 from .node_input_compiled_json_value import NodeInputCompiledJsonValue
 from .node_input_compiled_number_value import NodeInputCompiledNumberValue
 from .node_input_compiled_search_results_value import NodeInputCompiledSearchResultsValue
+from .node_input_compiled_secret_value import NodeInputCompiledSecretValue
 from .node_input_compiled_string_value import NodeInputCompiledStringValue
 from .node_input_variable_compiled_value import NodeInputVariableCompiledValue
 from .node_output_compiled_array_value import NodeOutputCompiledArrayValue
@@ -759,6 +760,7 @@ __all__ = [
     "NodeInputCompiledJsonValue",
     "NodeInputCompiledNumberValue",
     "NodeInputCompiledSearchResultsValue",
+    "NodeInputCompiledSecretValue",
     "NodeInputCompiledStringValue",
     "NodeInputVariableCompiledValue",
     "NodeOutputCompiledArrayValue",

vellum/client/types/node_input_compiled_secret_value.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .vellum_secret import VellumSecret
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class NodeInputCompiledSecretValue(UniversalBaseModel):
+    node_input_id: str
+    key: str
+    type: typing.Literal["SECRET"] = "SECRET"
+    value: VellumSecret
+
+    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/node_input_variable_compiled_value.py

@@ -9,6 +9,7 @@ from .node_input_compiled_search_results_value import NodeInputCompiledSearchRes
 from .node_input_compiled_error_value import NodeInputCompiledErrorValue
 from .node_input_compiled_array_value import NodeInputCompiledArrayValue
 from .node_input_compiled_function_call_value import NodeInputCompiledFunctionCallValue
+from .node_input_compiled_secret_value import NodeInputCompiledSecretValue
 
 NodeInputVariableCompiledValue = typing.Union[
     NodeInputCompiledStringValue,
@@ -19,4 +20,5 @@ NodeInputVariableCompiledValue = typing.Union[
     NodeInputCompiledErrorValue,
     NodeInputCompiledArrayValue,
     NodeInputCompiledFunctionCallValue,
+    NodeInputCompiledSecretValue,
 ]

vellum/types/node_input_compiled_secret_value.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.node_input_compiled_secret_value 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/core/inline_subworkflow_node/node.py

@@ -4,7 +4,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.events.workflow import is_workflow_event
-from vellum.workflows.exceptions import NodeException
+from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
@@ -119,19 +119,21 @@ class InlineSubworkflowNode(
 
     def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        if self.subworkflow_inputs is undefined:
-            inputs_dict = {}
-            for descriptor in inputs_class:
-                if hasattr(self, descriptor.name):
-                    inputs_dict[descriptor.name] = getattr(self, descriptor.name)
-
-            return inputs_class(**inputs_dict)
-        elif isinstance(self.subworkflow_inputs, dict):
-            return inputs_class(**self.subworkflow_inputs)
-        elif isinstance(self.subworkflow_inputs, inputs_class):
-            return self.subworkflow_inputs
-        else:
-            raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")
+        try:
+            if self.subworkflow_inputs is undefined:
+                inputs_dict = {}
+                for descriptor in inputs_class:
+                    if hasattr(self, descriptor.name):
+                        inputs_dict[descriptor.name] = getattr(self, descriptor.name)
+                return inputs_class(**inputs_dict)
+            elif isinstance(self.subworkflow_inputs, dict):
+                return inputs_class(**self.subworkflow_inputs)
+            elif isinstance(self.subworkflow_inputs, inputs_class):
+                return self.subworkflow_inputs
+            else:
+                raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")
+        except WorkflowInitializationException as e:
+            raise NodeException(message=str(e), code=e.code)
 
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:

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

@@ -1,5 +1,7 @@
 import pytest
 
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
@@ -87,3 +89,30 @@ def test_inline_subworkflow_node__nested_try():
     # THEN we only have the outer node's outputs
     valid_events = [e for e in events if e.name == "bar"]
     assert len(valid_events) == len(events)
+
+
+def test_inline_subworkflow_node__base_inputs_validation():
+    """Test that InlineSubworkflowNode properly validates required inputs"""
+
+    # GIVEN a real subworkflow class with a required input
+    class SubworkflowInputs(BaseInputs):
+        required_input: str  # This is a required field without a default
+
+    class TestSubworkflow(BaseWorkflow[SubworkflowInputs, BaseState]):
+        pass
+
+    # AND a node that uses this subworkflow
+    class TestNode(InlineSubworkflowNode):
+        subworkflow = TestSubworkflow
+        subworkflow_inputs = {"required_input": None}
+
+    # WHEN we try to run the node
+    node = TestNode()
+
+    # THEN it should raise a NodeException
+    with pytest.raises(NodeException) as e:
+        list(node.run())
+
+    # AND the error message should indicate the missing required input
+    assert e.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "Required input variables required_input should have defined value" == str(e.value)

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,47 +41,64 @@ 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
 

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/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -1,4 +1,6 @@
 import pytest
+import json
+from unittest import mock
 from uuid import uuid4
 from typing import Any, Iterator, List
 
@@ -7,6 +9,7 @@ from vellum import (
     JinjaPromptBlock,
     PlainTextPromptBlock,
     PromptBlock,
+    PromptParameters,
     RichTextPromptBlock,
     VariablePromptBlock,
 )
@@ -18,7 +21,11 @@ from vellum.client.types.prompt_request_string_input import PromptRequestStringI
 from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.nodes.displayable.bases.inline_prompt_node import BaseInlinePromptNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.state.base import StateMeta
 
 
 def test_validation_with_missing_variables():
@@ -180,3 +187,112 @@ def test_validation_with_extra_variables(vellum_adhoc_prompt_client):
         PromptRequestStringInput(key="required_var", type="STRING", value="value"),
         PromptRequestStringInput(key="extra_var", type="STRING", value="extra_value"),
     ]
+
+
+def test_inline_prompt_node__json_output(vellum_adhoc_prompt_client):
+    """Confirm that InlinePromptNodes output the expected JSON when run."""
+
+    # GIVEN a node that subclasses InlinePromptNode
+    class Inputs(BaseInputs):
+        input: str
+
+    class State(BaseState):
+        pass
+
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        parameters = PromptParameters(
+            stop=[],
+            temperature=0.0,
+            max_tokens=4096,
+            top_p=1.0,
+            top_k=0,
+            frequency_penalty=0.0,
+            presence_penalty=0.0,
+            logit_bias=None,
+            custom_parameters={
+                "json_mode": False,
+                "json_schema": {
+                    "name": "get_result",
+                    "schema": {
+                        "type": "object",
+                        "required": ["result"],
+                        "properties": {"result": {"type": "string", "description": ""}},
+                    },
+                },
+            },
+        )
+
+    # AND a known JSON response from invoking an inline prompt
+    expected_json = {"result": "Hello, world!"}
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value=json.dumps(expected_json)),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = MyInlinePromptNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(input="Generate JSON.")),
+        )
+    )
+    outputs = [o for o in node.run()]
+
+    # THEN the node should have produced the outputs we expect
+    results_output = outputs[0]
+    assert results_output.name == "results"
+    assert results_output.value == expected_outputs
+
+    text_output = outputs[1]
+    assert text_output.name == "text"
+    assert text_output.value == '{"result": "Hello, world!"}'
+
+    json_output = outputs[2]
+    assert json_output.name == "json"
+    assert json_output.value == expected_json
+
+    # AND we should have made the expected call to Vellum search
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
+        blocks=[],
+        expand_meta=Ellipsis,
+        functions=None,
+        input_values=[],
+        input_variables=[],
+        ml_model="gpt-4o",
+        parameters=PromptParameters(
+            stop=[],
+            temperature=0.0,
+            max_tokens=4096,
+            top_p=1.0,
+            top_k=0,
+            frequency_penalty=0.0,
+            presence_penalty=0.0,
+            logit_bias=None,
+            custom_parameters={
+                "json_mode": False,
+                "json_schema": {
+                    "name": "get_result",
+                    "schema": {
+                        "type": "object",
+                        "required": ["result"],
+                        "properties": {"result": {"type": "string", "description": ""}},
+                    },
+                },
+            },
+        ),
+        request_options=mock.ANY,
+        settings=None,
+    )

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

@@ -46,14 +46,31 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
             )
 
         string_outputs = []
+        json_output = None
+
+        should_parse_json = False
+        if hasattr(self, "parameters"):
+            custom_params = self.parameters.custom_parameters
+            if custom_params and isinstance(custom_params, dict):
+                json_schema = custom_params.get("json_schema", {})
+                if (isinstance(json_schema, dict) and "schema" in json_schema) or custom_params.get("json_mode", {}):
+                    should_parse_json = True
+
         for output in outputs:
             if output.value is None:
                 continue
 
             if output.type == "STRING":
                 string_outputs.append(output.value)
+                if should_parse_json:
+                    try:
+                        parsed_json = json.loads(output.value)
+                        json_output = parsed_json
+                    except (json.JSONDecodeError, TypeError):
+                        pass
             elif output.type == "JSON":
                 string_outputs.append(json.dumps(output.value, indent=4))
+                json_output = output.value
             elif output.type == "FUNCTION_CALL":
                 string_outputs.append(output.value.model_dump_json(indent=4))
             else:
@@ -61,3 +78,6 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
 
         value = "\n".join(string_outputs)
         yield BaseOutput(name="text", value=value)
+
+        if json_output:
+            yield BaseOutput(name="json", value=json_output)

vellum/workflows/runner/runner.py

@@ -43,7 +43,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionSnapshottedEvent,
     WorkflowExecutionStreamingBody,
 )
-from vellum.workflows.exceptions import NodeException
+from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import NodeRunResponse
 from vellum.workflows.nodes.mocks import MockNodeExecutionArg
@@ -332,6 +332,18 @@ class WorkflowRunner(Generic[StateType]):
                     parent=parent_context,
                 )
             )
+        except WorkflowInitializationException as e:
+            self._workflow_event_inner_queue.put(
+                NodeExecutionRejectedEvent(
+                    trace_id=node.state.meta.trace_id,
+                    span_id=span_id,
+                    body=NodeExecutionRejectedBody(
+                        node_definition=node.__class__,
+                        error=e.error,
+                    ),
+                    parent=parent_context,
+                )
+            )
         except Exception as e:
             logger.exception(f"An unexpected error occurred while running node {node.__class__.__name__}")
 
@@ -563,6 +575,9 @@ class WorkflowRunner(Generic[StateType]):
             except NodeException as e:
                 self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
                 return
+            except WorkflowInitializationException as e:
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
+                return
             except Exception:
                 err_message = f"An unexpected error occurred while initializing node {node_cls.__name__}"
                 logger.exception(err_message)

{vellum_ai-0.14.17.dist-info → vellum_ai-0.14.19.dist-info}/METADATA

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