vellum-ai 0.13.21__py3-none-any.whl → 0.13.23__py3-none-any.whl

vellum/__init__.py

@@ -92,6 +92,10 @@ from .types import (
     ErrorInput,
     ErrorVellumValue,
     ErrorVellumValueRequest,
+    ExecuteApiRequestBearerToken,
+    ExecuteApiRequestBody,
+    ExecuteApiRequestHeadersValue,
+    ExecuteApiResponse,
     ExecutePromptEvent,
     ExecutePromptResponse,
     ExecuteWorkflowResponse,
@@ -183,6 +187,7 @@ from .types import (
     MetadataFilterRuleCombinator,
     MetadataFilterRuleRequest,
     MetadataFiltersRequest,
+    MethodEnum,
     MetricDefinitionExecution,
     MetricDefinitionHistoryItem,
     MetricDefinitionInput,
@@ -437,6 +442,7 @@ from .types import (
     VellumErrorRequest,
     VellumImage,
     VellumImageRequest,
+    VellumSecret,
     VellumValue,
     VellumValueLogicalConditionGroupRequest,
     VellumValueLogicalConditionRequest,
@@ -617,6 +623,10 @@ __all__ = [
     "ErrorInput",
     "ErrorVellumValue",
     "ErrorVellumValueRequest",
+    "ExecuteApiRequestBearerToken",
+    "ExecuteApiRequestBody",
+    "ExecuteApiRequestHeadersValue",
+    "ExecuteApiResponse",
     "ExecutePromptEvent",
     "ExecutePromptResponse",
     "ExecuteWorkflowResponse",
@@ -713,6 +723,7 @@ __all__ = [
     "MetadataFilterRuleCombinator",
     "MetadataFilterRuleRequest",
     "MetadataFiltersRequest",
+    "MethodEnum",
     "MetricDefinitionExecution",
     "MetricDefinitionHistoryItem",
     "MetricDefinitionInput",
@@ -970,6 +981,7 @@ __all__ = [
     "VellumErrorRequest",
     "VellumImage",
     "VellumImageRequest",
+    "VellumSecret",
     "VellumValue",
     "VellumValueLogicalConditionGroupRequest",
     "VellumValueLogicalConditionRequest",

vellum/client/__init__.py

@@ -21,17 +21,22 @@ from .resources.workflow_sandboxes.client import WorkflowSandboxesClient
 from .resources.workflows.client import WorkflowsClient
 from .resources.workspace_secrets.client import WorkspaceSecretsClient
 from .resources.workspaces.client import WorkspacesClient
+from .types.method_enum import MethodEnum
+from .types.execute_api_request_body import ExecuteApiRequestBody
+from .types.execute_api_request_headers_value import ExecuteApiRequestHeadersValue
+from .types.execute_api_request_bearer_token import ExecuteApiRequestBearerToken
+from .core.request_options import RequestOptions
+from .types.execute_api_response import ExecuteApiResponse
+from .core.serialization import convert_and_respect_annotation_metadata
+from .core.pydantic_utilities import parse_obj_as
+from json.decoder import JSONDecodeError
+from .core.api_error import ApiError
 from .types.code_execution_runtime import CodeExecutionRuntime
 from .types.code_executor_input import CodeExecutorInput
 from .types.code_execution_package import CodeExecutionPackage
 from .types.vellum_variable_type import VellumVariableType
-from .core.request_options import RequestOptions
 from .types.code_executor_response import CodeExecutorResponse
-from .core.serialization import convert_and_respect_annotation_metadata
-from .core.pydantic_utilities import parse_obj_as
 from .errors.bad_request_error import BadRequestError
-from json.decoder import JSONDecodeError
-from .core.api_error import ApiError
 from .types.prompt_deployment_input_request import PromptDeploymentInputRequest
 from .types.prompt_deployment_expand_meta_request import PromptDeploymentExpandMetaRequest
 from .types.raw_prompt_execution_overrides_request import RawPromptExecutionOverridesRequest
@@ -149,6 +154,82 @@ class Vellum:
         self.workspace_secrets = WorkspaceSecretsClient(client_wrapper=self._client_wrapper)
         self.workspaces = WorkspacesClient(client_wrapper=self._client_wrapper)
 
+    def execute_api(
+        self,
+        *,
+        url: str,
+        method: typing.Optional[MethodEnum] = OMIT,
+        body: typing.Optional[ExecuteApiRequestBody] = OMIT,
+        headers: typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]] = OMIT,
+        bearer_token: typing.Optional[ExecuteApiRequestBearerToken] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> ExecuteApiResponse:
+        """
+        Parameters
+        ----------
+        url : str
+
+        method : typing.Optional[MethodEnum]
+
+        body : typing.Optional[ExecuteApiRequestBody]
+
+        headers : typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]]
+
+        bearer_token : typing.Optional[ExecuteApiRequestBearerToken]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        ExecuteApiResponse
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_key="YOUR_API_KEY",
+        )
+        client.execute_api(
+            url="url",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/execute-api",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json={
+                "url": url,
+                "method": method,
+                "body": convert_and_respect_annotation_metadata(
+                    object_=body, annotation=ExecuteApiRequestBody, direction="write"
+                ),
+                "headers": convert_and_respect_annotation_metadata(
+                    object_=headers, annotation=typing.Dict[str, ExecuteApiRequestHeadersValue], direction="write"
+                ),
+                "bearer_token": convert_and_respect_annotation_metadata(
+                    object_=bearer_token, annotation=ExecuteApiRequestBearerToken, direction="write"
+                ),
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    ExecuteApiResponse,
+                    parse_obj_as(
+                        type_=ExecuteApiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     def execute_code(
         self,
         *,
@@ -1414,6 +1495,90 @@ class AsyncVellum:
         self.workspace_secrets = AsyncWorkspaceSecretsClient(client_wrapper=self._client_wrapper)
         self.workspaces = AsyncWorkspacesClient(client_wrapper=self._client_wrapper)
 
+    async def execute_api(
+        self,
+        *,
+        url: str,
+        method: typing.Optional[MethodEnum] = OMIT,
+        body: typing.Optional[ExecuteApiRequestBody] = OMIT,
+        headers: typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]] = OMIT,
+        bearer_token: typing.Optional[ExecuteApiRequestBearerToken] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> ExecuteApiResponse:
+        """
+        Parameters
+        ----------
+        url : str
+
+        method : typing.Optional[MethodEnum]
+
+        body : typing.Optional[ExecuteApiRequestBody]
+
+        headers : typing.Optional[typing.Dict[str, ExecuteApiRequestHeadersValue]]
+
+        bearer_token : typing.Optional[ExecuteApiRequestBearerToken]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        ExecuteApiResponse
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.execute_api(
+                url="url",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/execute-api",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json={
+                "url": url,
+                "method": method,
+                "body": convert_and_respect_annotation_metadata(
+                    object_=body, annotation=ExecuteApiRequestBody, direction="write"
+                ),
+                "headers": convert_and_respect_annotation_metadata(
+                    object_=headers, annotation=typing.Dict[str, ExecuteApiRequestHeadersValue], direction="write"
+                ),
+                "bearer_token": convert_and_respect_annotation_metadata(
+                    object_=bearer_token, annotation=ExecuteApiRequestBearerToken, direction="write"
+                ),
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    ExecuteApiResponse,
+                    parse_obj_as(
+                        type_=ExecuteApiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     async def execute_code(
         self,
         *,

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

vellum/client/types/__init__.py

@@ -96,6 +96,10 @@ from .ephemeral_prompt_cache_config_type_enum import EphemeralPromptCacheConfigT
 from .error_input import ErrorInput
 from .error_vellum_value import ErrorVellumValue
 from .error_vellum_value_request import ErrorVellumValueRequest
+from .execute_api_request_bearer_token import ExecuteApiRequestBearerToken
+from .execute_api_request_body import ExecuteApiRequestBody
+from .execute_api_request_headers_value import ExecuteApiRequestHeadersValue
+from .execute_api_response import ExecuteApiResponse
 from .execute_prompt_event import ExecutePromptEvent
 from .execute_prompt_response import ExecutePromptResponse
 from .execute_workflow_response import ExecuteWorkflowResponse
@@ -191,6 +195,7 @@ from .metadata_filter_config_request import MetadataFilterConfigRequest
 from .metadata_filter_rule_combinator import MetadataFilterRuleCombinator
 from .metadata_filter_rule_request import MetadataFilterRuleRequest
 from .metadata_filters_request import MetadataFiltersRequest
+from .method_enum import MethodEnum
 from .metric_definition_execution import MetricDefinitionExecution
 from .metric_definition_history_item import MetricDefinitionHistoryItem
 from .metric_definition_input import MetricDefinitionInput
@@ -461,6 +466,7 @@ from .vellum_error_code_enum import VellumErrorCodeEnum
 from .vellum_error_request import VellumErrorRequest
 from .vellum_image import VellumImage
 from .vellum_image_request import VellumImageRequest
+from .vellum_secret import VellumSecret
 from .vellum_value import VellumValue
 from .vellum_value_logical_condition_group_request import VellumValueLogicalConditionGroupRequest
 from .vellum_value_logical_condition_request import VellumValueLogicalConditionRequest
@@ -606,6 +612,10 @@ __all__ = [
     "ErrorInput",
     "ErrorVellumValue",
     "ErrorVellumValueRequest",
+    "ExecuteApiRequestBearerToken",
+    "ExecuteApiRequestBody",
+    "ExecuteApiRequestHeadersValue",
+    "ExecuteApiResponse",
     "ExecutePromptEvent",
     "ExecutePromptResponse",
     "ExecuteWorkflowResponse",
@@ -697,6 +707,7 @@ __all__ = [
     "MetadataFilterRuleCombinator",
     "MetadataFilterRuleRequest",
     "MetadataFiltersRequest",
+    "MethodEnum",
     "MetricDefinitionExecution",
     "MetricDefinitionHistoryItem",
     "MetricDefinitionInput",
@@ -951,6 +962,7 @@ __all__ = [
     "VellumErrorRequest",
     "VellumImage",
     "VellumImageRequest",
+    "VellumSecret",
     "VellumValue",
     "VellumValueLogicalConditionGroupRequest",
     "VellumValueLogicalConditionRequest",

vellum/client/types/execute_api_request_bearer_token.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .vellum_secret import VellumSecret
+
+ExecuteApiRequestBearerToken = typing.Union[str, VellumSecret]

vellum/client/types/execute_api_request_body.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+ExecuteApiRequestBody = typing.Union[str, typing.Dict[str, typing.Optional[typing.Any]]]

vellum/client/types/execute_api_request_headers_value.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .vellum_secret import VellumSecret
+
+ExecuteApiRequestHeadersValue = typing.Union[str, VellumSecret]

vellum/client/types/execute_api_response.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class ExecuteApiResponse(UniversalBaseModel):
+    status_code: int
+    text: str
+    json_: typing_extensions.Annotated[typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="json")]
+    headers: typing.Dict[str, str]
+
+    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/method_enum.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+MethodEnum = typing.Union[typing.Literal["POST", "GET", "PATCH", "PUT", "DELETE"], typing.Any]

vellum/client/types/vellum_secret.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class VellumSecret(UniversalBaseModel):
+    name: str
+
+    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/plugins/pydantic.py

@@ -1,6 +1,7 @@
 from functools import lru_cache
 from typing import Any, Dict, Literal, Optional, Tuple, Union
 
+from pydantic.fields import FieldInfo
 from pydantic.plugin import (
     PydanticPluginProtocol,
     SchemaKind,
@@ -39,11 +40,22 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
         if not isinstance(input, dict):
             return
 
+        if self_instance:
+            model_fields: Dict[str, FieldInfo] = self_instance.model_fields
+        else:
+            model_fields = {}
+
         self.tracked_descriptors = {}
         BaseDescriptor = import_base_descriptor()
 
         for key, value in input.items():
-            if isinstance(value, BaseDescriptor):
+            field_info = model_fields.get(key)
+            if isinstance(value, BaseDescriptor) and (
+                not field_info
+                or not field_info.annotation
+                or not isinstance(field_info.annotation, type)
+                or not issubclass(field_info.annotation, BaseDescriptor)
+            ):
                 self.tracked_descriptors[key] = value
                 # TODO: This does not yet work for descriptors that map to more complex types
                 # https://app.shortcut.com/vellum/story/4636

vellum/types/execute_api_request_bearer_token.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.execute_api_request_bearer_token import *

vellum/types/execute_api_request_body.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.execute_api_request_body import *

vellum/types/execute_api_request_headers_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.execute_api_request_headers_value import *

vellum/types/execute_api_response.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.execute_api_response import *

vellum/types/method_enum.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.method_enum import *

vellum/types/vellum_secret.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.vellum_secret import *

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

@@ -78,6 +78,7 @@ class InlineSubworkflowNode(
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
                 event_filter=all_workflow_event_filter,
+                node_output_mocks=self._context._get_all_node_output_mocks(),
             )
 
         outputs: Optional[BaseOutputs] = None

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

@@ -152,6 +152,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         )
         events = subworkflow.stream(
             inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),
+            node_output_mocks=self._context._get_all_node_output_mocks(),
             event_filter=all_workflow_event_filter,
         )
 

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

@@ -44,6 +44,7 @@ class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
             )
             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()

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

@@ -1,5 +1,6 @@
 from typing import Callable, Generic, Iterator, Optional, Set, Type
 
+from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
@@ -26,13 +27,16 @@ class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
         error: Optional[WorkflowError] = None
 
     def run(self) -> Iterator[BaseOutput]:
-        subworkflow = self.subworkflow(
-            parent_state=self.state,
-            context=WorkflowContext(vellum_client=self._context.vellum_client),
-        )
-        subworkflow_stream = subworkflow.stream(
-            event_filter=all_workflow_event_filter,
-        )
+        parent_context = get_parent_context() or self._context.parent_context
+        with execution_context(parent_context=parent_context):
+            subworkflow = self.subworkflow(
+                parent_state=self.state,
+                context=WorkflowContext(vellum_client=self._context.vellum_client),
+            )
+            subworkflow_stream = subworkflow.stream(
+                event_filter=all_workflow_event_filter,
+                node_output_mocks=self._context._get_all_node_output_mocks(),
+            )
 
         outputs: Optional[BaseOutputs] = None
         exception: Optional[NodeException] = None

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

@@ -33,6 +33,7 @@ class APINode(BaseAPINode):
     def run(self) -> BaseAPINode.Outputs:
         headers = self.headers or {}
         header_overrides = {}
+        bearer_token = None
 
         if (
             self.authorization_type == AuthorizationType.API_KEY
@@ -40,9 +41,17 @@ class APINode(BaseAPINode):
             and self.api_key_header_value
         ):
             header_overrides[self.api_key_header_key] = self.api_key_header_value
-        elif self.authorization_type == AuthorizationType.BEARER_TOKEN:
+        elif self.authorization_type == AuthorizationType.BEARER_TOKEN and isinstance(self.bearer_token_value, str):
             header_overrides["Authorization"] = f"Bearer {self.bearer_token_value}"
-
+        elif self.authorization_type == AuthorizationType.BEARER_TOKEN and isinstance(
+            self.bearer_token_value, VellumSecret
+        ):
+            bearer_token = self.bearer_token_value
         return self._run(
-            method=self.method, url=self.url, data=self.data, json=self.json, headers={**headers, **header_overrides}
+            method=self.method,
+            url=self.url,
+            data=self.data or self.json,
+            json=self.json,
+            headers={**headers, **header_overrides},
+            bearer_token=bearer_token,
         )

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

@@ -0,0 +1,34 @@
+from vellum import ExecuteApiResponse, VellumSecret as ClientVellumSecret
+from vellum.workflows.constants import APIRequestMethod, AuthorizationType
+from vellum.workflows.nodes import APINode
+from vellum.workflows.state import BaseState
+from vellum.workflows.types.core import VellumSecret
+
+
+def test_run_workflow__secrets(vellum_client):
+    vellum_client.execute_api.return_value = ExecuteApiResponse(
+        status_code=200,
+        text='{"status": 200, "data": [1, 2, 3]}',
+        json_={"data": [1, 2, 3]},
+        headers={"X-Response-Header": "bar"},
+    )
+
+    class SimpleBaseAPINode(APINode):
+        method = APIRequestMethod.POST
+        authorization_type = AuthorizationType.BEARER_TOKEN
+        url = "https://api.vellum.ai"
+        body = {
+            "key": "value",
+        }
+        headers = {
+            "X-Test-Header": "foo",
+        }
+        bearer_token_value = VellumSecret(name="secret")
+
+    node = SimpleBaseAPINode(state=BaseState())
+    terminal = node.run()
+
+    assert vellum_client.execute_api.call_count == 1
+    bearer_token = vellum_client.execute_api.call_args.kwargs["bearer_token"]
+    assert bearer_token == ClientVellumSecret(name="secret")
+    assert terminal.headers == {"X-Response-Header": "bar"}

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

@@ -3,6 +3,7 @@ from typing import Any, Dict, Generic, Optional, Union
 from requests import Request, RequestException, Session
 from requests.exceptions import JSONDecodeError
 
+from vellum.client.types.vellum_secret import VellumSecret as ClientVellumSecret
 from vellum.workflows.constants import APIRequestMethod
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -45,29 +46,49 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         self,
         method: APIRequestMethod,
         url: str,
-        data: Optional[str] = None,
+        data: Optional[Union[str, Any]] = None,
         json: Any = None,
         headers: Any = None,
+        bearer_token: Optional[VellumSecret] = None,
     ) -> Outputs:
+        vellum_instance = False
+        for header in headers or {}:
+            if isinstance(headers[header], VellumSecret):
+                vellum_instance = True
+        if vellum_instance or bearer_token:
+            return self._vellum_execute_api(bearer_token, data, headers, method, url)
+        else:
+            return self._local_execute_api(data, headers, json, method, url)
+
+    def _local_execute_api(self, data, headers, json, method, url):
         try:
             prepped = Request(method=method.value, url=url, data=data, json=json, headers=headers).prepare()
         except Exception as e:
             raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
-
         try:
             with Session() as session:
                 response = session.send(prepped)
         except RequestException as e:
             raise NodeException(f"HTTP request failed: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
-
         try:
             json = response.json()
         except JSONDecodeError:
             json = None
-
         return self.Outputs(
             json=json,
             headers={header: value for header, value in response.headers.items()},
             status_code=response.status_code,
             text=response.text,
         )
+
+    def _vellum_execute_api(self, bearer_token, data, headers, method, url):
+        client_vellum_secret = ClientVellumSecret(name=bearer_token.name) if bearer_token else None
+        vellum_response = self._context.vellum_client.execute_api(
+            url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
+        )
+        return self.Outputs(
+            json=vellum_response.json_,
+            headers={header: value for header, value in vellum_response.headers.items()},
+            status_code=vellum_response.status_code,
+            text=vellum_response.text,
+        )