vellum-ai 0.14.63__py3-none-any.whl → 1.11.2__py3-none-any.whl

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

@@ -17,6 +17,7 @@ from typing import (
     overload,
 )
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -27,9 +28,11 @@ from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
@@ -96,6 +99,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
                     map_node_event = self._event_queue.get(block=False)
                     index = map_node_event[0]
                     subworkflow_event = map_node_event[1]
+
                     self._context._emit_subworkflow_event(subworkflow_event)
 
                     if not is_workflow_event(subworkflow_event):
@@ -207,8 +211,29 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
 
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
-        parameter_type = reference.types[0]
+        parameter_type = reference.types[0] if len(reference.types) > 0 else object
         annotation = List[parameter_type]  # type: ignore[valid-type]
 
         previous_annotations = {prev: annotation for prev in outputs_class.__annotations__ if not prev.startswith("_")}
+        # Map node output is a list of the same type so we use annotation=List[parameter_type] and not reference
+        # class Outputs(BaseOutputs):
+        #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
+
+        # Create a NEW OutputReference with the List-wrapped type for discoverability during iteration
+        map_output_reference = OutputReference(
+            name=reference.name,
+            types=(annotation,),
+            instance=undefined,
+            outputs_class=outputs_class,
+        )
+        setattr(outputs_class, reference.name, map_output_reference)
+
+        subworkflow_class = cls.subworkflow.instance if isinstance(cls.subworkflow, NodeReference) else None
+        if subworkflow_class:
+            output_id = subworkflow_class.__output_ids__.get(reference.name) or uuid4_from_hash(
+                f"{cls.__id__}|{reference.name}"
+            )
+        else:
+            output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
+        cls.__output_ids__[reference.name] = output_id

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

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

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

@@ -6,7 +6,6 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.outputs import BaseOutputs
-from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -44,7 +43,7 @@ def test_retry_node__retry_on_error_code__missed():
 
         def run(self) -> Outputs:
             if self.attempt_number < 3:
-                raise Exception("This will not be retried")
+                raise NodeException(message="This will not be retried", code=WorkflowErrorCode.INTERNAL_ERROR)
 
             return self.Outputs(execution_count=self.attempt_number)
 
@@ -102,7 +101,7 @@ def test_retry_node__condition_arg_successfully_retries():
     # AND a retry node that retries on a condition
     @RetryNode.wrap(
         max_attempts=5,
-        retry_on_condition=LazyReference(lambda: State.count.less_than(3)),
+        retry_on_condition=State.count.less_than(3),
     )
     class TestNode(BaseNode[State]):
         attempt_number = RetryNode.SubworkflowInputs.attempt_number

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

@@ -7,7 +7,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.nodes.utils import parse_type_from_str, wrap_inputs_for_backward_compatibility
 from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -47,6 +47,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     Useful for lightweight data transformations and complex string templating.
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:stamp"
+        color = "brown"
+
     # The Jinja template to render.
     template: ClassVar[str] = ""
 
@@ -86,9 +90,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
 
     def _render_template(self) -> str:
         try:
+            wrapped_inputs = wrap_inputs_for_backward_compatibility(self.inputs)
             return render_sandboxed_jinja_template(
                 template=self.template,
-                input_values=self.inputs,
+                input_values=wrapped_inputs,
                 jinja_custom_filters={**self.jinja_custom_filters},
                 jinja_globals=self.jinja_globals,
             )

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -1,6 +1,6 @@
 import pytest
 import json
-from typing import List, Union
+from typing import Any, Dict, List, Union
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.function_call import FunctionCall
@@ -32,6 +32,54 @@ def test_templating_node__dict_output():
     assert json.loads(dump) == {"key": "value"}
 
 
