vellum-ai 1.4.0__tar.gz → 1.4.2__tar.gz

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/PKG-INFO

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

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_cli/tests/test_pull.py

@@ -1323,6 +1323,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have been updated with the correct workspace

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_cli/tests/test_push.py

@@ -721,6 +721,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have been updated with the correct workspace
@@ -882,6 +883,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have the same two workflows

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -163,9 +163,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         elif callable(function):
             normalized_functions = compile_function_definition(function)
         elif isinstance(function, DeploymentDefinition):
-            normalized_functions = compile_workflow_deployment_function_definition(
-                function.model_dump(), display_context.client
-            )
+            normalized_functions = compile_workflow_deployment_function_definition(function, display_context.client)
         else:
             raise ValueError(f"Unsupported function type: {type(function)}")
         return {

vellum_ai-1.4.2/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_final_output_node.py

@@ -0,0 +1,78 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_final_output_node_display__serialize_with_valid_types():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with matching type to that node
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> CorrectOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = CorrectOutput.Outputs.value
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should succeed without raising validation errors
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # AND the node should be properly serialized
+    assert "workflow_raw_data" in serialized_workflow
+    assert "nodes" in serialized_workflow["workflow_raw_data"]
+
+    # Find the terminal node in the serialized output
+    terminal_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "TERMINAL"
+    )
+    assert terminal_node is not None
+    assert terminal_node["id"] == str(CorrectOutput.__id__)
+
+
+def test_final_output_node_display__serialize_with_invalid_types_should_raise_error():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with mismatched types (expects list but gets str)
+    class BadOutput(FinalOutputNode[BaseState, list]):
+        """Output with type mismatch."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result  # str type, conflicts with list
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> BadOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = BadOutput.Outputs.value
+
+    # WHEN we attempt to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should complete without raising an exception
+    serialized_workflow = workflow_display.serialize()
+
+    # AND the error should be captured in workflow_display.errors
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+    assert "Output type mismatch" in str(errors[0])
+    assert "list" in str(errors[0])
+    assert "str" in str(errors[0])
+
+    # AND the serialized workflow should still be created
+    assert "workflow_raw_data" in serialized_workflow

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -437,6 +437,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -206,6 +206,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_ee/workflows/display/types.py

@@ -62,6 +62,9 @@ class WorkflowDisplayContext:
 
         raise error
 
+    def add_validation_error(self, error: Exception) -> None:
+        self._errors.append(error)
+
     def add_invalid_node(self, node: Type[BaseNode]) -> None:
         """Track a node that failed to serialize."""
         if node not in self._invalid_nodes:

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -196,6 +196,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             node_display = self.display_context.node_displays[node]
 
             try:
+                try:
+                    node.__validate__()
+                except ValueError as validation_error:
+                    # Only collect node validation errors directly to errors list, don't raise them
+                    self.display_context.add_validation_error(validation_error)
+
                 serialized_node = node_display.serialize(self.display_context)
             except (NotImplementedError, NodeValidationError) as e:
                 self.display_context.add_error(e)

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.4.0"
+version = "1.4.2"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.4.0",
+            "User-Agent": "vellum-ai/1.4.2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.4.0",
+            "X-Fern-SDK-Version": "1.4.2",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/constants.py

@@ -58,3 +58,7 @@ class APIRequestMethod(Enum):
 class AuthorizationType(Enum):
     BEARER_TOKEN = "BEARER_TOKEN"
     API_KEY = "API_KEY"
+
+
+class VellumIntegrationProviderType(Enum):
+    COMPOSIO = "COMPOSIO"

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/emitters/base.py

@@ -29,3 +29,11 @@ class BaseWorkflowEmitter(ABC):
     @abstractmethod
     def snapshot_state(self, state: BaseState) -> None:
         pass
+
+    @abstractmethod
+    def join(self) -> None:
+        """
+        Wait for any background threads or timers used by this emitter to complete.
+        This ensures all pending work is finished before the workflow terminates.
+        """
+        pass

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/emitters/vellum_emitter.py

@@ -135,3 +135,13 @@ class VellumEmitter(BaseWorkflowEmitter):
             request=events,  # type: ignore[arg-type]
             request_options=request_options,
         )
+
+    def join(self) -> None:
+        """
+        Wait for any background threads or timers used by this emitter to complete.
+        This ensures all pending work is finished before the workflow terminates.
+        """
+        self._flush_events()
+
+        if self._debounce_timer and self._debounce_timer.is_alive():
+            self._debounce_timer.join()

vellum_ai-1.4.2/src/vellum/workflows/events/exception_handling.py

@@ -0,0 +1,58 @@
+from uuid import uuid4
+from typing import Generator
+
+from vellum.workflows.context import get_execution_context
+from vellum.workflows.events.stream import WorkflowEventGenerator
+from vellum.workflows.events.workflow import (
+    WorkflowEvent,
+    WorkflowEventStream,
+    WorkflowExecutionInitiatedBody,
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionRejectedBody,
+    WorkflowExecutionRejectedEvent,
+)
+from vellum.workflows.exceptions import WorkflowInitializationException
+from vellum.workflows.inputs import BaseInputs
+
+
+def stream_initialization_exception(
+    exception: WorkflowInitializationException,
+) -> WorkflowEventStream:
+    """
+    Stream a workflow initiated event followed by a workflow rejected event for an initialization exception.
+
+    Args:
+        exception: The WorkflowInitializationException to stream events for
+
+    Returns:
+        WorkflowEventGenerator yielding initiated and rejected events
+    """
+
+    execution_context = get_execution_context()
+    span_id = uuid4()
+
+    def _generate_events() -> Generator[WorkflowEvent, None, None]:
+        initiated_event: WorkflowEvent = WorkflowExecutionInitiatedEvent(
+            trace_id=execution_context.trace_id,
+            span_id=span_id,
+            body=WorkflowExecutionInitiatedBody(
+                workflow_definition=exception.definition,
+                inputs=BaseInputs(),
+                initial_state=None,
+            ),
+            parent=execution_context.parent_context,
+        )
+        yield initiated_event
+
+        rejected_event = WorkflowExecutionRejectedEvent(
+            trace_id=execution_context.trace_id,
+            span_id=span_id,
+            body=WorkflowExecutionRejectedBody(
+                workflow_definition=exception.definition,
+                error=exception.error,
+            ),
+            parent=execution_context.parent_context,
+        )
+        yield rejected_event
+
+    return WorkflowEventGenerator(_generate_events(), span_id)

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/events/tests/test_event.py

@@ -7,6 +7,7 @@ from deepdiff import DeepDiff
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
+from vellum.workflows.events.exception_handling import stream_initialization_exception
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
     NodeExecutionFulfilledEvent,
@@ -26,6 +27,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
 )
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
@@ -460,3 +462,28 @@ def test_parent_context__deserialize_from_json__invalid_parent_context():
     assert event.parent.type == "UNKNOWN"
     assert event.parent.span_id == UUID("123e4567-e89b-12d3-a456-426614174000")
     assert event.parent.parent is None
+
+
+def test_workflow_event_generator_stream_initialization_exception():
+    """
+    Tests that stream_initialization_exception yields both initiated and rejected events with proper correlation.
+    """
+    exception = WorkflowInitializationException("Test initialization error", workflow_definition=MockWorkflow)
+
+    events = list(stream_initialization_exception(exception))
+
+    assert len(events) == 2
+
+    initiated_event = events[0]
+    assert initiated_event.name == "workflow.execution.initiated"
+    assert initiated_event.body.inputs is not None
+    assert initiated_event.body.initial_state is None
+    assert initiated_event.body.workflow_definition == MockWorkflow
+
+    rejected_event = events[1]
+    assert rejected_event.name == "workflow.execution.rejected"
+    assert rejected_event.body.error.message == "Test initialization error"
+    assert rejected_event.body.workflow_definition == MockWorkflow
+
+    assert initiated_event.trace_id == rejected_event.trace_id
+    assert initiated_event.span_id == rejected_event.span_id

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/exceptions.py

@@ -1,7 +1,10 @@
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type
 
 from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 
+if TYPE_CHECKING:
+    from vellum.workflows.workflows.base import BaseWorkflow
+
 
 class NodeException(Exception):
     def __init__(
@@ -29,9 +32,15 @@ class NodeException(Exception):
 
 
 class WorkflowInitializationException(Exception):
-    def __init__(self, message: str, code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS):
+    def __init__(
+        self,
+        message: str,
+        workflow_definition: Type["BaseWorkflow"],
+        code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS,
+    ):
         self.message = message
         self.code = code
+        self.definition = workflow_definition
         super().__init__(message)
 
     @property
@@ -40,7 +49,3 @@ class WorkflowInitializationException(Exception):
             message=self.message,
             code=self.code,
         )
-
-    @staticmethod
-    def of(workflow_error: WorkflowError) -> "WorkflowInitializationException":
-        return WorkflowInitializationException(message=workflow_error.message, code=workflow_error.code)

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/inputs/base.py

@@ -95,6 +95,7 @@ class BaseInputs(metaclass=_BaseInputsMeta):
                     raise WorkflowInitializationException(
                         message=f"Required input variables {name} should have defined value",
                         code=WorkflowErrorCode.INVALID_INPUTS,
+                        workflow_definition=self.__class__.__parent_class__,
                     )
 
             # If value provided in kwargs, set it on the instance

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/inputs/dataset_row.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict
 
-from pydantic import field_serializer
+from pydantic import Field, field_serializer
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
@@ -16,7 +16,7 @@ class DatasetRow(UniversalBaseModel):
     """
 
     label: str
