vellum-ai 0.13.21__tar.gz → 0.13.23__tar.gz

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/PKG-INFO

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

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/ee/vellum_cli/push.py

@@ -49,6 +49,9 @@ def push_command(
         else config.workflows
     )
 
+    if len(workflow_configs) > 1 and workspace:
+        workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
+
     if len(workflow_configs) == 0:
         raise ValueError(f"No workflow config for '{module}' found in project to push.")
 
@@ -230,15 +233,11 @@ def push_command(
 Visit at: https://app.vellum.ai/workflow-sandboxes/{response.workflow_sandbox_id}"""
         )
 
-    requires_save = False
     if not workflow_config.workflow_sandbox_id:
         workflow_config.workflow_sandbox_id = response.workflow_sandbox_id
-        requires_save = True
 
     if not workflow_config.deployments and response.workflow_deployment_id:
         workflow_config.deployments.append(WorkflowDeploymentConfig(id=UUID(response.workflow_deployment_id)))
-        requires_save = True
 
-    if requires_save:
-        config.save()
-        logger.info("Updated vellum.lock file.")
+    config.save()
+    logger.info("Updated vellum.lock.json file.")

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/ee/vellum_cli/tests/test_push.py

@@ -489,7 +489,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
 
     # AND the workflow sandbox id arg passed in should be `None`
     call_args = vellum_client_class.return_value.workflows.push.call_args.kwargs
-    assert call_args["workflow_sandbox_id"] is None
+    assert call_args["workflow_sandbox_id"] is None, result.output
 
     # AND with the correct api key
     vellum_client_class.assert_called_once_with(
@@ -509,3 +509,83 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
             "deployments": [],
             "ignore": None,
         }
+
+
+def test_push__workspace_option__both_options_already_configured(mock_module, vellum_client_class):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    workflow_sandbox_id = mock_module.workflow_sandbox_id
+    set_pyproject_toml = mock_module.set_pyproject_toml
+    second_workflow_sandbox_id = str(uuid4())
+
+    # AND the module is configured twice
+    set_pyproject_toml(
+        {
+            "workflows": [
+                {
+                    "module": module,
+                    "workflow_sandbox_id": workflow_sandbox_id,
+                },
+                {
+                    "module": module,
+                    "workflow_sandbox_id": second_workflow_sandbox_id,
+                    "workspace": "my_other_workspace",
+                },
+            ],
+            "workspaces": [
+                {
+                    "name": "my_other_workspace",
+                    "api_key": "MY_OTHER_VELLUM_API_KEY",
+                }
+            ],
+        }
+    )
+
+    # AND the .env file has the other api key stored
+    with open(os.path.join(temp_dir, ".env"), "w") as f:
+        f.write(
+            """\
+VELLUM_API_KEY=abcdef123456
+MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
+"""
+        )
+
+    # AND a workflow exists in the module
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns  workflow sandbox id
+    vellum_client_class.return_value.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=second_workflow_sandbox_id,
+    )
+
+    # WHEN calling `vellum push` on strict mode
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module, "--workspace", "my_other_workspace"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API once
+    vellum_client_class.return_value.workflows.push.assert_called_once()
+
+    # AND the workflow sandbox id arg passed in should be `None`
+    call_args = vellum_client_class.return_value.workflows.push.call_args.kwargs
+    assert call_args["workflow_sandbox_id"] == second_workflow_sandbox_id
+
+    # AND with the correct api key
+    vellum_client_class.assert_called_once_with(
+        api_key="aaabbbcccddd",
+        environment=mock.ANY,
+    )
+
+    # AND the vellum lock file should have the same two workflows
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        assert len(lock_file_content["workflows"]) == 2
+        assert lock_file_content["workflows"][0]["module"] == module
+        assert lock_file_content["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id
+        assert lock_file_content["workflows"][0]["workspace"] == "default"
+        assert lock_file_content["workflows"][1]["module"] == module
+        assert lock_file_content["workflows"][1]["workflow_sandbox_id"] == second_workflow_sandbox_id
+        assert lock_file_content["workflows"][1]["workspace"] == "my_other_workspace"

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/ee/vellum_ee/workflows/display/types.py

@@ -14,11 +14,10 @@ from vellum_ee.workflows.display.base import (
     WorkflowMetaDisplayType,
     WorkflowOutputDisplayType,
 )
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
-from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+    from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
     from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
 
 NodeDisplayType = TypeVar("NodeDisplayType", bound="BaseNodeDisplay")
@@ -63,32 +62,3 @@ class WorkflowDisplayContext(
     workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplayType] = field(default_factory=dict)
     edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplayType] = field(default_factory=dict)
     port_displays: Dict[Port, "PortDisplay"] = field(default_factory=dict)