+def test_templating_node__dict_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using dict type annotation."""
+
+    # GIVEN a templating node with dict output type that returns a dict
+    class DictTemplateNode(TemplatingNode[BaseState, dict]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = DictTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__any_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using Any type annotation."""
+
+    # GIVEN a templating node with Any output type that returns a dict
+    class AnyTemplateNode(TemplatingNode[BaseState, Any]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = AnyTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__dict_str_any_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using Dict[str, Any] type annotation."""
+
+    # GIVEN a templating node with Dict[str, Any] output type that returns a dict
+    class DictStrAnyTemplateNode(TemplatingNode[BaseState, Dict[str, Any]]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = DictStrAnyTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
 def test_templating_node__int_output():
     # GIVEN a templating node that outputs an integer
     class IntTemplateNode(TemplatingNode[BaseState, int]):
@@ -317,3 +365,148 @@ def test_api_error_templating_node():
 
     # THEN the output should be empty string
     assert outputs.result == ""
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String value access
+        ("{{ text_input.value }}", {"text_input": "hello world"}, "hello world"),
+        # Function call value access
+        (
+            "{{ func.value.name }}",
+            {"func": FunctionCall(name="test_function", arguments={"key": "value"})},
+            "test_function",
+        ),
+        # Array item value access
+        ("{{ items[0].value }}", {"items": ["apple"]}, "apple"),
+    ],
+    ids=["string_value", "function_call_value", "array_item_value"],
+)
+def test_templating_node__value_access_patterns_str(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # Dict value access
+        ("{{ data.value }}", {"data": {"name": "test", "score": 42}}, {"name": "test", "score": 42}),
+        # List value access
+        ("{{ items.value }}", {"items": ["item1", "item2", "item3"]}, ["item1", "item2", "item3"]),
+    ],
+    ids=["dict_value", "list_value"],
+)
+def test_templating_node__value_access_patterns_json(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, Json]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String type access
+        ("{{ text_input.type }}", {"text_input": "hello world"}, "STRING"),
+        # Function call type access
+        ("{{ func.type }}", {"func": FunctionCall(name="test_function", arguments={"key": "value"})}, "FUNCTION_CALL"),
+    ],
+    ids=["string_type", "function_call_type"],
+)
+def test_templating_node__type_access_patterns(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper type properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the type is accessible
+    assert outputs.result == expected_result
+
+
+def test_templating_node__nested_dict_access():
+    # GIVEN a templating node with nested dict access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{{ data.user.name }}"
+        inputs = {"data": {"user": {"name": "John Doe", "age": 30}, "status": "active"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN nested properties are accessible
+    assert outputs.result == "John Doe"
+
+
+def test_templating_node__list_iteration_wrapper_access():
+    # GIVEN a templating node that iterates over list with wrapper access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% for item in items %}{{ item.value }}{% if not loop.last %},{% endif %}{% endfor %}"
+        inputs = {"items": ["apple", "banana", "cherry"]}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN list iteration with wrapper access works
+    assert outputs.result == "apple,banana,cherry"
+
+
+def test_templating_node__conditional_type_checking():
+    # GIVEN a templating node with conditional type checking
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if input.type == 'STRING' %}{{ input.value }}{% else %}unknown{% endif %}"
+        inputs = {"input": "test string"}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN conditional type checking works
+    assert outputs.result == "test string"
+
+
+def test_templating_node__dict_wrapper_nonexistent_attribute_is_none():
+    """Test that non-existent attributes on DictWrapper evaluate to None."""
+
+    # GIVEN a templating node with nonexistent attr in the template
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if data.nonexistent_attr is none %}none_value{% else %}{{ data.nonexistent_attr }}{% endif %}"
+        inputs = {"data": {"existing_key": "existing_value"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN it should recognize the non-existent attribute as ""
+    assert outputs.result == ""

vellum/workflows/nodes/displayable/__init__.py

@@ -12,7 +12,10 @@ from .merge_node import MergeNode
 from .note_node import NoteNode
 from .prompt_deployment_node import PromptDeploymentNode
 from .search_node import SearchNode
+from .set_state_node import SetStateNode
 from .subworkflow_deployment_node import SubworkflowDeploymentNode
+from .tool_calling_node import ToolCallingNode
+from .web_search_node import WebSearchNode
 
 __all__ = [
     "APINode",
@@ -28,6 +31,9 @@ __all__ = [
     "SubworkflowDeploymentNode",
     "PromptDeploymentNode",
     "SearchNode",
+    "SetStateNode",
     "TemplatingNode",
+    "ToolCallingNode",
+    "WebSearchNode",
     "FinalOutputNode",
 ]

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

@@ -22,6 +22,10 @@ class APINode(BaseAPINode):
     for the bearer token authorization.
     """
 
+    class Display(BaseAPINode.Display):
+        icon = "vellum:icon:signal-stream"
+        color = "lightBlue"
+
     authorization_type: Optional[AuthorizationType] = None
     api_key_header_key: Optional[str] = None
     api_key_header_value: Optional[Union[str, VellumSecret]] = None
@@ -31,6 +35,8 @@ class APINode(BaseAPINode):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
     def run(self) -> BaseAPINode.Outputs:
+        self._validate()
+
         headers = self.headers or {}
         header_overrides = {}
         bearer_token = None
@@ -51,7 +57,9 @@ class APINode(BaseAPINode):
         final_headers = {**headers, **header_overrides}
 
         vellum_client_wrapper = self._context.vellum_client._client_wrapper
-        if self.url.startswith(vellum_client_wrapper._environment.default) and "X-API-Key" not in final_headers:
+        if self.url.startswith(vellum_client_wrapper._environment.default) and (
+            "X-API-Key" not in final_headers and "X_API_KEY" not in final_headers
+        ):
             final_headers["X-API-Key"] = vellum_client_wrapper.api_key
 
         return self._run(
@@ -61,4 +69,5 @@ class APINode(BaseAPINode):
             json=self.json,
             headers=final_headers,
             bearer_token=bearer_token,
+            timeout=self.timeout,
         )

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -3,6 +3,7 @@ import pytest
 from vellum import ExecuteApiResponse, VellumSecret as ClientVellumSecret
 from vellum.client.core.api_error import ApiError
 from vellum.workflows.constants import APIRequestMethod, AuthorizationType
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes import APINode
 from vellum.workflows.types.core import VellumSecret
@@ -15,6 +16,7 @@ def test_run_workflow__secrets(vellum_client):
         json_={"data": [1, 2, 3]},
         headers={"X-Response-Header": "bar"},
     )