-    inputs: BaseInputs
+    inputs: BaseInputs = Field(default_factory=BaseInputs)
 
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: BaseInputs) -> Dict[str, Any]:

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/nodes/bases/base.py

@@ -1,4 +1,4 @@
-from abc import ABC, ABCMeta
+from abc import ABC, ABCMeta, abstractmethod
 from dataclasses import field
 from functools import cached_property, reduce
 import inspect
@@ -215,6 +215,17 @@ class BaseNodeMeta(ABCMeta):
                 yield attr_value
                 yielded_attr_names.add(attr_name)
 
+    @abstractmethod
+    def __validate__(cls) -> None:
+        """
+        Validates the node.
+        Subclasses can override this method to implement their specific validation logic.
+        Called during serialization or explicit validation.
+
+        Default implementation performs no validation.
+        """
+        pass
+
 
 class _BaseNodeTriggerMeta(type):
     def __eq__(self, other: Any) -> bool:

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -112,4 +112,10 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
         if not target_node_output:
             return False
 
+        if not isinstance(target_node_output.instance, OutputReference):
+            return False
+
+        if target_node_output.instance.name != "text":
+            return False
+
         return True

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -45,9 +45,15 @@ from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePrompt
 from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
-from vellum.workflows.types.definition import DeploymentDefinition, MCPServer
+from vellum.workflows.types.definition import (
+    ComposioToolDefinition,
+    DeploymentDefinition,
+    MCPServer,
+    VellumIntegrationToolDefinition,
+)
 from vellum.workflows.types.generics import StateType, is_workflow_class
 from vellum.workflows.utils.functions import (
+    compile_composio_tool_definition,
     compile_function_definition,
     compile_inline_workflow_function_definition,
     compile_mcp_tool_definition,
@@ -134,7 +140,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 elif isinstance(function, DeploymentDefinition):
                     normalized_functions.append(
                         compile_workflow_deployment_function_definition(
-                            function.model_dump(),
+                            function,
                             vellum_client=self._context.vellum_client,
                         )
                     )
@@ -142,6 +148,14 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                     normalized_functions.append(compile_inline_workflow_function_definition(function))
                 elif callable(function):
                     normalized_functions.append(compile_function_definition(function))
+                elif isinstance(function, ComposioToolDefinition):
+                    normalized_functions.append(compile_composio_tool_definition(function))
+                elif isinstance(function, VellumIntegrationToolDefinition):
+                    # TODO: Implement compile_vellum_integration_tool_definition
+                    raise NotImplementedError(
+                        "VellumIntegrationToolDefinition support coming soon. "
+                        "This will be implemented when compile_vellum_integration_tool_definition is created."
+                    )
                 elif isinstance(function, MCPServer):
                     tool_definitions = compile_mcp_tool_definition(function)
                     for tool_def in tool_definitions:

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/nodes/displayable/final_output_node/node.py

@@ -5,6 +5,7 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import cast_to_output_type
 from vellum.workflows.ports import NodePorts
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -27,6 +28,7 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
             **annotations,
             "value": parent.get_output_type(),
         }