-
-    def build_event_display_context(self) -> WorkflowEventDisplayContext:
-        workflow_outputs = {
-            output.name: self.workflow_output_displays[output].id for output in self.workflow_output_displays
-        }
-        workflow_inputs = {input.name: self.workflow_input_displays[input].id for input in self.workflow_input_displays}
-        node_displays = {str(node.__id__): self.node_displays[node] for node in self.node_displays}
-        temp_node_displays = {}
-        for node in node_displays:
-            current_node = node_displays[node]
-            input_display = {}
-            if issubclass(current_node.__class__, BaseNodeVellumDisplay):
-                input_display = current_node.node_input_ids_by_name  # type: ignore[attr-defined]
-            node_display_meta = {
-                output.name: current_node.output_display[output].id for output in current_node.output_display
-            }
-            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
-
-            temp_node_displays[node] = NodeDisplay(
-                input_display=input_display,
-                output_display=node_display_meta,
-                port_display=port_display_meta,
-            )
-        display_meta = WorkflowEventDisplayContext(
-            workflow_outputs=workflow_outputs,
-            workflow_inputs=workflow_inputs,
-            node_displays=temp_node_displays,
-        )
-        return display_meta

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/ee/vellum_ee/workflows/display/vellum.py

@@ -113,8 +113,8 @@ class WorkflowOutputVellumDisplayOverrides(WorkflowOutputDisplay, WorkflowOutput
     name: str
     label: str
     node_id: UUID
-    target_handle_id: UUID
     display_data: NodeDisplayData
+    target_handle_id: Optional[UUID] = None
 
 
 @dataclass

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -29,9 +29,15 @@ from vellum_ee.workflows.display.base import (
     WorkflowOutputDisplayOverridesType,
     WorkflowOutputDisplayType,
 )
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext, WorkflowEventDisplayContext
+from vellum_ee.workflows.display.types import (
+    NodeDisplay,
+    NodeDisplayType,
+    WorkflowDisplayContext,
+    WorkflowEventDisplayContext,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -343,4 +349,42 @@ class BaseWorkflowDisplay(
             display_class = importlib.import_module(workflow_display_module)
         except ModuleNotFoundError:
             return None
-        return display_class.WorkflowDisplay(workflow_class).display_context.build_event_display_context()
+
+        display_context = display_class.WorkflowDisplay(workflow_class).display_context
+        if not isinstance(display_context, WorkflowDisplayContext):
+            return None
+
+        workflow_outputs = {
+            output.name: display_context.workflow_output_displays[output].id
+            for output in display_context.workflow_output_displays
+        }
+        workflow_inputs = {
+            input.name: display_context.workflow_input_displays[input].id
+            for input in display_context.workflow_input_displays
+        }
+        node_displays = {
+            str(node.__id__): display_context.node_displays[node] for node in display_context.node_displays
+        }
+        temp_node_displays = {}
+        for node in node_displays:
+            current_node = node_displays[node]
+            input_display = {}
+            if isinstance(current_node, BaseNodeVellumDisplay):
+                input_display = current_node.node_input_ids_by_name
+            node_display_meta = {
+                output.name: current_node.output_display[output].id for output in current_node.output_display
+            }
+            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
+
+            temp_node_displays[node] = NodeDisplay(
+                input_display=input_display,
+                output_display=node_display_meta,
+                port_display=port_display_meta,
+            )
+
+        display_meta = WorkflowEventDisplayContext(
+            workflow_outputs=workflow_outputs,
+            workflow_inputs=workflow_inputs,
+            node_displays=temp_node_displays,
+        )
+        return display_meta

vellum_ai-0.13.23/ee/vellum_ee/workflows/tests/test_server.py

@@ -0,0 +1,9 @@
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+
+
+def test_load_workflow_event_display_context():
+    from vellum_ee.workflows.display.types import WorkflowEventDisplayContext
+
+    # We are actually just ensuring there are no circular dependencies when
+    # our Workflow Server imports this class.
+    assert issubclass(WorkflowEventDisplayContext, UniversalBaseModel)

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.21"
+version = "0.13.23"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.13.21 → vellum_ai-0.13.23}/src/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_ai-0.13.21 → vellum_ai-0.13.23}/src/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_ai-0.13.21 → vellum_ai-0.13.23}/src/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_ai-0.13.21 → vellum_ai-0.13.23}/src/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_ai-0.13.23/src/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_ai-0.13.23/src/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_ai-0.13.23/src/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_ai-0.13.23/src/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_ai-0.13.23/src/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_ai-0.13.23/src/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