vellum-ai 0.13.21__py3-none-any.whl → 0.13.22__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.22",
         }
         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/bases/inline_prompt_node/node.py

@@ -1,6 +1,6 @@
 import json
 from uuid import uuid4
-from typing import Callable, ClassVar, Generic, Iterator, List, Optional, Tuple, Union, cast
+from typing import Callable, ClassVar, Generic, Iterator, List, Optional, Tuple, Union
 
 from vellum import (
     AdHocExecutePromptEvent,
@@ -16,6 +16,7 @@ from vellum import (
     VellumVariable,
 )
 from vellum.client import RequestOptions
+from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
@@ -108,7 +109,14 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                         value=input_value,
                     )
                 )
-            elif isinstance(input_value, list) and all(isinstance(message, ChatMessage) for message in input_value):
+            elif isinstance(input_value, list) and all(
+                isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value
+            ):
+                chat_history = [
+                    message if isinstance(message, ChatMessage) else ChatMessage.model_validate(message.model_dump())
+                    for message in input_value
+                    if isinstance(message, (ChatMessage, ChatMessageRequest))
+                ]
                 input_variables.append(
                     VellumVariable(
                         # TODO: Determine whether or not we actually need an id here and if we do,
@@ -122,7 +130,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 input_values.append(
                     PromptRequestChatHistoryInput(
                         key=input_name,
-                        value=cast(List[ChatMessage], input_value),
+                        value=chat_history,
                     )
                 )
             else:

vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -1,3 +1,4 @@
+import json
 from uuid import UUID
 from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Sequence, Union, cast
 
@@ -12,9 +13,11 @@ from vellum import (
     StringInputRequest,
 )
 from vellum.client import RequestOptions
+from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
 from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
 from vellum.workflows.types import MergeBehavior
@@ -89,26 +92,29 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                         value=input_value,
                     )
                 )
-            elif isinstance(input_value, list) and all(isinstance(message, ChatMessage) for message in input_value):
+            elif isinstance(input_value, list) and all(
+                isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value
+            ):
                 compiled_inputs.append(
                     ChatHistoryInputRequest(
                         name=input_name,
                         value=cast(List[ChatMessage], input_value),
                     )
                 )
-            elif isinstance(input_value, dict):
-                # Note: We may want to fail early here if we know that input_value is not
-                #   JSON serializable.
+            else:
+                try:
+                    input_value = default_serializer(input_value)
+                except json.JSONDecodeError as e:
+                    raise NodeException(
+                        message=f"Failed to serialize input '{input_name}' of type '{input_value.__class__}': {e}",
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
+
                 compiled_inputs.append(
                     JsonInputRequest(
                         name=input_name,
-                        value=cast(Dict[str, Any], input_value),
+                        value=input_value,
                     )
                 )
-            else:
-                raise NodeException(
-                    message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
-                    code=WorkflowErrorCode.INVALID_INPUTS,
-                )
 
         return compiled_inputs