+
         return parent
 
     def get_output_type(cls) -> Type:
@@ -38,6 +40,63 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
         else:
             return all_args[1]
 
+    def __validate__(cls) -> None:
+        cls._validate_output_type_consistency(cls)
+
+    @classmethod
+    def _validate_output_type_consistency(mcs, cls: Type) -> None:
+        """
+        Validates that the declared output type of FinalOutputNode matches
+        the type of the descriptor assigned to the 'value' attribute in its Outputs class.
+
+        Raises ValueError if there's a type mismatch.
+        """
+        if not hasattr(cls, "Outputs"):
+            return
+
+        outputs_class = cls.Outputs
+        if not hasattr(outputs_class, "value"):
+            return
+
+        declared_output_type = cls.get_output_type()
+        value_descriptor = None
+
+        if "value" in outputs_class.__dict__:
+            value_descriptor = outputs_class.__dict__["value"]
+        else:
+            value_descriptor = getattr(outputs_class, "value")
+
+        if isinstance(value_descriptor, OutputReference):
+            descriptor_types = value_descriptor.types
+
+            type_mismatch = True
+            for descriptor_type in descriptor_types:
+                if descriptor_type == declared_output_type:
+                    type_mismatch = False
+                    break
+                try:
+                    if issubclass(descriptor_type, declared_output_type) or issubclass(
+                        declared_output_type, descriptor_type
+                    ):
+                        type_mismatch = False
+                        break
+                except TypeError:
+                    # Handle cases where types aren't classes (e.g., Union)
+                    if str(descriptor_type) == str(declared_output_type):
+                        type_mismatch = False
+                        break
+
+            if type_mismatch:
+                declared_type_name = getattr(declared_output_type, "__name__", str(declared_output_type))
+                descriptor_type_names = [getattr(t, "__name__", str(t)) for t in descriptor_types]
+
+                raise ValueError(
+                    f"Output type mismatch in {cls.__name__}: "
+                    f"FinalOutputNode is declared with output type '{declared_type_name}' "
+                    f"but the 'value' descriptor has type(s) {descriptor_type_names}. "
+                    f"The output descriptor type must match the declared FinalOutputNode output type."
+                )
+
 
 class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], metaclass=_FinalOutputNodeMeta):
     """

vellum_ai-1.4.2/src/vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py

@@ -0,0 +1,59 @@
+import pytest
+
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.nodes.displayable.inline_prompt_node import InlinePromptNode
+from vellum.workflows.state.base import BaseState
+
+
+def test_final_output_node__mismatched_output_type_should_raise_exception_when_ran():
+    # GIVEN a FinalOutputNode with a mismatched output type
+    class StringOutputNode(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = {"foo": "bar"}
+
+    # WHEN the node is run
+    node = StringOutputNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # THEN an error is raised
+    assert str(exc_info.value) == "Expected an output of type 'str', but received 'dict'"
+
+
+def test_final_output_node__mismatched_output_type_should_raise_exception():
+    # GIVEN a FinalOutputNode declared with list output type but has a string value type
+    class Output(FinalOutputNode[BaseState, list]):
+        """Output the extracted invoice line items as an array of objects."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = InlinePromptNode.Outputs.text
+
+    # WHEN attempting to validate the node class
+    # THEN a ValueError should be raised during validation
+    with pytest.raises(ValueError) as exc_info:
+        Output.__validate__()
+
+    # AND the error message should indicate the type mismatch
+    assert (
+        str(exc_info.value)
+        == "Output type mismatch in Output: FinalOutputNode is declared with output type 'list' but "
+        "the 'value' descriptor has type(s) ['str']. The output descriptor type must match the "
+        "declared FinalOutputNode output type."
+    )
+
+
+def test_final_output_node__matching_output_type_should_pass_validation():
+    # GIVEN a FinalOutputNode declared with correct matching types
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        """Output with correct type matching."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = InlinePromptNode.Outputs.text
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        CorrectOutput.__validate__()
+    except ValueError:
+        pytest.fail("Validation should not raise an exception for correct type matching")

{vellum_ai-1.4.0 → vellum_ai-1.4.2}/src/vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -2,6 +2,7 @@ from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set,
 
 from vellum import ChatMessage, PromptBlock
 from vellum.client.types.prompt_parameters import PromptParameters
+from vellum.client.types.prompt_settings import PromptSettings
 from vellum.prompts.constants import DEFAULT_PROMPT_PARAMETERS
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -47,6 +48,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
     max_prompt_iterations: ClassVar[Optional[int]] = 5
+    settings: ClassVar[Optional[Union[PromptSettings, Dict[str, Any]]]] = None
 
     class Outputs(BaseOutputs):
         """
@@ -150,6 +152,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             max_prompt_iterations=self.max_prompt_iterations,
             process_parameters_method=process_parameters_method,
             process_blocks_method=process_blocks_method,
+            settings=self.settings,
         )
 
         # Create the router node (handles routing logic only)