@bodhiapp/ts-client 0.1.11 → 0.1.13

package/dist/openapi-typescript/openapi-schema.d.ts

@@ -271,7 +271,7 @@ export interface paths {
         put?: never;
         /**
          * Request Resource Access
-         * @description Requests access permissions for an application client to access this resource server's protected resources.
+         * @description Requests access permissions for an application client to access this resource server's protected resources. Supports caching via optional version parameter.
          */
         post: operations["requestAccess"];
         delete?: never;
@@ -465,6 +465,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/bodhi/v1/models/refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Refresh Model Metadata
+         * @description Refresh metadata for models. Supports two modes via discriminated request body:
+         *
+         *     - Bulk async: `{"source": "all"}` triggers background extraction for all local GGUF models (202 Accepted)
+         *
+         *     - Single sync: `{"source": "model", "repo": "...", "filename": "...", "snapshot": "..."}` performs immediate extraction (200 OK)
+         *
+         *     Requires PowerUser permissions.
+         */
+        post: operations["refreshModelMetadata"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/bodhi/v1/models/{alias}": {
         parameters: {
             query?: never;
@@ -502,6 +528,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/bodhi/v1/queue": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Queue Status
+         * @description Returns the current status of the metadata refresh queue. Requires PowerUser permissions.
+         */
+        get: operations["getQueueStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/bodhi/v1/settings": {
         parameters: {
             query?: never;
@@ -622,6 +668,101 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/bodhi/v1/toolset_types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List all available toolset types with their tools
+         * @description For OAuth tokens, filters types by scope_toolset-* scopes in the token.
+         */
+        get: operations["listToolsetTypes"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/bodhi/v1/toolset_types/{type_id}/app-config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Enable a toolset type at app level (admin only - enforced by auth middleware) */
+        put: operations["enableToolsetType"];
+        post?: never;
+        /** Disable a toolset type at app level (admin only - enforced by auth middleware) */
+        delete: operations["disableToolsetType"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/bodhi/v1/toolsets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List all toolsets for the authenticated user
+         * @description For OAuth tokens, filters toolsets by scope_toolset-* scopes in the token.
+         */
+        get: operations["listToolsets"];
+        put?: never;
+        /** Create a new toolset */
+        post: operations["createToolset"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/bodhi/v1/toolsets/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a specific toolset by ID */
+        get: operations["getToolset"];
+        /** Update a toolset (full PUT semantics) */
+        put: operations["updateToolset"];
+        post?: never;
+        /** Delete a toolset */
+        delete: operations["deleteToolset"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/bodhi/v1/toolsets/{id}/execute/{method}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Execute a tool method on a toolset */
+        post: operations["executeToolset"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/bodhi/v1/user": {
         parameters: {
             query?: never;
@@ -939,6 +1080,16 @@ export interface components {
             /** @enum {string} */
             action: "set";
         };
+        /** @description API key update enum (mirrors services::db::ApiKeyUpdate) */
+        ApiKeyUpdateDto: {
+            /** @enum {string} */
+            action: "Keep";
+        } | {
+            /** @description Set a new API key (or clear if None) */
+            value: string | null;
+            /** @enum {string} */
+            action: "Set";
+        };
         /**
          * @description Response containing API model configuration
          * @example {
@@ -999,9 +1150,26 @@ export interface components {
         };
         AppAccessRequest: {
             app_client_id: string;
+            /** @description Optional version for cache lookup - if matches cached config, skips auth server call */
+            version?: string | null;
+            /** @description Optional toolset scope IDs to register with resource-client for token exchange */
+            toolset_scope_ids?: string[] | null;
         };
         AppAccessResponse: {
             scope: string;
+            /** @description List of toolsets the app-client is configured to access */
+            toolsets?: components["schemas"]["AppClientToolset"][];
+            /** @description Version of app-client's toolset configuration on auth server */
+            app_client_config_version?: string | null;
+        };
+        /** @description Toolset configuration from app-client registration */
+        AppClientToolset: {
+            id: string;
+            scope: string;
+            /** @description client scope UUID for cache validation */
+            scope_id?: string;
+            /** @description True if scope has been added to resource-client as optional scope */
+            added_to_resource_client?: boolean | null;
         };
         /**
          * @description Application information and status
@@ -1031,6 +1199,29 @@ export interface components {
          * @enum {string}
          */
         AppStatus: "setup" | "ready" | "resource-admin";
+        /** @description App-level configuration for a toolset (admin-controlled) */
+        AppToolsetConfig: {
+            /** @description Toolset identifier (e.g., "builtin-exa-web-search") */
+            toolset_id: string;
+            /** @description Whether the toolset is enabled for this app instance */
+            enabled: boolean;
+            /** @description User ID of the admin who last updated this configuration */
+            updated_by: string;
+            /**
+             * Format: date-time
+             * @description When this configuration was created
+             * @example 2024-11-10T04:52:06.786Z
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description When this configuration was last updated
+             * @example 2024-11-10T04:52:06.786Z
+             */
+            updated_at: string;
+        };
+        /** @description Response with app-level toolset configuration */
+        AppToolsetConfigResponse: components["schemas"]["AppToolsetConfig"];
         /**
          * @description Request body for approving access with role assignment
          * @example {
@@ -1102,23 +1293,46 @@ export interface components {
             finish_reason?: null | components["schemas"]["FinishReason"];
             logprobs?: null | components["schemas"]["ChatChoiceLogprobs"];
         };
+        ChatCompletionAllowedTools: {
+            /** @description Constrains the tools available to the model to a pre-defined set.
+             *
+             *     `auto` allows the model to pick from among the allowed tools and generate a
+             *     message.
+             *
+             *     `required` requires the model to call one or more of the allowed tools. */
+            mode: components["schemas"]["ToolChoiceAllowedMode"];
+            /** @description A list of tool definitions that the model should be allowed to call.
+             *
+             *     For the Chat Completions API, the list of tool definitions might look like:
+             *     ```json
+             *     [
+             *       { "type": "function", "function": { "name": "get_weather" } },
+             *       { "type": "function", "function": { "name": "get_time" } }
+             *     ]
+             *     ``` */
+            tools: unknown[];
+        };
+        ChatCompletionAllowedToolsChoice: {
+            allowed_tools: components["schemas"]["ChatCompletionAllowedTools"][];
+        };
         ChatCompletionAudio: {
-            /** @description The voice the model uses to respond. Supported voices are `ash`, `ballad`, `coral`, `sage`, and `verse` (also supported but not recommended are `alloy`, `echo`, and `shimmer`; these voices are less expressive). */
+            /** @description The voice the model uses to respond. Supported built-in voices are `alloy`, `ash`,
+             *     `ballad`, `coral`, `echo`, `fable`, `nova`, `onyx`, `sage`, `shimmer`, `marin`, and `cedar`. */
             voice: components["schemas"]["ChatCompletionAudioVoice"];
-            /** @description Specifies the output audio format. Must be one of `wav`, `mp3`, `flac`, `opus`, or `pcm16`. */
+            /** @description Specifies the output audio format. Must be one of `wav`, `aac`, `mp3`, `flac`, `opus`, or `pcm16`. */
             format: components["schemas"]["ChatCompletionAudioFormat"];
         };
         /** @enum {string} */
-        ChatCompletionAudioFormat: "wav" | "mp3" | "flac" | "opus" | "pcm16";
-        /** @enum {string} */
-        ChatCompletionAudioVoice: "alloy" | "ash" | "ballad" | "coral" | "echo" | "sage" | "shimmer" | "verse";
+        ChatCompletionAudioFormat: "wav" | "aac" | "mp3" | "flac" | "opus" | "pcm16";
+        ChatCompletionAudioVoice: "alloy" | "ash" | "ballad" | "coral" | "echo" | "fable" | "nova" | "onyx" | "sage" | "shimmer" | {
+            other: string;
+        };
         ChatCompletionFunctionCall: "none" | "auto" | {
             /** @description Forces the model to call the specified function. */
             Function: {
                 name: string;
             };
         };
-        /** @deprecated */
         ChatCompletionFunctions: {
             /** @description The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64. */
             name: string;
@@ -1129,11 +1343,15 @@ export interface components {
              *     Omitting `parameters` defines a function with an empty parameter list. */
             parameters: unknown;
         };
+        ChatCompletionMessageCustomToolCall: {
+            /** @description The ID of the tool call. */
+            id: string;
+            /** @description The custom tool that the model called. */
+            custom_tool: components["schemas"]["CustomTool"];
+        };
         ChatCompletionMessageToolCall: {
             /** @description The ID of the tool call. */
             id: string;
-            /** @description The type of the tool. Currently, only `function` is supported. */
-            type: components["schemas"]["ChatCompletionToolType"];
             /** @description The function that the model called. */
             function: components["schemas"]["FunctionCall"];
         };
@@ -1142,25 +1360,23 @@ export interface components {
             index: number;
             /** @description The ID of the tool call. */
             id?: string | null;
-            type?: null | components["schemas"]["ChatCompletionToolType"];
+            type?: null | components["schemas"]["FunctionType"];
             function?: null | components["schemas"]["FunctionCallStream"];
         };
-        /**
-         * @description Output types that you would like the model to generate for this request.
-         *
-         *     Most models are capable of generating text, which is the default: `["text"]`
-         *
-         *     The `gpt-4o-audio-preview` model can also be used to [generate
-         *     audio](https://platform.openai.com/docs/guides/audio). To request that this model generate both text and audio responses, you can use: `["text", "audio"]`
-         * @enum {string}
-         */
-        ChatCompletionModalities: "text" | "audio";
+        ChatCompletionMessageToolCalls: (components["schemas"]["ChatCompletionMessageToolCall"] & {
+            /** @enum {string} */
+            type: "function";
+        }) | (components["schemas"]["ChatCompletionMessageCustomToolCall"] & {
+            /** @enum {string} */
+            type: "custom";
+        });
         /** @description Specifies a tool the model should use. Use to force the model to call a specific function. */
         ChatCompletionNamedToolChoice: {
-            /** @description The type of the tool. Currently, only `function` is supported. */
-            type: components["schemas"]["ChatCompletionToolType"];
             function: components["schemas"]["FunctionName"];
         };
+        ChatCompletionNamedToolChoiceCustom: {
+            custom: components["schemas"]["CustomName"];
+        };
         ChatCompletionRequestAssistantMessage: {
             content?: null | components["schemas"]["ChatCompletionRequestAssistantMessageContent"];
             /** @description The refusal message by the assistant. */
@@ -1168,7 +1384,7 @@ export interface components {
             /** @description An optional name for the participant. Provides the model information to differentiate between participants of the same role. */
             name?: string | null;
             audio?: null | components["schemas"]["ChatCompletionRequestAssistantMessageAudio"];
-            tool_calls?: components["schemas"]["ChatCompletionMessageToolCall"][] | null;
+            tool_calls?: components["schemas"]["ChatCompletionMessageToolCalls"][] | null;
             function_call?: null | components["schemas"]["FunctionCall"];
         };
         ChatCompletionRequestAssistantMessageAudio: {
@@ -1189,7 +1405,11 @@ export interface components {
             /** @description An optional name for the participant. Provides the model information to differentiate between participants of the same role. */
             name?: string | null;
         };
-        ChatCompletionRequestDeveloperMessageContent: string | components["schemas"]["ChatCompletionRequestMessageContentPartText"][];
+        ChatCompletionRequestDeveloperMessageContent: string | components["schemas"]["ChatCompletionRequestDeveloperMessageContentPart"][];
+        ChatCompletionRequestDeveloperMessageContentPart: components["schemas"]["ChatCompletionRequestMessageContentPartText"] & {
+            /** @enum {string} */
+            type: "text";
+        };
         ChatCompletionRequestFunctionMessage: {
             /** @description The return value from the function call, to return to the model. */
             content?: string | null;
@@ -1219,6 +1439,9 @@ export interface components {
         ChatCompletionRequestMessageContentPartAudio: {
             input_audio: components["schemas"]["InputAudio"];
         };
+        ChatCompletionRequestMessageContentPartFile: {
+            file: components["schemas"]["FileObject"];
+        };
         ChatCompletionRequestMessageContentPartImage: {
             image_url: components["schemas"]["ImageUrl"];
         };
@@ -1267,6 +1490,9 @@ export interface components {
         }) | (components["schemas"]["ChatCompletionRequestMessageContentPartAudio"] & {
             /** @enum {string} */
             type: "input_audio";
+        }) | (components["schemas"]["ChatCompletionRequestMessageContentPartFile"] & {
+            /** @enum {string} */
+            type: "file";
         });
         /** @description A chat completion message generated by the model. */
         ChatCompletionResponseMessage: {
@@ -1275,17 +1501,25 @@ export interface components {
             /** @description The refusal message generated by the model. */
             refusal?: string | null;
             /** @description The tool calls generated by the model, such as function calls. */
-            tool_calls?: components["schemas"]["ChatCompletionMessageToolCall"][] | null;
+            tool_calls?: components["schemas"]["ChatCompletionMessageToolCalls"][] | null;
+            annotations?: components["schemas"]["ChatCompletionResponseMessageAnnotation"][] | null;
             /** @description The role of the author of this message. */
             role: components["schemas"]["Role"];
             function_call?: null | components["schemas"]["FunctionCall"];
             audio?: null | components["schemas"]["ChatCompletionResponseMessageAudio"];
+            /** @description The contents of the reasoning message. */
+            reasoning_content?: string | null;
+        };
+        ChatCompletionResponseMessageAnnotation: {
+            url_citation: components["schemas"]["UrlCitation"];
+            /** @enum {string} */
+            type: "url_citation";
         };
         ChatCompletionResponseMessageAudio: {
             /** @description Unique identifier for this audio response. */
             id: string;
             /**
-             * Format: int32
+             * Format: int64
              * @description The Unix timestamp (in seconds) for when this audio response will no longer be accessible on the server for use in multi-turn conversations.
              */
             expires_at: number;
@@ -1296,8 +1530,23 @@ export interface components {
         };
         /** @description Options for streaming response. Only set this when you set `stream: true`. */
         ChatCompletionStreamOptions: {
-            /** @description If set, an additional chunk will be streamed before the `data: [DONE]` message. The `usage` field on this chunk shows the token usage statistics for the entire request, and the `choices` field will always be an empty array. All other chunks will also include a `usage` field, but with a null value. */
-            include_usage: boolean;
+            /** @description If set, an additional chunk will be streamed before the `data: [DONE]`
+             *     message. The `usage` field on this chunk shows the token usage statistics
+             *     for the entire request, and the `choices` field will always be an empty
+             *     array.
+             *
+             *     All other chunks will also include a `usage` field, but with a null
+             *     value. **NOTE:** If the stream is interrupted, you may not receive the
+             *     final usage chunk which contains the total token usage for the request. */
+            include_usage?: boolean | null;
+            /** @description When true, stream obfuscation will be enabled. Stream obfuscation adds
+             *     random characters to an `obfuscation` field on streaming delta events to
+             *     normalize payload sizes as a mitigation to certain side-channel attacks.
+             *     These obfuscation fields are included by default, but add a small amount
+             *     of overhead to the data stream. You can set `include_obfuscation` to
+             *     false to optimize for bandwidth if you trust the network links between
+             *     your application and the OpenAI API. */
+            include_obfuscation?: boolean | null;
         };
         /** @description A chat completion delta generated by streamed model responses. */
         ChatCompletionStreamResponseDelta: {
@@ -1308,6 +1557,8 @@ export interface components {
             role?: null | components["schemas"]["Role"];
             /** @description The refusal message generated by the model. */
             refusal?: string | null;
+            /** @description The contents of the chunk reasoning message. */
+            reasoning_content?: string | null;
         };
         ChatCompletionTokenLogprob: {
             /** @description The token. */
@@ -1323,7 +1574,6 @@ export interface components {
             top_logprobs: components["schemas"]["TopLogprobs"][];
         };
         ChatCompletionTool: {
-            type: components["schemas"]["ChatCompletionToolType"];
             function: components["schemas"]["FunctionObject"];
         };
         /** @description Controls which (if any) tool is called by the model.
@@ -1333,11 +1583,26 @@ export interface components {
          *     Specifying a particular tool via `{"type": "function", "function": {"name": "my_function"}}` forces the model to call that tool.
          *
          *     `none` is the default when no tools are present. `auto` is the default if tools are present. */
-        ChatCompletionToolChoiceOption: "none" | "auto" | "required" | {
-            named: components["schemas"]["ChatCompletionNamedToolChoice"];
-        };
-        /** @enum {string} */
-        ChatCompletionToolType: "function";
+        ChatCompletionToolChoiceOption: (components["schemas"]["ChatCompletionAllowedToolsChoice"] & {
+            /** @enum {string} */
+            type: "allowed_tools";
+        }) | (components["schemas"]["ChatCompletionNamedToolChoice"] & {
+            /** @enum {string} */
+            type: "function";
+        }) | (components["schemas"]["ChatCompletionNamedToolChoiceCustom"] & {
+            /** @enum {string} */
+            type: "custom";
+        }) | (components["schemas"]["ToolChoiceOptions"] & {
+            /** @enum {string} */
+            type: "mode";
+        });
+        ChatCompletionTools: (components["schemas"]["ChatCompletionTool"] & {
+            /** @enum {string} */
+            type: "function";
+        }) | (components["schemas"]["CustomToolChatCompletions"] & {
+            /** @enum {string} */
+            type: "custom";
+        });
         ChatRequest: {
             model: string;
             messages: components["schemas"]["Message"][];
@@ -1390,6 +1655,12 @@ export interface components {
             prompt_tokens_details?: null | components["schemas"]["PromptTokensDetails"];
             completion_tokens_details?: null | components["schemas"]["CompletionTokensDetails"];
         };
+        ContextLimits: {
+            /** Format: int64 */
+            max_input_tokens?: number | null;
+            /** Format: int64 */
+            max_output_tokens?: number | null;
+        };
         CreateAliasRequest: {
             alias: string;
             repo: string;
@@ -1442,23 +1713,73 @@ export interface components {
             scope: components["schemas"]["TokenScope"];
         };
         CreateChatCompletionRequest: {
-            /** @description A list of messages comprising the conversation so far. Depending on the [model](https://platform.openai.com/docs/models) you use, different message types (modalities) are supported, like [text](https://platform.openai.com/docs/guides/text-generation), [images](https://platform.openai.com/docs/guides/vision), and [audio](https://platform.openai.com/docs/guides/audio). */
+            /** @description A list of messages comprising the conversation so far. Depending on the
+             *     [model](https://platform.openai.com/docs/models) you use, different message types (modalities)
+             *     are supported, like [text](https://platform.openai.com/docs/guides/text-generation),
+             *     [images](https://platform.openai.com/docs/guides/vision), and
+             *     [audio](https://platform.openai.com/docs/guides/audio). */
             messages: components["schemas"]["ChatCompletionRequestMessage"][];
-            /** @description ID of the model to use.
-             *     See the [model endpoint compatibility](https://platform.openai.com/docs/models#model-endpoint-compatibility) table for details on which models work with the Chat API. */
+            /** @description Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI
+             *     offers a wide range of models with different capabilities, performance
+             *     characteristics, and price points. Refer to the
+             *     [model guide](https://platform.openai.com/docs/models)
+             *     to browse and compare available models. */
             model: string;
-            /** @description Whether or not to store the output of this chat completion request
+            /** @description Output types that you would like the model to generate. Most models are capable of generating
+             *     text, which is the default:
              *
-             *     for use in our [model distillation](https://platform.openai.com/docs/guides/distillation) or [evals](https://platform.openai.com/docs/guides/evals) products. */
-            store?: boolean | null;
+             *     `["text"]`
+             *     The `gpt-4o-audio-preview` model can also be used to
+             *     [generate audio](https://platform.openai.com/docs/guides/audio). To request that this model
+             *     generate both text and audio responses, you can use:
+             *
+             *     `["text", "audio"]` */
+            modalities?: components["schemas"]["ResponseModalities"][] | null;
+            verbosity?: null | components["schemas"]["Verbosity"];
             reasoning_effort?: null | components["schemas"]["ReasoningEffort"];
-            /** @description Developer-defined tags and values used for filtering completions in the [dashboard](https://platform.openai.com/chat-completions). */
-            metadata?: unknown;
+            /**
+             * Format: int32
+             * @description An upper bound for the number of tokens that can be generated for a completion, including
+             *     visible output tokens and [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
+             */
+            max_completion_tokens?: number | null;
             /**
              * Format: float
-             * @description Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+             * @description Number between -2.0 and 2.0. Positive values penalize new tokens based on
+             *     their existing frequency in the text so far, decreasing the model's
+             *     likelihood to repeat the same line verbatim.
              */
             frequency_penalty?: number | null;
+            /**
+             * Format: float
+             * @description Number between -2.0 and 2.0. Positive values penalize new tokens based on
+             *     whether they appear in the text so far, increasing the model's likelihood
+             *     to talk about new topics.
+             */
+            presence_penalty?: number | null;
+            web_search_options?: null | components["schemas"]["WebSearchOptions"];
+            /**
+             * Format: int32
+             * @description An integer between 0 and 20 specifying the number of most likely tokens to
+             *     return at each token position, each with an associated log probability.
+             *     `logprobs` must be set to `true` if this parameter is used.
+             */
+            top_logprobs?: number | null;
+            response_format?: null | components["schemas"]["ResponseFormat"];
+            audio?: null | components["schemas"]["ChatCompletionAudio"];
+            /** @description Whether or not to store the output of this chat completion request for
+             *     use in our [model distillation](https://platform.openai.com/docs/guides/distillation) or
+             *     [evals](https://platform.openai.com/docs/guides/evals) products.
+             *
+             *     Supports text and image inputs. Note: image inputs over 8MB will be dropped. */
+            store?: boolean | null;
+            /** @description If set to true, the model response data will be streamed to the client
+             *     as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+             *     See the [Streaming section below](https://platform.openai.com/docs/api-reference/chat/streaming)
+             *     for more information, along with the [streaming responses](https://platform.openai.com/docs/guides/streaming-responses)
+             *     guide for more information on how to handle the streaming events. */
+            stream?: boolean | null;
+            stop?: null | components["schemas"]["StopConfiguration"];
             /** @description Modify the likelihood of specified tokens appearing in the completion.
              *
              *     Accepts a json object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100.
@@ -1466,59 +1787,42 @@ export interface components {
              *     The exact effect will vary per model, but values between -1 and 1 should decrease or increase likelihood of selection;
              *     values like -100 or 100 should result in a ban or exclusive selection of the relevant token. */
             logit_bias?: {
-                [key: string]: unknown;
+                [key: string]: number;
             } | null;
-            /** @description Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the `content` of `message`. */
+            /** @description Whether to return log probabilities of the output tokens or not. If true,
+             *     returns the log probabilities of each output token returned in the `content` of `message`. */
             logprobs?: boolean | null;
-            /**
-             * Format: int32
-             * @description An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. `logprobs` must be set to `true` if this parameter is used.
-             */
-            top_logprobs?: number | null;
             /**
              * Format: int32
              * @deprecated
-             * @description The maximum number of [tokens](https://platform.openai.com/tokenizer) that can be generated in the chat completion.
-             *
-             *     This value can be used to control [costs](https://openai.com/api/pricing/) for text generated via API.
+             * @description The maximum number of [tokens](https://platform.openai.com/tokenizer) that can be generated in
+             *     the chat completion. This value can be used to control [costs](https://openai.com/api/pricing/) for text generated via API.
              *     This value is now deprecated in favor of `max_completion_tokens`, and is
-             *     not compatible with [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+             *     not compatible with [o-series models](https://platform.openai.com/docs/guides/reasoning).
              */
             max_tokens?: number | null;
             /**
              * Format: int32
-             * @description An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
-             */
-            max_completion_tokens?: number | null;
-            /**
-             * Format: int32
-             * @description How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to minimize costs.
+             * @description How many chat completion choices to generate for each input message. Note that you will be
+             *     charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to
+             *     minimize costs.
              */
             n?: number | null;
-            modalities?: components["schemas"]["ChatCompletionModalities"][] | null;
             prediction?: null | components["schemas"]["PredictionContent"];
-            audio?: null | components["schemas"]["ChatCompletionAudio"];
-            /**
-             * Format: float
-             * @description Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
-             */
-            presence_penalty?: number | null;
-            response_format?: null | components["schemas"]["ResponseFormat"];
             /**
              * Format: int64
-             * @description  This feature is in Beta.
-             *     If specified, our system will make a best effort to sample deterministically, such that repeated requests
-             *     with the same `seed` and parameters should return the same result.
-             *     Determinism is not guaranteed, and you should refer to the `system_fingerprint` response parameter to monitor changes in the backend.
+             * @deprecated
+             * @description This feature is in Beta.
+             *
+             *     If specified, our system will make a best effort to sample deterministically, such that
+             *     repeated requests with the same `seed` and parameters should return the same result.
+             *
+             *     Determinism is not guaranteed, and you should refer to the `system_fingerprint` response
+             *     parameter to monitor changes in the backend.
              */
             seed?: number | null;
-            service_tier?: null | components["schemas"]["ServiceTier"];
-            stop?: null | components["schemas"]["Stop"];
-            /** @description If set, partial message deltas will be sent, like in ChatGPT.
-             *     Tokens will be sent as data-only [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
-             *     as they become available, with the stream terminated by a `data: [DONE]` message. [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions). */
-            stream?: boolean | null;
             stream_options?: null | components["schemas"]["ChatCompletionStreamOptions"];
+            service_tier?: null | components["schemas"]["ServiceTier"];
             /**
              * Format: float
              * @description What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random,
@@ -1536,15 +1840,33 @@ export interface components {
              *      We generally recommend altering this or `temperature` but not both.
              */
             top_p?: number | null;
-            /** @description A list of tools the model may call. Currently, only functions are supported as a tool.
-             *     Use this to provide a list of functions the model may generate JSON inputs for. A max of 128 functions are supported. */
-            tools?: components["schemas"]["ChatCompletionTool"][] | null;
+            /** @description A list of tools the model may call. You can provide either
+             *     [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools) or
+             *     [function tools](https://platform.openai.com/docs/guides/function-calling). */
+            tools?: components["schemas"]["ChatCompletionTools"][] | null;
             tool_choice?: null | components["schemas"]["ChatCompletionToolChoiceOption"];
-            /** @description Whether to enable [parallel function calling](https://platform.openai.com/docs/guides/function-calling/parallel-function-calling) during tool use. */
+            /** @description Whether to enable [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
+             *     during tool use. */
             parallel_tool_calls?: boolean | null;
-            /** @description A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids). */
+            /**
+             * @deprecated
+             * @description This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use `prompt_cache_key`
+             *     instead to maintain caching optimizations.
+             *     A stable identifier for your end-users.
+             *     Used to boost cache hit rates by better bucketing similar requests and  to help OpenAI detect and
+             *     prevent abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+             */
             user?: string | null;
-            web_search_options?: null | components["schemas"]["WebSearchOptions"];
+            /** @description A stable identifier used to help detect users of your application that may be violating OpenAI's
+             *     usage policies.
+             *
+             *     The IDs should be a string that uniquely identifies each user. We recommend hashing their username
+             *     or email address, in order to avoid sending us any identifying information. [Learn
+             *     more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers). */
+            safety_identifier?: string | null;
+            /** @description Used by OpenAI to cache responses for similar requests to optimize your cache hit rates. Replaces
+             *     the `user` field. [Learn more](https://platform.openai.com/docs/guides/prompt-caching). */
+            prompt_cache_key?: string | null;
             function_call?: null | components["schemas"]["ChatCompletionFunctionCall"];
             /**
              * @deprecated
@@ -1553,6 +1875,11 @@ export interface components {
              *     A list of functions the model may generate JSON inputs for.
              */
             functions?: components["schemas"]["ChatCompletionFunctions"][] | null;
+            metadata?: null | components["schemas"]["Metadata"];
+            /** @description llama.cpp compatible extra params in request */
+            chat_template_kwargs?: {
+                [key: string]: unknown;
+            } | null;
         };
         /** @description Represents a chat completion response returned by model, based on the provided input. */
         CreateChatCompletionResponse: {
@@ -1567,16 +1894,19 @@ export interface components {
             created: number;
             /** @description The model used for the chat completion. */
             model: string;
-            service_tier?: null | components["schemas"]["ServiceTierResponse"];
-            /** @description This fingerprint represents the backend configuration that the model runs with.
+            service_tier?: null | components["schemas"]["ServiceTier"];
+            /**
+             * @deprecated
+             * @description This fingerprint represents the backend configuration that the model runs with.
              *
-             *     Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism. */
+             *     Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
+             */
             system_fingerprint?: string | null;
             /** @description The object type, which is always `chat.completion`. */
             object: string;
             usage?: null | components["schemas"]["CompletionUsage"];
         };
-        /** @description Represents a streamed chunk of a chat completion response returned by model, based on the provided input. */
+        /** @description Represents a streamed chunk of a chat completion response returned by the model, based on the provided input. [Learn more](https://platform.openai.com/docs/guides/streaming-responses). */
         CreateChatCompletionStreamResponse: {
             /** @description A unique identifier for the chat completion. Each chunk has the same ID. */
             id: string;
@@ -1589,26 +1919,33 @@ export interface components {
             created: number;
             /** @description The model to generate the completion. */
             model: string;
-            service_tier?: null | components["schemas"]["ServiceTierResponse"];
-            /** @description This fingerprint represents the backend configuration that the model runs with.
-             *     Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism. */
+            service_tier?: null | components["schemas"]["ServiceTier"];
+            /**
+             * @deprecated
+             * @description This fingerprint represents the backend configuration that the model runs with.
+             *     Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
+             */
             system_fingerprint?: string | null;
             /** @description The object type, which is always `chat.completion.chunk`. */
             object: string;
             usage?: null | components["schemas"]["CompletionUsage"];
         };
         CreateEmbeddingRequest: {
-            /** @description ID of the model to use. You can use the
-             *     [List models](https://platform.openai.com/docs/api-reference/models/list)
-             *     API to see all of your available models, or see our
-             *     [Model overview](https://platform.openai.com/docs/models/overview)
+            /** @description ID of the model to use. You can use the [List models](https://platform.openai.com/docs/api-reference/models/list)
+             *     API to see all of your available models, or see our [Model overview](https://platform.openai.com/docs/models)
              *     for descriptions of them. */
             model: string;
-            /** @description Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single request, pass an array of strings or array of token arrays. The input must not exceed the max input tokens for the model (8192 tokens for `text-embedding-ada-002`), cannot be an empty string, and any array must be 2048 dimensions or less. [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken) for counting tokens. */
+            /** @description Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single
+             *     request, pass an array of strings or array of token arrays. The input must not exceed the max
+             *     input tokens for the model (8192 tokens for all embedding models), cannot be an empty string, and
+             *     any array must be 2048 dimensions or less. [Example Python
+             *     code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken) for counting tokens.
+             *     In addition to the per-input token limit, all embedding  models enforce a maximum of 300,000
+             *     tokens summed across all inputs in a  single request. */
             input: components["schemas"]["EmbeddingInput"];
             encoding_format?: null | components["schemas"]["EncodingFormat"];
-            /** @description A unique identifier representing your end-user, which will help OpenAI
-             *      to monitor and detect abuse. [Learn more](https://platform.openai.com/docs/usage-policies/end-user-ids). */
+            /** @description A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
+             *     [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids). */
             user?: string | null;
             /**
              * Format: int32
@@ -1625,6 +1962,54 @@ export interface components {
             /** @description The usage information for the request. */
             usage: components["schemas"]["EmbeddingUsage"];
         };
+        /** @description Request to create a toolset */
+        CreateToolsetRequest: {
+            /** @description Toolset type identifier (e.g., "builtin-exa-web-search") */
+            toolset_type: string;
+            /** @description User-defined name for this toolset (2-24 chars, alphanumeric + spaces/dash/underscore) */
+            name: string;
+            /** @description Optional description for this toolset */
+            description?: string | null;
+            /** @description Whether this toolset is enabled */
+            enabled?: boolean;
+            /** @description API key for the toolset */
+            api_key: string;
+        };
+        CustomGrammarFormatParam: {
+            /** @description The grammar definition. */
+            definition: string;
+            /** @description The syntax of the grammar definition. One of `lark` or `regex`. */
+            syntax: components["schemas"]["GrammarSyntax"];
+        };
+        CustomName: {
+            /** @description The name of the custom tool to call. */
+            name: string;
+        };
+        CustomTool: {
+            /** @description The name of the custom tool to call. */
+            name: string;
+            /** @description The input for the custom tool call generated by the model. */
+            input: string;
+        };
+        CustomToolChatCompletions: {
+            custom: components["schemas"]["CustomToolProperties"];
+        };
+        CustomToolProperties: {
+            /** @description The name of the custom tool, used to identify it in tool calls. */
+            name: string;
+            /** @description Optional description of the custom tool, used to provide more context. */
+            description?: string | null;
+            /** @description The input format for the custom tool. Default is unconstrained text. */
+            format: components["schemas"]["CustomToolPropertiesFormat"];
+        };
+        CustomToolPropertiesFormat: {
+            /** @enum {string} */
+            type: "text";
+        } | {
+            grammar: components["schemas"]["CustomGrammarFormatParam"];
+            /** @enum {string} */
+            type: "grammar";
+        };
         DownloadRequest: {
             id: string;
             repo: string;
@@ -1710,6 +2095,13 @@ export interface components {
              */
             param?: string | null;
         };
+        /** @description Request to execute a toolset */
+        ExecuteToolsetRequest: {
+            /** @description Tool call ID from LLM */
+            tool_call_id: string;
+            /** @description Function parameters as JSON */
+            params: unknown;
+        };
         /**
          * @description Request to fetch available models from provider
          * @example {
@@ -1739,6 +2131,16 @@ export interface components {
         FetchModelsResponse: {
             models: string[];
         };
+        FileObject: {
+            /** @description The base64 encoded file data, used when passing the file to the model
+             *     as a string. */
+            file_data?: string | null;
+            /** @description The ID of an uploaded file to use as input. */
+            file_id?: string | null;
+            /** @description The name of the file, used when passing the file to the model as a
+             *     string. */
+            filename?: string | null;
+        };
         /** @enum {string} */
         FinishReason: "stop" | "length" | "tool_calls" | "content_filter" | "function_call";
         /** @description The name and arguments of a function that should be called, as generated by the model. */
@@ -1757,6 +2159,15 @@ export interface components {
              *     code before calling your function. */
             arguments?: string | null;
         };
+        /** @description Function definition within a tool */
+        FunctionDefinition: {
+            /** @description Simple tool name (e.g., "search", "findSimilar"). Frontend composes fully qualified name. */
+            name: string;
+            /** @description Human-readable description for LLM */
+            description: string;
+            /** @description JSON Schema for function parameters */
+            parameters: unknown;
+        };
         FunctionName: {
             /** @description The name of the function to call. */
             name: string;
@@ -1774,6 +2185,10 @@ export interface components {
             strict?: boolean | null;
         };
         /** @enum {string} */
+        FunctionType: "function";
+        /** @enum {string} */
+        GrammarSyntax: "lark" | "regex";
+        /** @enum {string} */
         ImageDetail: "auto" | "low" | "high";
         ImageUrl: {
             /** @description Either a URL of the image or the base64 encoded image data. */
@@ -1792,6 +2207,14 @@ export interface components {
             object: string;
             data: components["schemas"]["Model"][];
         };
+        /** @description List of toolset types */
+        ListToolsetTypesResponse: {
+            types: components["schemas"]["ToolsetTypeResponse"][];
+        };
+        /** @description List of toolsets */
+        ListToolsetsResponse: {
+            toolsets: components["schemas"]["ToolsetResponse"][];
+        };
         /** @description List users query parameters */
         ListUsersParams: {
             /**
@@ -1814,12 +2237,20 @@ export interface components {
             model_params: {
                 [key: string]: unknown;
             };
+            metadata?: null | components["schemas"]["ModelMetadata"];
         };
         Message: {
             role: string;
             content: string;
             images?: string[] | null;
         };
+        /** @description Set of 16 key-value pairs that can be attached to an object.
+         *     This can be useful for storing additional information about the
+         *     object in a structured format, and querying for objects via API
+         *     or the dashboard. Keys are strings with a maximum length of 64
+         *     characters. Values are strings with a maximum length of 512
+         *     characters. */
+        Metadata: unknown;
         /** @description Describes an OpenAI model offering that can be used with the API. */
         Model: {
             /** @description The model identifier, which can be referenced in the API endpoints. */
@@ -1848,6 +2279,20 @@ export interface components {
             repo: string;
             filename: string;
             snapshot: string;
+            metadata?: null | components["schemas"]["ModelMetadata"];
+        };
+        ModelArchitecture: {
+            family?: string | null;
+            /** Format: int64 */
+            parameter_count?: number | null;
+            quantization?: string | null;
+            format: string;
+        };
+        ModelCapabilities: {
+            vision?: boolean | null;
+            audio?: boolean | null;
+            thinking?: boolean | null;
+            tools: components["schemas"]["ToolCapabilities"];
         };
         ModelDetails: {
             parent_model?: string | null;
@@ -1857,6 +2302,13 @@ export interface components {
             parameter_size: string;
             quantization_level: string;
         };
+        /** @description Model metadata for API responses */
+        ModelMetadata: {
+            capabilities: components["schemas"]["ModelCapabilities"];
+            context: components["schemas"]["ContextLimits"];
+            architecture: components["schemas"]["ModelArchitecture"];
+            chat_template?: string | null;
+        };
         ModelsResponse: {
             models: components["schemas"]["OllamaModel"][];
         };
@@ -2094,8 +2546,13 @@ export interface components {
              */
             cached_tokens?: number | null;
         };
+        /** @description Response for queue status operations */
+        QueueStatusResponse: {
+            /** @description Queue status ("idle" or "processing") */
+            status: string;
+        };
         /** @enum {string} */
-        ReasoningEffort: "minimal" | "low" | "medium" | "high";
+        ReasoningEffort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
         /** @example {
          *       "location": "https://oauth.example.com/auth?client_id=test&redirect_uri=..."
          *     } */
@@ -2106,6 +2563,41 @@ export interface components {
              */
             location: string;
         };
+        /** @description Refresh request - discriminated union by source field */
+        RefreshRequest: {
+            /** @enum {string} */
+            source: "all";
+        } | {
+            /**
+             * @description Repository in format "user/repo"
+             * @example bartowski/Qwen2.5-3B-Instruct-GGUF
+             */
+            repo: string;
+            /**
+             * @description Filename of the GGUF model
+             * @example Qwen2.5-3B-Instruct-Q4_K_M.gguf
+             */
+            filename: string;
+            /**
+             * @description Snapshot/commit identifier
+             * @example 8ba1c3c3ee94ba4b86ff92a749ae687dc41fce3f
+             */
+            snapshot: string;
+            /** @enum {string} */
+            source: "model";
+        };
+        /** @description Response for metadata refresh operations */
+        RefreshResponse: {
+            /** @description Number of models queued ("all" for bulk refresh, "1" for single) */
+            num_queued: string;
+            /** @description Model alias (only for single model refresh) */
+            alias?: string | null;
+        };
+        /**
+         * @description Source type discriminator for refresh requests
+         * @enum {string}
+         */
+        RefreshSource: "all" | "model";
         /** @enum {string} */
         ResourceRole: "resource_user" | "resource_power_user" | "resource_manager" | "resource_admin";
         ResponseFormat: {
@@ -2124,17 +2616,30 @@ export interface components {
             description?: string | null;
             /** @description The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64. */
             name: string;
-            /** @description The schema for the response format, described as a JSON Schema object. */
+            /** @description The schema for the response format, described as a JSON Schema object.
+             *     Learn how to build JSON schemas [here](https://json-schema.org/). */
             schema?: unknown;
-            /** @description Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the `schema` field. Only a subset of JSON Schema is supported when `strict` is `true`. To learn more, read the [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs). */
+            /** @description Whether to enable strict schema adherence when generating the output.
+             *     If set to true, the model will always follow the exact schema defined
+             *     in the `schema` field. Only a subset of JSON Schema is supported when
+             *     `strict` is `true`. To learn more, read the [Structured Outputs
+             *     guide](https://platform.openai.com/docs/guides/structured-outputs). */
             strict?: boolean | null;
         };
+        /**
+         * @description Output types that you would like the model to generate for this request.
+         *
+         *     Most models are capable of generating text, which is the default: `["text"]`
+         *
+         *     The `gpt-4o-audio-preview` model can also be used to [generate
+         *     audio](https://platform.openai.com/docs/guides/audio). To request that this model generate both text and audio responses, you can use: `["text", "audio"]`
+         * @enum {string}
+         */
+        ResponseModalities: "text" | "audio";
         /** @enum {string} */
         Role: "system" | "user" | "assistant" | "tool" | "function";
         /** @enum {string} */
         ServiceTier: "auto" | "default" | "flex" | "scale" | "priority";
-        /** @enum {string} */
-        ServiceTierResponse: "scale" | "default" | "flex" | "priority";
         SettingInfo: {
             key: string;
             current_value: unknown;
@@ -2206,7 +2711,7 @@ export interface components {
             parameters: string;
             template: string;
         };
-        Stop: string | string[];
+        StopConfiguration: string | string[];
         /** @description Credentials for test/fetch operations */
         TestCreds: {
             /** @description Look up credentials from stored API model */
@@ -2262,6 +2767,113 @@ export interface components {
         TokenScope: "scope_token_user" | "scope_token_power_user" | "scope_token_manager" | "scope_token_admin";
         /** @enum {string} */
         TokenStatus: "active" | "inactive";
+        ToolCapabilities: {
+            function_calling?: boolean | null;
+            structured_output?: boolean | null;
+        };
+        /** @enum {string} */
+        ToolChoiceAllowedMode: "auto" | "required";
+        /** @enum {string} */
+        ToolChoiceOptions: "none" | "auto" | "required";
+        /** @description Tool definition in OpenAI format for LLM function calling.
+         *     Tool name follows Claude MCP convention: toolset__{toolset_id}__{tool_name} */
+        ToolDefinition: {
+            /** @description Type of tool (always "function" for now) */
+            type: string;
+            /** @description Function definition details */
+            function: components["schemas"]["FunctionDefinition"];
+        };
+        /** @description User-owned toolset instance with UUID identification */
+        Toolset: {
+            /** @description Unique instance identifier (UUID) */
+            id: string;
+            /** @description User-defined name for this instance */
+            name: string;
+            /** @description Toolset type identifier (e.g., "builtin-exa-web-search") */
+            toolset_type: string;
+            /** @description Optional description for this instance */
+            description?: string | null;
+            /** @description Whether this instance is enabled */
+            enabled: boolean;
+            /** @description Whether this instance has an API key configured */
+            has_api_key: boolean;
+            /**
+             * Format: date-time
+             * @description When this instance was created
+             * @example 2024-11-10T04:52:06.786Z
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description When this instance was last updated
+             * @example 2024-11-10T04:52:06.786Z
+             */
+            updated_at: string;
+        };
+        /** @description Response from toolset tool execution (to send back to LLM) */
+        ToolsetExecutionResponse: {
+            /** @description Tool call ID this response is for */
+            tool_call_id: string;
+            /** @description Successful result (JSON), if any */
+            result?: unknown;
+            /** @description Error message, if execution failed */
+            error?: string | null;
+        };
+        /** @description Toolset response */
+        ToolsetResponse: {
+            /** @description Unique instance identifier (UUID) */
+            id: string;
+            /** @description User-defined name for this toolset */
+            name: string;
+            /** @description Toolset type identifier (e.g., "builtin-exa-web-search") */
+            toolset_type: string;
+            /** @description Optional description for this toolset */
+            description?: string | null;
+            /** @description Whether this toolset is enabled */
+            enabled: boolean;
+            /** @description Whether this toolset has an API key configured */
+            has_api_key: boolean;
+            /** @description Whether the toolset type is enabled at app level */
+            app_enabled: boolean;
+            /** @description Tools provided by this toolset type */
+            tools: components["schemas"]["ToolDefinition"][];
+            /**
+             * Format: date-time
+             * @description When this toolset was created
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description When this toolset was last updated
+             */
+            updated_at: string;
+        };
+        /** @description Toolset type response (for admin listing) */
+        ToolsetTypeResponse: {
+            /** @description Unique toolset type identifier (e.g., "builtin-exa-web-search") */
+            toolset_id: string;
+            /** @description Human-readable name (e.g., "Exa Web Search") */
+            name: string;
+            /** @description Description of the toolset */
+            description: string;
+            /** @description Whether the toolset is enabled at app level (admin-controlled) */
+            app_enabled: boolean;
+            /** @description Tools provided by this toolset */
+            tools: components["schemas"]["ToolDefinition"][];
+        };
+        /** @description Toolset with app-level configuration status (API response model) */
+        ToolsetWithTools: {
+            /** @description Unique toolset identifier (e.g., "builtin-exa-web-search") */
+            toolset_id: string;
+            /** @description Human-readable name (e.g., "Exa Web Search") */
+            name: string;
+            /** @description Description of the toolset */
+            description: string;
+            /** @description Whether the toolset is enabled at app level (admin-controlled) */
+            app_enabled: boolean;
+            /** @description Tools provided by this toolset */
+            tools: components["schemas"]["ToolDefinition"][];
+        };
         TopLogprobs: {
             /** @description The token. */
             token: string;
@@ -2335,6 +2947,33 @@ export interface components {
             /** @description New value for the setting (type depends on setting metadata) */
             value: unknown;
         };
+        /** @description Request to update a toolset (full PUT - all fields required except api_key) */
+        UpdateToolsetRequest: {
+            /** @description User-defined name for this toolset */
+            name: string;
+            /** @description Optional description for this toolset */
+            description?: string | null;
+            /** @description Whether this toolset is enabled */
+            enabled: boolean;
+            /** @description API key update action (Keep or Set) */
+            api_key?: components["schemas"]["ApiKeyUpdateDto"];
+        };
+        UrlCitation: {
+            /**
+             * Format: int32
+             * @description The index of the last character of the URL citation in the message.
+             */
+            end_index: number;
+            /**
+             * Format: int32
+             * @description The index of the first character of the URL citation in the message.
+             */
+            start_index: number;
+            /** @description The title of the web resource. */
+            title: string;
+            /** @description The URL of the web resource. */
+            url: string;
+        };
         UserAccessRequest: {
             /**
              * Format: int64
@@ -2404,6 +3043,7 @@ export interface components {
             };
             request_params: components["schemas"]["OAIRequestParams"];
             context_params: string[];
+            metadata?: null | components["schemas"]["ModelMetadata"];
         };
         UserInfo: {
             /** @example 550e8400-e29b-41d4-a716-446655440000 */
@@ -2466,6 +3106,11 @@ export interface components {
         });
         /** @enum {string} */
         UserScope: "scope_user_user" | "scope_user_power_user" | "scope_user_manager" | "scope_user_admin";
+        /**
+         * @description Constrains the verbosity of the model's response. Lower values will result in more concise responses, while higher values will result in more verbose responses. Currently supported values are `low`, `medium`, and `high`.
+         * @enum {string}
+         */
+        Verbosity: "low" | "medium" | "high";
         /**
          * @description The amount of context window space to use for the search.
          * @enum {string}
@@ -3689,7 +4334,8 @@ export interface operations {
         requestBody: {
             content: {
                 /** @example {
-                 *       "app_client_id": "my_app_client_123"
+                 *       "app_client_id": "my_app_client_123",
+                 *       "version": "v1.0.0"
                  *     } */
                 "application/json": components["schemas"]["AppAccessRequest"];
             };
@@ -3702,7 +4348,14 @@ export interface operations {
                 };
                 content: {
                     /** @example {
-                     *       "scope": "scope_resource_bodhi-server"
+                     *       "app_client_config_version": "v1.0.0",
+                     *       "scope": "scope_resource_bodhi-server",
+                     *       "toolsets": [
+                     *         {
+                     *           "id": "builtin-exa-web-search",
+                     *           "scope": "scope_toolset-builtin-exa-web-search"
+                     *         }
+                     *       ]
                      *     } */
                     "application/json": components["schemas"]["AppAccessResponse"];
                 };
@@ -4615,6 +5268,86 @@ export interface operations {
             };
         };
     };
+    refreshModelMetadata: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Refresh request - either bulk (source='all') or single model (source='model' with identifiers) */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RefreshRequest"];
+            };
+        };
+        responses: {
+            /** @description Metadata refreshed successfully (sync mode) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ModelAliasResponse"];
+                };
+            };
+            /** @description Metadata refresh queued in background (bulk mode) */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /** @example {
+                     *       "num_queued": "all"
+                     *     } */
+                    "application/json": components["schemas"]["RefreshResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Model alias not found for specified repo/filename/snapshot */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
     getAlias: {
         parameters: {
             query?: never;
@@ -4777,6 +5510,65 @@ export interface operations {
             };
         };
     };
+    getQueueStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Queue status retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /** @example {
+                     *       "status": "idle"
+                     *     } */
+                    "application/json": components["schemas"]["QueueStatusResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
     listSettings: {
         parameters: {
             query?: never;
@@ -5367,6 +6159,596 @@ export interface operations {
             };
         };
     };
+    listToolsetTypes: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of all toolset types */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListToolsetTypesResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    enableToolsetType: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Toolset type identifier */
+                type_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Toolset type enabled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AppToolsetConfigResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Toolset type not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    disableToolsetType: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Toolset type identifier */
+                type_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Toolset type disabled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AppToolsetConfigResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Toolset type not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    listToolsets: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of user's toolsets */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListToolsetsResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    createToolset: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateToolsetRequest"];
+            };
+        };
+        responses: {
+            /** @description Toolset created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolsetResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Name already exists */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    getToolset: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Toolset instance UUID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Toolset */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolsetResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Toolset not found or not owned */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    updateToolset: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Toolset instance UUID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateToolsetRequest"];
+            };
+        };
+        responses: {
+            /** @description Toolset updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolsetResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Toolset not found or not owned */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Name already exists */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    deleteToolset: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Toolset instance UUID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Toolset deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Toolset not found or not owned */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
+    executeToolset: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Toolset instance UUID */
+                id: string;
+                /** @description Tool method name */
+                method: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ExecuteToolsetRequest"];
+            };
+        };
+        responses: {
+            /** @description Tool execution result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolsetExecutionResponse"];
+                };
+            };
+            /** @description Invalid request parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Not authenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description Toolset or method not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+        };
+    };
     getCurrentUser: {
         parameters: {
             query?: never;