+    vellum_client._client_wrapper.get_headers.return_value = {"User-Agent": "vellum-ai/1.0.6"}
 
     class SimpleBaseAPINode(APINode):
         method = APIRequestMethod.POST
@@ -34,7 +36,9 @@ def test_run_workflow__secrets(vellum_client):
     assert vellum_client.execute_api.call_count == 1
     assert vellum_client.execute_api.call_args.kwargs["url"] == "https://example.vellum.ai"
     assert vellum_client.execute_api.call_args.kwargs["body"] == {"key": "value"}
-    assert vellum_client.execute_api.call_args.kwargs["headers"] == {"X-Test-Header": "foo"}
+    headers = vellum_client.execute_api.call_args.kwargs["headers"]
+    assert headers["X-Test-Header"] == "foo"
+    assert "vellum-ai" in headers.get("User-Agent", "")
     bearer_token = vellum_client.execute_api.call_args.kwargs["bearer_token"]
     assert bearer_token == ClientVellumSecret(name="secret")
     assert terminal.headers == {"X-Response-Header": "bar"}
@@ -43,6 +47,7 @@ def test_run_workflow__secrets(vellum_client):
 def test_api_node_raises_error_when_api_call_fails(vellum_client):
     # GIVEN an API call that fails
     vellum_client.execute_api.side_effect = ApiError(status_code=400, body="API Error")
+    vellum_client._client_wrapper.get_headers.return_value = {"User-Agent": "vellum-ai/1.0.6"}
 
     class SimpleAPINode(APINode):
         method = APIRequestMethod.GET
@@ -69,7 +74,9 @@ def test_api_node_raises_error_when_api_call_fails(vellum_client):
     assert vellum_client.execute_api.call_count == 1
     assert vellum_client.execute_api.call_args.kwargs["url"] == "https://example.vellum.ai"
     assert vellum_client.execute_api.call_args.kwargs["body"] == {"key": "value"}
-    assert vellum_client.execute_api.call_args.kwargs["headers"] == {"X-Test-Header": "foo"}
+    headers = vellum_client.execute_api.call_args.kwargs["headers"]
+    assert headers["X-Test-Header"] == "foo"
+    assert "vellum-ai" in headers.get("User-Agent", "")
 
 
 def test_api_node_defaults_to_get_method(vellum_client):
@@ -158,3 +165,107 @@ def test_api_node__detects_client_environment_urls__does_not_override_headers(
     # AND the vellum API should have been called with the correct headers
     assert mock_response.last_request
     assert mock_response.last_request.headers["X-API-Key"] == "vellum-api-key-5678"
+
+
+def test_api_node__detects_client_environment_urls__legacy_does_not_override_headers(
+    mock_httpx_transport, mock_requests, monkeypatch
+):
+    # GIVEN an API node with a URL pointing back to Vellum
+    class SimpleAPINodeToVellum(APINode):
+        url = "https://api.vellum.ai"
+        headers = {
+            "X_API_KEY": "vellum-api-key-5678",
+        }
+
+    # AND a mock request sent to the Vellum API would return a 200
+    mock_response = mock_requests.get(
+        "https://api.vellum.ai",
+        status_code=200,
+        json={"data": [1, 2, 3]},
+    )
+
+    # AND an api key is set
+    monkeypatch.setenv("VELLUM_API_KEY", "vellum-api-key-1234")
+
+    # WHEN we run the node
+    node = SimpleAPINodeToVellum()
+    node.run()
+
+    # THEN the execute_api method should not have been called
+    mock_httpx_transport.handle_request.assert_not_called()
+
+    # AND the vellum API should have been called with the correct headers
+    assert mock_response.last_request
+    assert mock_response.last_request.headers["X_API_KEY"] == "vellum-api-key-5678"
+
+
+def test_api_node_raises_error_for_empty_url():
+    class APINodeWithEmptyURL(APINode):
+        method = APIRequestMethod.GET
+        url = ""
+
+    node = APINodeWithEmptyURL()
+
+    with pytest.raises(NodeException) as excinfo:
+        node.run()
+
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "URL is required and must be a non-empty string" in str(excinfo.value)
+
+
+def test_api_node_raises_error_for_none_url():
+    class APINodeWithNoneURL(APINode):
+        method = APIRequestMethod.GET
+        url = None  # type: ignore
+
+    node = APINodeWithNoneURL()
+
+    with pytest.raises(NodeException) as excinfo:
+        node.run()
+
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "URL is required and must be a non-empty string" in str(excinfo.value)
+
+
+def test_api_node_raises_error_for_whitespace_url():
+    class APINodeWithWhitespaceURL(APINode):
+        method = APIRequestMethod.GET
+        url = "   "
+
+    node = APINodeWithWhitespaceURL()
+
+    with pytest.raises(NodeException) as excinfo:
+        node.run()
+
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "URL is required and must be a non-empty string" in str(excinfo.value)
+
+
+def test_api_node_passes_timeout_to_vellum_client(vellum_client):
+    """Test that timeout is passed to vellum client as RequestOptions."""
+    vellum_client.execute_api.return_value = ExecuteApiResponse(
+        status_code=200,
+        text='{"result": "success"}',
+        json_={"result": "success"},
+        headers={"content-type": "application/json"},
+    )
+
+    # GIVEN an API node configured with a timeout value of 25 seconds
+    class APINodeWithTimeout(APINode):
+        method = APIRequestMethod.GET
+        authorization_type = AuthorizationType.BEARER_TOKEN
+        url = "https://example.com"
+        timeout = 25
+        bearer_token_value = VellumSecret(name="secret")
+
+    # WHEN the API node is executed
+    node = APINodeWithTimeout()
+    node.run()
+
+    # THEN the vellum client should be called exactly once
+    assert vellum_client.execute_api.call_count == 1
+    call_args = vellum_client.execute_api.call_args
+    request_options = call_args.kwargs["request_options"]
+    # AND the call should include RequestOptions with the correct timeout
+    assert request_options is not None
+    assert request_options["timeout_in_seconds"] == 25