@bodhiapp/ts-client 0.1.15 → 0.1.17

package/dist/types/types.gen.d.ts

@@ -1,3 +1,81 @@
+export type AccessRequestActionResponse = {
+    /**
+     * Updated status after action
+     */
+    status: AppAccessRequestStatus;
+    /**
+     * Flow type of the access request
+     */
+    flow_type: FlowType;
+    /**
+     * Redirect URL (present for redirect flow)
+     */
+    redirect_url?: string | null;
+};
+export type AccessRequestReviewResponse = {
+    /**
+     * Access request ID
+     */
+    id: string;
+    /**
+     * App client ID
+     */
+    app_client_id: string;
+    /**
+     * App name from KC (if available)
+     */
+    app_name?: string | null;
+    /**
+     * App description from KC (if available)
+     */
+    app_description?: string | null;
+    /**
+     * Flow type: "redirect" or "popup"
+     */
+    flow_type: FlowType;
+    /**
+     * Current status
+     */
+    status: AppAccessRequestStatus;
+    /**
+     * Role requested by the app
+     */
+    requested_role: string;
+    /**
+     * Resources requested
+     */
+    requested: RequestedResources;
+    /**
+     * Tool type information with user instances
+     */
+    tools_info: Array<ToolTypeReviewInfo>;
+    /**
+     * MCP server information with user instances
+     */
+    mcps_info?: Array<McpServerReviewInfo>;
+};
+export type AccessRequestStatusResponse = {
+    /**
+     * Access request ID
+     */
+    id: string;
+    /**
+     * Current status: "draft", "approved", "denied", "failed"
+     */
+    status: AppAccessRequestStatus;
+    /**
+     * Role requested by the app
+     */
+    requested_role: string;
+    /**
+     * Role approved (present when approved)
+     */
+    approved_role?: string | null;
+    /**
+     * Access request scope (present when user-approved with tools)
+     */
+    access_request_scope?: string | null;
+};
 /**
  * Flat enum representing all types of model aliases
  * Each variant is identified by the source field
@@ -18,10 +96,10 @@ export type ApiAlias = {
     id: string;
     api_format: ApiFormat;
     base_url: string;
-    models: Array<string>;
+    models: JsonVec;
     prefix?: string | null;
     forward_all_with_prefix: boolean;
-    models_cache: Array<string>;
+    models_cache: JsonVec;
     cache_fetched_at: string;
     created_at: string;
     updated_at: string;
@@ -112,43 +190,7 @@ export type ApiTokenResponse = {
      */
     token: string;
 };
-export type AppAccessRequest = {
-    app_client_id: string;
-    /**
-     * Optional version for cache lookup - if matches cached config, skips auth server call
-     */
-    version?: string | null;
-    /**
-     * Optional toolset scope IDs to register with resource-client for token exchange
-     */
-    toolset_scope_ids?: Array<string> | null;
-};
-export type AppAccessResponse = {
-    scope: string;
-    /**
-     * List of toolsets the app-client is configured to access
-     */
-    toolsets?: Array<AppClientToolset>;
-    /**
-     * Version of app-client's toolset configuration on auth server
-     */
-    app_client_config_version?: string | null;
-};
-/**
- * Toolset configuration from app-client registration
- */
-export type AppClientToolset = {
-    id: string;
-    scope: string;
-    /**
-     * client scope UUID for cache validation
-     */
-    scope_id?: string;
-    /**
-     * True if scope has been added to resource-client as optional scope
-     */
-    added_to_resource_client?: boolean | null;
-};
+export type AppAccessRequestStatus = 'draft' | 'approved' | 'denied' | 'failed' | 'expired';
 /**
  * Application information and status
  */
@@ -167,36 +209,51 @@ export type AppInfo = {
     status: AppStatus;
 };
 export type AppRole = ResourceRole | TokenScope | UserScope;
-export type AppStatus = 'setup' | 'ready' | 'resource-admin';
+export type AppStatus = 'setup' | 'ready' | 'resource_admin';
 /**
- * App-level configuration for a toolset (admin-controlled)
+ * Application-level toolset configuration
  */
 export type AppToolsetConfig = {
     /**
-     * Toolset identifier (e.g., "builtin-exa-web-search")
+     * Toolset type identifier (e.g., "builtin-exa-search")
+     */
+    toolset_type: string;
+    /**
+     * Human-readable name (e.g., "Exa Web Search")
+     */
+    name: string;
+    /**
+     * Description of the toolset
      */
-    toolset_id: string;
+    description: string;
     /**
-     * Whether the toolset is enabled for this app instance
+     * Whether this toolset type is enabled at app level
      */
     enabled: boolean;
     /**
-     * User ID of the admin who last updated this configuration
+     * User who last updated this config
      */
     updated_by: string;
     /**
-     * When this configuration was created
+     * When this config was created
      */
     created_at: string;
     /**
-     * When this configuration was last updated
+     * When this config was last updated
      */
     updated_at: string;
 };
-/**
- * The app-level toolset configuration
- */
-export type AppToolsetConfigResponse = AppToolsetConfig;
+export type ApprovalStatus = 'approved' | 'denied';
+export type ApproveAccessRequestBody = {
+    /**
+     * Role to grant for the approved request (scope_user_user or scope_user_power_user)
+     */
+    approved_role: UserScope;
+    /**
+     * Approved resources with selections
+     */
+    approved: ApprovedResources;
+};
 /**
  * Request body for approving access with role assignment
  */
@@ -206,6 +263,10 @@ export type ApproveUserAccessRequest = {
      */
     role: ResourceRole;
 };
+export type ApprovedResources = {
+    toolsets?: Array<ToolsetApproval>;
+    mcps?: Array<McpApproval>;
+};
 export type AuthCallbackRequest = {
     /**
      * OAuth authorization code from successful authentication (required for success flow)
@@ -692,6 +753,42 @@ export type ContextLimits = {
     max_input_tokens?: number | null;
     max_output_tokens?: number | null;
 };
+export type CopyAliasRequest = {
+    alias: string;
+};
+export type CreateAccessRequestBody = {
+    /**
+     * App client ID from Keycloak
+     */
+    app_client_id: string;
+    /**
+     * Flow type: "redirect" or "popup"
+     */
+    flow_type: FlowType;
+    /**
+     * Redirect URL for result notification (required for redirect flow)
+     */
+    redirect_url?: string | null;
+    /**
+     * Role requested for the external app (scope_user_user or scope_user_power_user)
+     */
+    requested_role: UserScope;
+    requested?: null | RequestedResources;
+};
+export type CreateAccessRequestResponse = {
+    /**
+     * Access request ID
+     */
+    id: string;
+    /**
+     * Status (always "draft")
+     */
+    status: AppAccessRequestStatus;
+    /**
+     * Review URL for user to approve/deny
+     */
+    review_url: string;
+};
 export type CreateAliasRequest = {
     alias: string;
     repo: string;
@@ -742,6 +839,12 @@ export type CreateApiTokenRequest = {
      */
     scope: TokenScope;
 };
+/**
+ * Wrapper for creating auth configs with server_id in body instead of path
+ */
+export type CreateAuthConfigBody = CreateMcpAuthConfigRequest & {
+    mcp_server_id: string;
+};
 export type CreateChatCompletionRequest = {
     /**
      * A list of messages comprising the conversation so far. Depending on the
@@ -1034,18 +1137,62 @@ export type CreateEmbeddingResponse = {
      */
     usage: EmbeddingUsage;
 };
+/**
+ * Discriminated union for creating any type of MCP auth config.
+ * The JSON `"type"` field determines the variant: `"header"` or `"oauth"`.
+ */
+export type CreateMcpAuthConfigRequest = {
+    name: string;
+    header_key: string;
+    header_value: string;
+    type: 'header';
+} | {
+    name: string;
+    client_id: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    client_secret?: string | null;
+    scopes?: string | null;
+    /**
+     * `"pre_registered"` (default) or `"dynamic_registration"`
+     */
+    registration_type?: RegistrationType;
+    registration_access_token?: string | null;
+    registration_endpoint?: string | null;
+    token_endpoint_auth_method?: string | null;
+    client_id_issued_at?: number | null;
+    type: 'oauth';
+};
+export type CreateMcpRequest = {
+    name: string;
+    slug: string;
+    mcp_server_id: string;
+    description?: string | null;
+    enabled: boolean;
+    tools_cache?: Array<McpTool> | null;
+    tools_filter?: Array<string> | null;
+    auth_type?: McpAuthType;
+    auth_uuid?: string | null;
+};
+export type CreateMcpServerRequest = {
+    url: string;
+    name: string;
+    description?: string | null;
+    enabled: boolean;
+    auth_config?: null | CreateMcpAuthConfigRequest;
+};
 /**
  * Request to create a toolset
  */
 export type CreateToolsetRequest = {
     /**
-     * Toolset type identifier (e.g., "builtin-exa-web-search")
+     * Toolset type identifier (e.g., "builtin-exa-search")
      */
     toolset_type: string;
     /**
-     * User-defined name for this toolset (2-24 chars, alphanumeric + spaces/dash/underscore)
+     * User-defined slug for this toolset (1-24 chars, alphanumeric + hyphens)
      */
-    name: string;
+    slug: string;
     /**
      * Optional description for this toolset
      */
@@ -1122,6 +1269,18 @@ export type DownloadRequest = {
 };
 export type DownloadStatus = 'pending' | 'completed' | 'error';
 export type Duration = string;
+export type DynamicRegisterRequest = {
+    registration_endpoint: string;
+    redirect_uri: string;
+    scopes?: string | null;
+};
+export type DynamicRegisterResponse = {
+    client_id: string;
+    client_secret?: string | null;
+    client_id_issued_at?: number | null;
+    token_endpoint_auth_method?: string | null;
+    registration_access_token?: string | null;
+};
 /**
  * Represents an embedding vector returned by embedding endpoint.
  */
@@ -1166,9 +1325,11 @@ export type ErrorBody = {
      */
     code?: string | null;
     /**
-     * Parameter name that caused the error (for validation errors)
+     * Additional error parameters as key-value pairs (for validation errors)
      */
-    param?: string | null;
+    param?: {
+        [key: string]: string;
+    } | null;
 };
 /**
  * Request to execute a toolset
@@ -1179,6 +1340,11 @@ export type ExecuteToolsetRequest = {
      */
     params: unknown;
 };
+export type FetchMcpToolsRequest = {
+    mcp_server_id: string;
+    auth?: null | McpAuth;
+    auth_uuid?: string | null;
+};
 /**
  * Request to fetch available models from provider
  */
@@ -1215,6 +1381,7 @@ export type FileObject = {
     filename?: string | null;
 };
 export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
+export type FlowType = 'redirect' | 'popup';
 /**
  * The name and arguments of a function that should be called, as generated by the model.
  */
@@ -1305,6 +1472,13 @@ export type InputAudio = {
     format: InputAudioFormat;
 };
 export type InputAudioFormat = 'wav' | 'mp3';
+export type JsonVec = Array<string>;
+export type ListMcpServersResponse = {
+    mcp_servers: Array<McpServerResponse>;
+};
+export type ListMcpsResponse = {
+    mcps: Array<McpResponse>;
+};
 export type ListModelResponse = {
     object: string;
     data: Array<Model>;
@@ -1313,13 +1487,14 @@ export type ListModelResponse = {
  * List of toolset types
  */
 export type ListToolsetTypesResponse = {
-    types: Array<ToolsetTypeResponse>;
+    types: Array<ToolsetDefinition>;
 };
 /**
  * List of toolsets
  */
 export type ListToolsetsResponse = {
     toolsets: Array<ToolsetResponse>;
+    toolset_types: Array<AppToolsetConfig>;
 };
 /**
  * List users query parameters
@@ -1336,113 +1511,378 @@ export type LocalModelResponse = {
     model_params: {};
     metadata?: null | ModelMetadata;
 };
-export type Message = {
-    role: string;
-    content: string;
-    images?: Array<string> | null;
-};
-/**
- * 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.
- */
-export type Metadata = unknown;
 /**
- * Describes an OpenAI model offering that can be used with the API.
+ * User-owned MCP server instance with tool caching and filtering.
  */
-export type Model = {
+export type Mcp = {
     /**
-     * The model identifier, which can be referenced in the API endpoints.
+     * Unique instance identifier (UUID)
      */
     id: string;
     /**
-     * The object type, which is always "model".
+     * Server info resolved via JOIN
      */
-    object: string;
+    mcp_server: McpServerInfo;
     /**
-     * The Unix timestamp (in seconds) when the model was created.
+     * User-defined slug for this instance
      */
-    created: number;
+    slug: string;
     /**
-     * The organization that owns the model.
+     * Human-readable name
      */
-    owned_by: string;
+    name: string;
+    /**
+     * Optional description for this instance
+     */
+    description?: string | null;
+    /**
+     * Whether this instance is enabled
+     */
+    enabled: boolean;
+    /**
+     * Cached tool schemas from the MCP server (JSON array)
+     */
+    tools_cache?: Array<McpTool> | null;
+    /**
+     * Whitelisted tool names (empty = block all)
+     */
+    tools_filter?: Array<string> | null;
+    auth_type: McpAuthType;
+    /**
+     * Reference to the auth config (mcp_auth_headers.id or mcp_oauth_configs.id)
+     */
+    auth_uuid?: string | null;
+    /**
+     * When this instance was created
+     */
+    created_at: string;
+    /**
+     * When this instance was last updated
+     */
+    updated_at: string;
 };
-export type ModelAlias = {
-    alias: string;
-    repo: string;
-    filename: string;
-    snapshot: string;
+export type McpApproval = {
+    url: string;
+    status: ApprovalStatus;
+    instance?: null | McpInstance;
+};
+export type McpAuth = {
+    type: 'public';
+} | {
+    header_key: string;
+    header_value: string;
+    type: 'header';
 };
 /**
- * Response for auto-discovered model aliases
+ * Discriminated union response for any type of MCP auth config.
+ * The JSON `"type"` field determines the variant: `"header"` or `"oauth"`.
  */
-export type ModelAliasResponse = {
-    source: string;
-    alias: string;
-    repo: string;
-    filename: string;
-    snapshot: string;
-    metadata?: null | ModelMetadata;
+export type McpAuthConfigResponse = {
+    id: string;
+    name: string;
+    mcp_server_id: string;
+    header_key: string;
+    has_header_value: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+    type: 'header';
+} | {
+    id: string;
+    name: string;
+    mcp_server_id: string;
+    registration_type: RegistrationType;
+    client_id: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint?: string | null;
+    scopes?: string | null;
+    client_id_issued_at?: number | null;
+    token_endpoint_auth_method?: string | null;
+    has_client_secret: boolean;
+    has_registration_access_token: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+    type: 'oauth';
 };
-export type ModelArchitecture = {
-    family?: string | null;
-    parameter_count?: number | null;
-    quantization?: string | null;
-    format: string;
+/**
+ * List wrapper for unified auth config responses.
+ */
+export type McpAuthConfigsListResponse = {
+    auth_configs: Array<McpAuthConfigResponse>;
 };
-export type ModelCapabilities = {
-    vision?: boolean | null;
-    audio?: boolean | null;
-    thinking?: boolean | null;
-    tools: ToolCapabilities;
+export type McpAuthType = 'public' | 'header' | 'oauth';
+export type McpExecuteRequest = {
+    params: unknown;
 };
-export type ModelDetails = {
-    parent_model?: string | null;
-    format: string;
-    family: string;
-    families?: Array<string> | null;
-    parameter_size: string;
-    quantization_level: string;
+export type McpExecuteResponse = {
+    result?: unknown;
+    error?: string | null;
 };
-/**
- * Model metadata for API responses
- */
-export type ModelMetadata = {
-    capabilities: ModelCapabilities;
-    context: ContextLimits;
-    architecture: ModelArchitecture;
-    chat_template?: string | null;
+export type McpInstance = {
+    id: string;
 };
-export type ModelsResponse = {
-    models: Array<OllamaModel>;
+export type McpResponse = {
+    id: string;
+    mcp_server: McpServerInfo;
+    slug: string;
+    name: string;
+    description?: string | null;
+    enabled: boolean;
+    tools_cache?: Array<McpTool> | null;
+    tools_filter?: Array<string> | null;
+    auth_type: McpAuthType;
+    auth_uuid?: string | null;
+    created_at: string;
+    updated_at: string;
 };
 /**
- * Request to pull a model file from HuggingFace
+ * Admin-managed MCP server registry entry.
+ * Admins/managers register MCP server URLs that users can then create instances of.
  */
-export type NewDownloadRequest = {
+export type McpServer = {
     /**
-     * HuggingFace repository name in format 'username/repository-name'
+     * Unique identifier (UUID)
      */
-    repo: string;
+    id: string;
     /**
-     * Model file name to download (typically .gguf format)
+     * MCP server endpoint URL (trimmed, case-insensitive unique)
      */
-    filename: string;
-};
-export type OaiRequestParams = {
-    frequency_penalty?: number | null;
-    max_tokens?: number | null;
-    presence_penalty?: number | null;
-    seed?: number | null;
-    stop?: Array<string>;
-    temperature?: number | null;
-    top_p?: number | null;
+    url: string;
+    /**
+     * Human-readable display name
+     */
+    name: string;
+    /**
+     * Optional description
+     */
+    description?: string | null;
+    /**
+     * Whether this MCP server is enabled
+     */
+    enabled: boolean;
+    /**
+     * User who created this entry
+     */
+    created_by: string;
+    /**
+     * User who last updated this entry
+     */
+    updated_by: string;
+    /**
+     * When this entry was created
+     */
+    created_at: string;
+    /**
+     * When this entry was last updated
+     */
+    updated_at: string;
+};
+/**
+ * Minimal MCP server info embedded in MCP instance responses.
+ */
+export type McpServerInfo = {
+    id: string;
+    url: string;
+    name: string;
+    enabled: boolean;
+};
+export type McpServerRequest = {
+    url: string;
+};
+export type McpServerResponse = {
+    id: string;
+    url: string;
+    name: string;
+    description?: string | null;
+    enabled: boolean;
+    created_by: string;
+    updated_by: string;
+    enabled_mcp_count: number;
+    disabled_mcp_count: number;
+    created_at: string;
+    updated_at: string;
+    auth_config?: null | McpAuthConfigResponse;
+};
+export type McpServerReviewInfo = {
+    /**
+     * Requested MCP server URL
+     */
+    url: string;
+    /**
+     * User's MCP instances connected to this server URL
+     */
+    instances: Array<Mcp>;
+};
+/**
+ * Tool schema cached from an MCP server's tools/list response.
+ */
+export type McpTool = {
+    /**
+     * Tool name as declared by the MCP server
+     */
+    name: string;
+    /**
+     * Human-readable description of the tool
+     */
+    description?: string | null;
+    /**
+     * JSON Schema for tool input parameters
+     */
+    input_schema?: unknown;
+};
+export type McpToolsResponse = {
+    tools: Array<McpTool>;
+};
+export type Message = {
+    role: string;
+    content: string;
+    images?: Array<string> | null;
+};
+/**
+ * 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.
+ */
+export type Metadata = unknown;
+/**
+ * Describes an OpenAI model offering that can be used with the API.
+ */
+export type Model = {
+    /**
+     * The model identifier, which can be referenced in the API endpoints.
+     */
+    id: string;
+    /**
+     * The object type, which is always "model".
+     */
+    object: string;
+    /**
+     * The Unix timestamp (in seconds) when the model was created.
+     */
+    created: number;
+    /**
+     * The organization that owns the model.
+     */
+    owned_by: string;
+};
+export type ModelAlias = {
+    alias: string;
+    repo: string;
+    filename: string;
+    snapshot: string;
+};
+/**
+ * Response for auto-discovered model aliases
+ */
+export type ModelAliasResponse = {
+    source: string;
+    alias: string;
+    repo: string;
+    filename: string;
+    snapshot: string;
+    metadata?: null | ModelMetadata;
+};
+export type ModelArchitecture = {
+    family?: string | null;
+    parameter_count?: number | null;
+    quantization?: string | null;
+    format: string;
+};
+export type ModelCapabilities = {
+    vision?: boolean | null;
+    audio?: boolean | null;
+    thinking?: boolean | null;
+    tools: ToolCapabilities;
+};
+export type ModelDetails = {
+    parent_model?: string | null;
+    format: string;
+    family: string;
+    families?: Array<string> | null;
+    parameter_size: string;
+    quantization_level: string;
+};
+/**
+ * Model metadata for API responses
+ */
+export type ModelMetadata = {
+    capabilities: ModelCapabilities;
+    context: ContextLimits;
+    architecture: ModelArchitecture;
+    chat_template?: string | null;
+};
+export type ModelsResponse = {
+    models: Array<OllamaModel>;
+};
+/**
+ * Request to pull a model file from HuggingFace
+ */
+export type NewDownloadRequest = {
+    /**
+     * HuggingFace repository name in format 'username/repository-name'
+     */
+    repo: string;
+    /**
+     * Model file name to download (typically .gguf format)
+     */
+    filename: string;
+};
+export type OaiRequestParams = {
+    frequency_penalty?: number | null;
+    max_tokens?: number | null;
+    presence_penalty?: number | null;
+    seed?: number | null;
+    stop?: Array<string>;
+    temperature?: number | null;
+    top_p?: number | null;
     user?: string | null;
 };
+export type OAuthDiscoverAsRequest = {
+    url: string;
+};
+export type OAuthDiscoverAsResponse = {
+    authorization_endpoint: string;
+    token_endpoint: string;
+    scopes_supported?: Array<string> | null;
+};
+export type OAuthDiscoverMcpRequest = {
+    mcp_server_url: string;
+};
+export type OAuthDiscoverMcpResponse = {
+    authorization_endpoint?: string | null;
+    token_endpoint?: string | null;
+    registration_endpoint?: string | null;
+    scopes_supported?: Array<string> | null;
+    resource?: string | null;
+    authorization_server_url?: string | null;
+};
+export type OAuthLoginRequest = {
+    redirect_uri: string;
+};
+export type OAuthLoginResponse = {
+    authorization_url: string;
+};
+export type OAuthTokenExchangeRequest = {
+    code: string;
+    redirect_uri: string;
+    state: string;
+};
+export type OAuthTokenResponse = {
+    id: string;
+    mcp_oauth_config_id: string;
+    scopes_granted?: string | null;
+    expires_at?: number | null;
+    has_access_token: boolean;
+    has_refresh_token: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+};
 export type OllamaError = {
     error: string;
 };
@@ -1662,6 +2102,14 @@ export type RefreshResponse = {
  * Source type discriminator for refresh requests
  */
 export type RefreshSource = 'all' | 'model';
+/**
+ * OAuth 2.1 registration type: pre-registered client or dynamic client registration (DCR).
+ */
+export type RegistrationType = 'pre_registered' | 'dynamic_registration';
+export type RequestedResources = {
+    toolset_types?: Array<ToolsetTypeRequest>;
+    mcp_servers?: Array<McpServerRequest>;
+};
 export type ResourceRole = 'resource_user' | 'resource_power_user' | 'resource_manager' | 'resource_admin';
 export type ResponseFormat = {
     type: 'text';
@@ -1724,7 +2172,7 @@ export type SettingMetadata = {
     options: Array<string>;
     type: 'option';
 };
-export type SettingSource = 'system' | 'command_line' | 'environment' | 'settings_file' | 'default';
+export type SettingSource = 'system' | 'command_line' | 'environment' | 'database' | 'settings_file' | 'default';
 /**
  * Request to setup the application in authenticated mode
  */
@@ -1811,7 +2259,7 @@ export type TestPromptResponse = {
 export type TokenInfo = {
     role: TokenScope;
 };
-export type TokenScope = 'scope_token_user' | 'scope_token_power_user' | 'scope_token_manager' | 'scope_token_admin';
+export type TokenScope = 'scope_token_user' | 'scope_token_power_user';
 export type TokenStatus = 'active' | 'inactive';
 export type ToolCapabilities = {
     function_calling?: boolean | null;
@@ -1821,7 +2269,7 @@ export type ToolChoiceAllowedMode = 'auto' | 'required';
 export type ToolChoiceOptions = 'none' | 'auto' | 'required';
 /**
  * Tool definition in OpenAI format for LLM function calling.
- * Tool name follows Claude MCP convention: toolset__{toolset_id}__{tool_name}
+ * Tool name follows Claude MCP convention: toolset__{toolset_name}__{tool_name}
  */
 export type ToolDefinition = {
     /**
@@ -1833,6 +2281,24 @@ export type ToolDefinition = {
      */
     function: FunctionDefinition;
 };
+export type ToolTypeReviewInfo = {
+    /**
+     * Tool type identifier
+     */
+    toolset_type: string;
+    /**
+     * Tool type display name
+     */
+    name: string;
+    /**
+     * Tool type description
+     */
+    description: string;
+    /**
+     * User's configured instances of this tool type
+     */
+    instances: Array<Toolset>;
+};
 /**
  * User-owned toolset instance with UUID identification
  */
@@ -1842,11 +2308,11 @@ export type Toolset = {
      */
     id: string;
     /**
-     * User-defined name for this instance
+     * User-defined slug for this instance
      */
-    name: string;
+    slug: string;
     /**
-     * Toolset type identifier (e.g., "builtin-exa-web-search")
+     * Toolset type identifier (e.g., "builtin-exa-search")
      */
     toolset_type: string;
     /**
@@ -1870,6 +2336,33 @@ export type Toolset = {
      */
     updated_at: string;
 };
+export type ToolsetApproval = {
+    toolset_type: string;
+    status: ApprovalStatus;
+    instance?: null | ToolsetInstance;
+};
+/**
+ * A toolset is a connector that provides one or more tools.
+ * Example: Exa Web Search toolset provides search, find_similar, get_contents, answer tools.
+ */
+export type ToolsetDefinition = {
+    /**
+     * Toolset type identifier (e.g., "builtin-exa-search")
+     */
+    toolset_type: string;
+    /**
+     * Human-readable name (e.g., "Exa Web Search")
+     */
+    name: string;
+    /**
+     * Description of the toolset
+     */
+    description: string;
+    /**
+     * Tools provided by this toolset (in OpenAI format)
+     */
+    tools: Array<ToolDefinition>;
+};
 /**
  * Response from toolset tool execution (to send back to LLM)
  */
@@ -1883,6 +2376,9 @@ export type ToolsetExecutionResponse = {
      */
     error?: string | null;
 };
+export type ToolsetInstance = {
+    id: string;
+};
 /**
  * Toolset response
  */
@@ -1892,11 +2388,11 @@ export type ToolsetResponse = {
      */
     id: string;
     /**
-     * User-defined name for this toolset
+     * User-defined slug for this toolset
      */
-    name: string;
+    slug: string;
     /**
-     * Toolset type identifier (e.g., "builtin-exa-web-search")
+     * Toolset type identifier (e.g., "builtin-exa-search")
      */
     toolset_type: string;
     /**
@@ -1911,10 +2407,6 @@ export type ToolsetResponse = {
      * Whether this toolset has an API key configured
      */
     has_api_key: boolean;
-    /**
-     * Whether the toolset type is enabled at app level
-     */
-    app_enabled: boolean;
     /**
      * Tools provided by this toolset type
      */
@@ -1928,55 +2420,8 @@ export type ToolsetResponse = {
      */
     updated_at: string;
 };
-/**
- * Toolset type response (for admin listing)
- */
-export type ToolsetTypeResponse = {
-    /**
-     * Unique toolset type identifier (e.g., "builtin-exa-web-search")
-     */
-    toolset_id: string;
-    /**
-     * Human-readable name (e.g., "Exa Web Search")
-     */
-    name: string;
-    /**
-     * Description of the toolset
-     */
-    description: string;
-    /**
-     * Whether the toolset is enabled at app level (admin-controlled)
-     */
-    app_enabled: boolean;
-    /**
-     * Tools provided by this toolset
-     */
-    tools: Array<ToolDefinition>;
-};
-/**
- * Toolset with app-level configuration status (API response model)
- */
-export type ToolsetWithTools = {
-    /**
-     * Unique toolset identifier (e.g., "builtin-exa-web-search")
-     */
-    toolset_id: string;
-    /**
-     * Human-readable name (e.g., "Exa Web Search")
-     */
-    name: string;
-    /**
-     * Description of the toolset
-     */
-    description: string;
-    /**
-     * Whether the toolset is enabled at app level (admin-controlled)
-     */
-    app_enabled: boolean;
-    /**
-     * Tools provided by this toolset
-     */
-    tools: Array<ToolDefinition>;
+export type ToolsetTypeRequest = {
+    toolset_type: string;
 };
 export type TopLogprobs = {
     /**
@@ -2041,11 +2486,27 @@ export type UpdateApiTokenRequest = {
      */
     status: TokenStatus;
 };
-/**
- * Request to update a setting value
- */
-export type UpdateSettingRequest = {
-    /**
+export type UpdateMcpRequest = {
+    name: string;
+    slug: string;
+    description?: string | null;
+    enabled: boolean;
+    tools_filter?: Array<string> | null;
+    tools_cache?: Array<McpTool> | null;
+    auth_type?: null | McpAuthType;
+    auth_uuid?: string | null;
+};
+export type UpdateMcpServerRequest = {
+    url: string;
+    name: string;
+    description?: string | null;
+    enabled: boolean;
+};
+/**
+ * Request to update a setting value
+ */
+export type UpdateSettingRequest = {
+    /**
      * New value for the setting (type depends on setting metadata)
      */
     value: unknown;
@@ -2055,9 +2516,9 @@ export type UpdateSettingRequest = {
  */
 export type UpdateToolsetRequest = {
     /**
-     * User-defined name for this toolset
+     * User-defined slug for this toolset
      */
-    name: string;
+    slug: string;
     /**
      * Optional description for this toolset
      */
@@ -2090,30 +2551,12 @@ export type UrlCitation = {
     url: string;
 };
 export type UserAccessRequest = {
-    /**
-     * Unique identifier for the request
-     */
-    id: number;
-    /**
-     * Username of the requesting user
-     */
+    id: string;
     username: string;
-    /**
-     * User ID (UUID) of the requesting user
-     */
     user_id: string;
     reviewer?: string | null;
-    /**
-     * Current status of the request
-     */
     status: UserAccessRequestStatus;
-    /**
-     * Creation timestamp
-     */
     created_at: string;
-    /**
-     * Last update timestamp
-     */
     updated_at: string;
 };
 export type UserAccessRequestStatus = 'pending' | 'approved' | 'rejected';
@@ -2139,14 +2582,18 @@ export type UserAccessStatusResponse = {
     updated_at: string;
 };
 export type UserAlias = {
+    id: string;
     alias: string;
     repo: string;
     filename: string;
     snapshot: string;
     request_params?: OaiRequestParams;
-    context_params?: Array<string>;
+    context_params?: JsonVec;
+    created_at: string;
+    updated_at: string;
 };
 export type UserAliasResponse = {
+    id: string;
     alias: string;
     repo: string;
     filename: string;
@@ -2155,6 +2602,8 @@ export type UserAliasResponse = {
     model_params: {};
     request_params: OaiRequestParams;
     context_params: Array<string>;
+    created_at: string;
+    updated_at: string;
     metadata?: null | ModelMetadata;
 };
 export type UserInfo = {
@@ -2184,7 +2633,7 @@ export type UserResponse = {
 }) | (TokenInfo & {
     auth_status: 'api_token';
 });
-export type UserScope = 'scope_user_user' | 'scope_user_power_user' | 'scope_user_manager' | 'scope_user_admin';
+export type UserScope = 'scope_user_user' | 'scope_user_power_user';
 /**
  * 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`.
  */
@@ -2442,7 +2891,7 @@ export type ApproveAccessRequestData = {
         /**
          * Access request ID
          */
-        id: number;
+        id: string;
     };
     query?: never;
     url: '/bodhi/v1/access-requests/{id}/approve';
@@ -2476,13 +2925,106 @@ export type ApproveAccessRequestResponses = {
      */
     200: unknown;
 };
+export type ApproveAppsAccessRequestData = {
+    /**
+     * Approval details with tool selections
+     */
+    body: ApproveAccessRequestBody;
+    path: {
+        /**
+         * Access request ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/access-requests/{id}/approve';
+};
+export type ApproveAppsAccessRequestErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Already processed
+     */
+    409: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type ApproveAppsAccessRequestError = ApproveAppsAccessRequestErrors[keyof ApproveAppsAccessRequestErrors];
+export type ApproveAppsAccessRequestResponses = {
+    /**
+     * Request approved
+     */
+    200: AccessRequestActionResponse;
+};
+export type ApproveAppsAccessRequestResponse = ApproveAppsAccessRequestResponses[keyof ApproveAppsAccessRequestResponses];
+export type DenyAccessRequestData = {
+    body?: never;
+    path: {
+        /**
+         * Access request ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/access-requests/{id}/deny';
+};
+export type DenyAccessRequestErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Already processed
+     */
+    409: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type DenyAccessRequestError = DenyAccessRequestErrors[keyof DenyAccessRequestErrors];
+export type DenyAccessRequestResponses = {
+    /**
+     * Request denied
+     */
+    200: AccessRequestActionResponse;
+};
+export type DenyAccessRequestResponse = DenyAccessRequestResponses[keyof DenyAccessRequestResponses];
 export type RejectAccessRequestData = {
     body?: never;
     path: {
         /**
          * Access request ID
          */
-        id: number;
+        id: string;
     };
     query?: never;
     url: '/bodhi/v1/access-requests/{id}/reject';
@@ -2516,6 +3058,51 @@ export type RejectAccessRequestResponses = {
      */
     200: unknown;
 };
+export type GetAccessRequestReviewData = {
+    body?: never;
+    path: {
+        /**
+         * Access request ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/access-requests/{id}/review';
+};
+export type GetAccessRequestReviewErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Request expired
+     */
+    410: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type GetAccessRequestReviewError = GetAccessRequestReviewErrors[keyof GetAccessRequestReviewErrors];
+export type GetAccessRequestReviewResponses = {
+    /**
+     * Review data retrieved
+     */
+    200: AccessRequestReviewResponse;
+};
+export type GetAccessRequestReviewResponse = GetAccessRequestReviewResponses[keyof GetAccessRequestReviewResponses];
 export type ListApiModelsData = {
     body?: never;
     path?: never;
@@ -2706,9 +3293,929 @@ export type DeleteApiModelData = {
         id: string;
     };
     query?: never;
-    url: '/bodhi/v1/api-models/{id}';
+    url: '/bodhi/v1/api-models/{id}';
+};
+export type DeleteApiModelErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * API model not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type DeleteApiModelError = DeleteApiModelErrors[keyof DeleteApiModelErrors];
+export type DeleteApiModelResponses = {
+    /**
+     * API model deleted
+     */
+    204: void;
+};
+export type DeleteApiModelResponse = DeleteApiModelResponses[keyof DeleteApiModelResponses];
+export type GetApiModelData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the API model alias
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/api-models/{id}';
+};
+export type GetApiModelErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * API model with specified ID not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type GetApiModelError = GetApiModelErrors[keyof GetApiModelErrors];
+export type GetApiModelResponses = {
+    /**
+     * API model configuration retrieved successfully
+     */
+    200: ApiModelResponse;
+};
+export type GetApiModelResponse = GetApiModelResponses[keyof GetApiModelResponses];
+export type UpdateApiModelData = {
+    body: UpdateApiModelRequest;
+    path: {
+        /**
+         * API model ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/api-models/{id}';
+};
+export type UpdateApiModelErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * API model not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type UpdateApiModelError = UpdateApiModelErrors[keyof UpdateApiModelErrors];
+export type UpdateApiModelResponses = {
+    /**
+     * API model updated
+     */
+    200: ApiModelResponse;
+};
+export type UpdateApiModelResponse = UpdateApiModelResponses[keyof UpdateApiModelResponses];
+export type SyncModelsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the API model alias
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/api-models/{id}/sync-models';
+};
+export type SyncModelsErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * API model not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type SyncModelsError = SyncModelsErrors[keyof SyncModelsErrors];
+export type SyncModelsResponses = {
+    /**
+     * Models synced to cache successfully
+     */
+    200: ApiModelResponse;
+};
+export type SyncModelsResponse = SyncModelsResponses[keyof SyncModelsResponses];
+export type GetAccessRequestStatusData = {
+    body?: never;
+    path: {
+        /**
+         * Access request ID
+         */
+        id: string;
+    };
+    query: {
+        /**
+         * App client ID for verification
+         */
+        app_client_id: string;
+    };
+    url: '/bodhi/v1/apps/access-requests/{id}';
+};
+export type GetAccessRequestStatusErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found or app_client_id mismatch
+     */
+    404: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type GetAccessRequestStatusError = GetAccessRequestStatusErrors[keyof GetAccessRequestStatusErrors];
+export type GetAccessRequestStatusResponses = {
+    /**
+     * Status retrieved
+     */
+    200: AccessRequestStatusResponse;
+};
+export type GetAccessRequestStatusResponse = GetAccessRequestStatusResponses[keyof GetAccessRequestStatusResponses];
+export type CreateAccessRequestData = {
+    /**
+     * Access request details
+     */
+    body: CreateAccessRequestBody;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/apps/request-access';
+};
+export type CreateAccessRequestErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * App client not found
+     */
+    404: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type CreateAccessRequestError = CreateAccessRequestErrors[keyof CreateAccessRequestErrors];
+export type CreateAccessRequestResponses = {
+    /**
+     * Access request created
+     */
+    201: CreateAccessRequestResponse;
+};
+export type CreateAccessRequestResponse2 = CreateAccessRequestResponses[keyof CreateAccessRequestResponses];
+export type CompleteOAuthFlowData = {
+    /**
+     * OAuth callback parameters from authorization server
+     */
+    body: AuthCallbackRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/auth/callback';
+};
+export type CompleteOAuthFlowErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * OAuth error, invalid request parameters, or state mismatch
+     */
+    422: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type CompleteOAuthFlowError = CompleteOAuthFlowErrors[keyof CompleteOAuthFlowErrors];
+export type CompleteOAuthFlowResponses = {
+    /**
+     * OAuth flow completed successfully, user authenticated
+     */
+    200: RedirectResponse;
+};
+export type CompleteOAuthFlowResponse = CompleteOAuthFlowResponses[keyof CompleteOAuthFlowResponses];
+export type InitiateOAuthFlowData = {
+    body: unknown;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/auth/initiate';
+};
+export type InitiateOAuthFlowErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type InitiateOAuthFlowError = InitiateOAuthFlowErrors[keyof InitiateOAuthFlowErrors];
+export type InitiateOAuthFlowResponses = {
+    /**
+     * User already authenticated, home page URL provided
+     */
+    200: RedirectResponse;
+    /**
+     * User not authenticated, OAuth authorization URL provided
+     */
+    201: RedirectResponse;
+};
+export type InitiateOAuthFlowResponse = InitiateOAuthFlowResponses[keyof InitiateOAuthFlowResponses];
+export type GetAppInfoData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/info';
+};
+export type GetAppInfoErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type GetAppInfoError = GetAppInfoErrors[keyof GetAppInfoErrors];
+export type GetAppInfoResponses = {
+    /**
+     * Application information retrieved successfully
+     */
+    200: AppInfo;
+};
+export type GetAppInfoResponse = GetAppInfoResponses[keyof GetAppInfoResponses];
+export type LogoutUserData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/logout';
+};
+export type LogoutUserErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
+export type LogoutUserResponses = {
+    /**
+     * User logged out successfully
+     */
+    200: RedirectResponse;
+};
+export type LogoutUserResponse = LogoutUserResponses[keyof LogoutUserResponses];
+export type ListMcpsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps';
+};
+export type ListMcpsErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type ListMcpsError = ListMcpsErrors[keyof ListMcpsErrors];
+export type ListMcpsResponses = {
+    /**
+     * List of user's MCP instances
+     */
+    200: ListMcpsResponse;
+};
+export type ListMcpsResponse2 = ListMcpsResponses[keyof ListMcpsResponses];
+export type CreateMcpData = {
+    body: CreateMcpRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps';
+};
+export type CreateMcpErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type CreateMcpError = CreateMcpErrors[keyof CreateMcpErrors];
+export type CreateMcpResponses = {
+    /**
+     * MCP created
+     */
+    201: McpResponse;
+};
+export type CreateMcpResponse = CreateMcpResponses[keyof CreateMcpResponses];
+export type ListMcpAuthConfigsData = {
+    body?: never;
+    path?: never;
+    query: {
+        mcp_server_id: string;
+    };
+    url: '/bodhi/v1/mcps/auth-configs';
+};
+export type ListMcpAuthConfigsErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type ListMcpAuthConfigsError = ListMcpAuthConfigsErrors[keyof ListMcpAuthConfigsErrors];
+export type ListMcpAuthConfigsResponses = {
+    /**
+     * List of auth configs
+     */
+    200: McpAuthConfigsListResponse;
+};
+export type ListMcpAuthConfigsResponse = ListMcpAuthConfigsResponses[keyof ListMcpAuthConfigsResponses];
+export type CreateMcpAuthConfigData = {
+    body: CreateAuthConfigBody;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps/auth-configs';
+};
+export type CreateMcpAuthConfigErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type CreateMcpAuthConfigError = CreateMcpAuthConfigErrors[keyof CreateMcpAuthConfigErrors];
+export type CreateMcpAuthConfigResponses = {
+    /**
+     * Auth config created
+     */
+    201: McpAuthConfigResponse;
+};
+export type CreateMcpAuthConfigResponse = CreateMcpAuthConfigResponses[keyof CreateMcpAuthConfigResponses];
+export type DeleteMcpAuthConfigData = {
+    body?: never;
+    path: {
+        /**
+         * Auth config UUID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/mcps/auth-configs/{id}';
+};
+export type DeleteMcpAuthConfigErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type DeleteMcpAuthConfigError = DeleteMcpAuthConfigErrors[keyof DeleteMcpAuthConfigErrors];
+export type DeleteMcpAuthConfigResponses = {
+    /**
+     * Auth config deleted
+     */
+    204: void;
+};
+export type DeleteMcpAuthConfigResponse = DeleteMcpAuthConfigResponses[keyof DeleteMcpAuthConfigResponses];
+export type GetMcpAuthConfigData = {
+    body?: never;
+    path: {
+        /**
+         * Auth config UUID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/mcps/auth-configs/{id}';
+};
+export type GetMcpAuthConfigErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type GetMcpAuthConfigError = GetMcpAuthConfigErrors[keyof GetMcpAuthConfigErrors];
+export type GetMcpAuthConfigResponses = {
+    /**
+     * Auth config
+     */
+    200: McpAuthConfigResponse;
+};
+export type GetMcpAuthConfigResponse = GetMcpAuthConfigResponses[keyof GetMcpAuthConfigResponses];
+export type McpOAuthLoginData = {
+    body: OAuthLoginRequest;
+    path: {
+        /**
+         * Auth config UUID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/mcps/auth-configs/{id}/login';
+};
+export type McpOAuthLoginErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Auth config not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type McpOAuthLoginError = McpOAuthLoginErrors[keyof McpOAuthLoginErrors];
+export type McpOAuthLoginResponses = {
+    /**
+     * Authorization URL
+     */
+    200: OAuthLoginResponse;
+};
+export type McpOAuthLoginResponse = McpOAuthLoginResponses[keyof McpOAuthLoginResponses];
+export type McpOAuthTokenExchangeData = {
+    body: OAuthTokenExchangeRequest;
+    path: {
+        /**
+         * Auth config UUID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/mcps/auth-configs/{id}/token';
+};
+export type McpOAuthTokenExchangeErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Auth config not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type McpOAuthTokenExchangeError = McpOAuthTokenExchangeErrors[keyof McpOAuthTokenExchangeErrors];
+export type McpOAuthTokenExchangeResponses = {
+    /**
+     * Token stored
+     */
+    200: OAuthTokenResponse;
+};
+export type McpOAuthTokenExchangeResponse = McpOAuthTokenExchangeResponses[keyof McpOAuthTokenExchangeResponses];
+export type FetchMcpToolsData = {
+    body: FetchMcpToolsRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps/fetch-tools';
+};
+export type FetchMcpToolsErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * MCP server not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type FetchMcpToolsError = FetchMcpToolsErrors[keyof FetchMcpToolsErrors];
+export type FetchMcpToolsResponses = {
+    /**
+     * List of tools from MCP server
+     */
+    200: McpToolsResponse;
+};
+export type FetchMcpToolsResponse = FetchMcpToolsResponses[keyof FetchMcpToolsResponses];
+export type DeleteMcpOAuthTokenData = {
+    body?: never;
+    path: {
+        /**
+         * OAuth token UUID
+         */
+        token_id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/mcps/oauth-tokens/{token_id}';
+};
+export type DeleteMcpOAuthTokenErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type DeleteMcpOAuthTokenError = DeleteMcpOAuthTokenErrors[keyof DeleteMcpOAuthTokenErrors];
+export type DeleteMcpOAuthTokenResponses = {
+    /**
+     * OAuth token deleted
+     */
+    204: void;
+};
+export type DeleteMcpOAuthTokenResponse = DeleteMcpOAuthTokenResponses[keyof DeleteMcpOAuthTokenResponses];
+export type GetMcpOAuthTokenData = {
+    body?: never;
+    path: {
+        /**
+         * OAuth token UUID
+         */
+        token_id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/mcps/oauth-tokens/{token_id}';
+};
+export type GetMcpOAuthTokenErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type GetMcpOAuthTokenError = GetMcpOAuthTokenErrors[keyof GetMcpOAuthTokenErrors];
+export type GetMcpOAuthTokenResponses = {
+    /**
+     * OAuth token
+     */
+    200: OAuthTokenResponse;
+};
+export type GetMcpOAuthTokenResponse = GetMcpOAuthTokenResponses[keyof GetMcpOAuthTokenResponses];
+export type McpOAuthDiscoverAsData = {
+    body: OAuthDiscoverAsRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps/oauth/discover-as';
+};
+export type McpOAuthDiscoverAsErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type McpOAuthDiscoverAsError = McpOAuthDiscoverAsErrors[keyof McpOAuthDiscoverAsErrors];
+export type McpOAuthDiscoverAsResponses = {
+    /**
+     * OAuth discovery metadata
+     */
+    200: OAuthDiscoverAsResponse;
+};
+export type McpOAuthDiscoverAsResponse = McpOAuthDiscoverAsResponses[keyof McpOAuthDiscoverAsResponses];
+export type McpOAuthDiscoverMcpData = {
+    body: OAuthDiscoverMcpRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps/oauth/discover-mcp';
+};
+export type McpOAuthDiscoverMcpErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type McpOAuthDiscoverMcpError = McpOAuthDiscoverMcpErrors[keyof McpOAuthDiscoverMcpErrors];
+export type McpOAuthDiscoverMcpResponses = {
+    /**
+     * MCP OAuth discovery metadata
+     */
+    200: OAuthDiscoverMcpResponse;
+};
+export type McpOAuthDiscoverMcpResponse = McpOAuthDiscoverMcpResponses[keyof McpOAuthDiscoverMcpResponses];
+export type McpOAuthDynamicRegisterStandaloneData = {
+    body: DynamicRegisterRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps/oauth/dynamic-register';
+};
+export type McpOAuthDynamicRegisterStandaloneErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type McpOAuthDynamicRegisterStandaloneError = McpOAuthDynamicRegisterStandaloneErrors[keyof McpOAuthDynamicRegisterStandaloneErrors];
+export type McpOAuthDynamicRegisterStandaloneResponses = {
+    /**
+     * Dynamic client registration result
+     */
+    200: DynamicRegisterResponse;
+};
+export type McpOAuthDynamicRegisterStandaloneResponse = McpOAuthDynamicRegisterStandaloneResponses[keyof McpOAuthDynamicRegisterStandaloneResponses];
+export type ListMcpServersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by enabled status
+         */
+        enabled?: boolean;
+    };
+    url: '/bodhi/v1/mcps/servers';
+};
+export type ListMcpServersErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type ListMcpServersError = ListMcpServersErrors[keyof ListMcpServersErrors];
+export type ListMcpServersResponses = {
+    /**
+     * List of MCP servers
+     */
+    200: ListMcpServersResponse;
+};
+export type ListMcpServersResponse2 = ListMcpServersResponses[keyof ListMcpServersResponses];
+export type CreateMcpServerData = {
+    body: CreateMcpServerRequest;
+    path?: never;
+    query?: never;
+    url: '/bodhi/v1/mcps/servers';
 };
-export type DeleteApiModelErrors = {
+export type CreateMcpServerErrors = {
     /**
      * Invalid request parameters
      */
@@ -2722,34 +4229,34 @@ export type DeleteApiModelErrors = {
      */
     403: OpenAiApiError;
     /**
-     * API model not found
+     * URL already exists
      */
-    404: OpenAiApiError;
+    409: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type DeleteApiModelError = DeleteApiModelErrors[keyof DeleteApiModelErrors];
-export type DeleteApiModelResponses = {
+export type CreateMcpServerError = CreateMcpServerErrors[keyof CreateMcpServerErrors];
+export type CreateMcpServerResponses = {
     /**
-     * API model deleted
+     * MCP server created
      */
-    204: void;
+    201: McpServerResponse;
 };
-export type DeleteApiModelResponse = DeleteApiModelResponses[keyof DeleteApiModelResponses];
-export type GetApiModelData = {
+export type CreateMcpServerResponse = CreateMcpServerResponses[keyof CreateMcpServerResponses];
+export type GetMcpServerData = {
     body?: never;
     path: {
         /**
-         * Unique identifier for the API model alias
+         * MCP server UUID
          */
         id: string;
     };
     query?: never;
-    url: '/bodhi/v1/api-models/{id}';
+    url: '/bodhi/v1/mcps/servers/{id}';
 };
-export type GetApiModelErrors = {
+export type GetMcpServerErrors = {
     /**
      * Invalid request parameters
      */
@@ -2763,34 +4270,34 @@ export type GetApiModelErrors = {
      */
     403: OpenAiApiError;
     /**
-     * API model with specified ID not found
+     * Not found
      */
-    404: OpenAiApiError;
+    404: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type GetApiModelError = GetApiModelErrors[keyof GetApiModelErrors];
-export type GetApiModelResponses = {
+export type GetMcpServerError = GetMcpServerErrors[keyof GetMcpServerErrors];
+export type GetMcpServerResponses = {
     /**
-     * API model configuration retrieved successfully
+     * MCP server
      */
-    200: ApiModelResponse;
+    200: McpServerResponse;
 };
-export type GetApiModelResponse = GetApiModelResponses[keyof GetApiModelResponses];
-export type UpdateApiModelData = {
-    body: UpdateApiModelRequest;
+export type GetMcpServerResponse = GetMcpServerResponses[keyof GetMcpServerResponses];
+export type UpdateMcpServerData = {
+    body: UpdateMcpServerRequest;
     path: {
         /**
-         * API model ID
+         * MCP server UUID
          */
         id: string;
     };
     query?: never;
-    url: '/bodhi/v1/api-models/{id}';
+    url: '/bodhi/v1/mcps/servers/{id}';
 };
-export type UpdateApiModelErrors = {
+export type UpdateMcpServerErrors = {
     /**
      * Invalid request parameters
      */
@@ -2804,34 +4311,38 @@ export type UpdateApiModelErrors = {
      */
     403: OpenAiApiError;
     /**
-     * API model not found
+     * Not found
      */
-    404: OpenAiApiError;
+    404: unknown;
+    /**
+     * URL already exists
+     */
+    409: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type UpdateApiModelError = UpdateApiModelErrors[keyof UpdateApiModelErrors];
-export type UpdateApiModelResponses = {
+export type UpdateMcpServerError = UpdateMcpServerErrors[keyof UpdateMcpServerErrors];
+export type UpdateMcpServerResponses = {
     /**
-     * API model updated
+     * MCP server updated
      */
-    200: ApiModelResponse;
+    200: McpServerResponse;
 };
-export type UpdateApiModelResponse = UpdateApiModelResponses[keyof UpdateApiModelResponses];
-export type SyncModelsData = {
+export type UpdateMcpServerResponse = UpdateMcpServerResponses[keyof UpdateMcpServerResponses];
+export type DeleteMcpData = {
     body?: never;
     path: {
         /**
-         * Unique identifier for the API model alias
+         * MCP instance UUID
          */
         id: string;
     };
     query?: never;
-    url: '/bodhi/v1/api-models/{id}/sync-models';
+    url: '/bodhi/v1/mcps/{id}';
 };
-export type SyncModelsErrors = {
+export type DeleteMcpErrors = {
     /**
      * Invalid request parameters
      */
@@ -2845,7 +4356,7 @@ export type SyncModelsErrors = {
      */
     403: OpenAiApiError;
     /**
-     * API model not found
+     * MCP not found
      */
     404: unknown;
     /**
@@ -2853,24 +4364,26 @@ export type SyncModelsErrors = {
      */
     500: OpenAiApiError;
 };
-export type SyncModelsError = SyncModelsErrors[keyof SyncModelsErrors];
-export type SyncModelsResponses = {
+export type DeleteMcpError = DeleteMcpErrors[keyof DeleteMcpErrors];
+export type DeleteMcpResponses = {
     /**
-     * Models synced to cache successfully
+     * MCP deleted
      */
-    200: ApiModelResponse;
+    204: void;
 };
-export type SyncModelsResponse = SyncModelsResponses[keyof SyncModelsResponses];
-export type RequestAccessData = {
-    /**
-     * Application client requesting access
-     */
-    body: AppAccessRequest;
-    path?: never;
+export type DeleteMcpResponse = DeleteMcpResponses[keyof DeleteMcpResponses];
+export type GetMcpData = {
+    body?: never;
+    path: {
+        /**
+         * MCP instance UUID
+         */
+        id: string;
+    };
     query?: never;
-    url: '/bodhi/v1/apps/request-access';
+    url: '/bodhi/v1/mcps/{id}';
 };
-export type RequestAccessErrors = {
+export type GetMcpErrors = {
     /**
      * Invalid request parameters
      */
@@ -2883,29 +4396,35 @@ export type RequestAccessErrors = {
      * Insufficient permissions
      */
     403: OpenAiApiError;
+    /**
+     * MCP not found
+     */
+    404: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type RequestAccessError = RequestAccessErrors[keyof RequestAccessErrors];
-export type RequestAccessResponses = {
+export type GetMcpError = GetMcpErrors[keyof GetMcpErrors];
+export type GetMcpResponses = {
     /**
-     * Access granted successfully
+     * MCP instance
      */
-    200: AppAccessResponse;
+    200: McpResponse;
 };
-export type RequestAccessResponse = RequestAccessResponses[keyof RequestAccessResponses];
-export type CompleteOAuthFlowData = {
-    /**
-     * OAuth callback parameters from authorization server
-     */
-    body: AuthCallbackRequest;
-    path?: never;
+export type GetMcpResponse = GetMcpResponses[keyof GetMcpResponses];
+export type UpdateMcpData = {
+    body: UpdateMcpRequest;
+    path: {
+        /**
+         * MCP instance UUID
+         */
+        id: string;
+    };
     query?: never;
-    url: '/bodhi/v1/auth/callback';
+    url: '/bodhi/v1/mcps/{id}';
 };
-export type CompleteOAuthFlowErrors = {
+export type UpdateMcpErrors = {
     /**
      * Invalid request parameters
      */
@@ -2919,29 +4438,34 @@ export type CompleteOAuthFlowErrors = {
      */
     403: OpenAiApiError;
     /**
-     * OAuth error, invalid request parameters, or state mismatch
+     * MCP not found
      */
-    422: OpenAiApiError;
+    404: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type CompleteOAuthFlowError = CompleteOAuthFlowErrors[keyof CompleteOAuthFlowErrors];
-export type CompleteOAuthFlowResponses = {
+export type UpdateMcpError = UpdateMcpErrors[keyof UpdateMcpErrors];
+export type UpdateMcpResponses = {
     /**
-     * OAuth flow completed successfully, user authenticated
+     * MCP updated
      */
-    200: RedirectResponse;
+    200: McpResponse;
 };
-export type CompleteOAuthFlowResponse = CompleteOAuthFlowResponses[keyof CompleteOAuthFlowResponses];
-export type InitiateOAuthFlowData = {
-    body: unknown;
-    path?: never;
+export type UpdateMcpResponse = UpdateMcpResponses[keyof UpdateMcpResponses];
+export type RefreshMcpToolsData = {
+    body?: never;
+    path: {
+        /**
+         * MCP instance UUID
+         */
+        id: string;
+    };
     query?: never;
-    url: '/bodhi/v1/auth/initiate';
+    url: '/bodhi/v1/mcps/{id}/tools/refresh';
 };
-export type InitiateOAuthFlowErrors = {
+export type RefreshMcpToolsErrors = {
     /**
      * Invalid request parameters
      */
@@ -2955,53 +4479,38 @@ export type InitiateOAuthFlowErrors = {
      */
     403: OpenAiApiError;
     /**
-     * Internal server error
-     */
-    500: OpenAiApiError;
-};
-export type InitiateOAuthFlowError = InitiateOAuthFlowErrors[keyof InitiateOAuthFlowErrors];
-export type InitiateOAuthFlowResponses = {
-    /**
-     * User already authenticated, home page URL provided
-     */
-    200: RedirectResponse;
-    /**
-     * User not authenticated, OAuth authorization URL provided
-     */
-    201: RedirectResponse;
-};
-export type InitiateOAuthFlowResponse = InitiateOAuthFlowResponses[keyof InitiateOAuthFlowResponses];
-export type GetAppInfoData = {
-    body?: never;
-    path?: never;
-    query?: never;
-    url: '/bodhi/v1/info';
-};
-export type GetAppInfoErrors = {
-    /**
-     * Invalid request parameters
+     * MCP not found
      */
-    400: OpenAiApiError;
+    404: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type GetAppInfoError = GetAppInfoErrors[keyof GetAppInfoErrors];
-export type GetAppInfoResponses = {
+export type RefreshMcpToolsError = RefreshMcpToolsErrors[keyof RefreshMcpToolsErrors];
+export type RefreshMcpToolsResponses = {
     /**
-     * Application information retrieved successfully
+     * Refreshed list of tools
      */
-    200: AppInfo;
+    200: McpToolsResponse;
 };
-export type GetAppInfoResponse = GetAppInfoResponses[keyof GetAppInfoResponses];
-export type LogoutUserData = {
-    body?: never;
-    path?: never;
+export type RefreshMcpToolsResponse = RefreshMcpToolsResponses[keyof RefreshMcpToolsResponses];
+export type ExecuteMcpToolData = {
+    body: McpExecuteRequest;
+    path: {
+        /**
+         * MCP instance UUID
+         */
+        id: string;
+        /**
+         * Tool name to execute
+         */
+        tool_name: string;
+    };
     query?: never;
-    url: '/bodhi/v1/logout';
+    url: '/bodhi/v1/mcps/{id}/tools/{tool_name}/execute';
 };
-export type LogoutUserErrors = {
+export type ExecuteMcpToolErrors = {
     /**
      * Invalid request parameters
      */
@@ -3014,19 +4523,23 @@ export type LogoutUserErrors = {
      * Insufficient permissions
      */
     403: OpenAiApiError;
+    /**
+     * MCP or tool not found
+     */
+    404: unknown;
     /**
      * Internal server error
      */
     500: OpenAiApiError;
 };
-export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
-export type LogoutUserResponses = {
+export type ExecuteMcpToolError = ExecuteMcpToolErrors[keyof ExecuteMcpToolErrors];
+export type ExecuteMcpToolResponses = {
     /**
-     * User logged out successfully
+     * Tool execution result
      */
-    200: RedirectResponse;
+    200: McpExecuteResponse;
 };
-export type LogoutUserResponse = LogoutUserResponses[keyof LogoutUserResponses];
+export type ExecuteMcpToolResponse = ExecuteMcpToolResponses[keyof ExecuteMcpToolResponses];
 export type ListModelFilesData = {
     body?: never;
     path?: never;
@@ -3164,51 +4677,6 @@ export type PullModelFileResponses = {
     201: DownloadRequest;
 };
 export type PullModelFileResponse = PullModelFileResponses[keyof PullModelFileResponses];
-export type PullModelByAliasData = {
-    body?: never;
-    path: {
-        /**
-         * Predefined model alias. Available aliases include popular models like llama2:chat, mistral:instruct, phi3:mini, etc. Use the /models endpoint to see all available aliases.
-         */
-        alias: string;
-    };
-    query?: never;
-    url: '/bodhi/v1/modelfiles/pull/{alias}';
-};
-export type PullModelByAliasErrors = {
-    /**
-     * Invalid request parameters
-     */
-    400: OpenAiApiError;
-    /**
-     * Not authenticated
-     */
-    401: OpenAiApiError;
-    /**
-     * Insufficient permissions
-     */
-    403: OpenAiApiError;
-    /**
-     * Alias not found
-     */
-    404: OpenAiApiError;
-    /**
-     * Internal server error
-     */
-    500: OpenAiApiError;
-};
-export type PullModelByAliasError = PullModelByAliasErrors[keyof PullModelByAliasErrors];
-export type PullModelByAliasResponses = {
-    /**
-     * Existing download request found
-     */
-    200: DownloadRequest;
-    /**
-     * Download request created
-     */
-    201: DownloadRequest;
-};
-export type PullModelByAliasResponse = PullModelByAliasResponses[keyof PullModelByAliasResponses];
 export type GetDownloadStatusData = {
     body?: never;
     path: {
@@ -3374,16 +4842,56 @@ export type RefreshModelMetadataResponses = {
     202: RefreshResponse;
 };
 export type RefreshModelMetadataResponse = RefreshModelMetadataResponses[keyof RefreshModelMetadataResponses];
+export type DeleteAliasData = {
+    body?: never;
+    path: {
+        /**
+         * UUID of the alias to delete
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/models/{id}';
+};
+export type DeleteAliasErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Alias not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type DeleteAliasError = DeleteAliasErrors[keyof DeleteAliasErrors];
+export type DeleteAliasResponses = {
+    /**
+     * Alias deleted successfully
+     */
+    200: unknown;
+};
 export type GetAliasData = {
     body?: never;
     path: {
         /**
-         * Alias identifier for the model
+         * UUID of the alias
          */
-        alias: string;
+        id: string;
     };
     query?: never;
-    url: '/bodhi/v1/models/{alias}';
+    url: '/bodhi/v1/models/{id}';
 };
 export type GetAliasErrors = {
     /**
@@ -3419,7 +4927,7 @@ export type UpdateAliasData = {
     body: UpdateAliasRequest;
     path: {
         /**
-         * Alias identifier
+         * UUID of the alias to update
          */
         id: string;
     };
@@ -3452,6 +4960,47 @@ export type UpdateAliasResponses = {
     200: UserAliasResponse;
 };
 export type UpdateAliasResponse = UpdateAliasResponses[keyof UpdateAliasResponses];
+export type CopyAliasData = {
+    body: CopyAliasRequest;
+    path: {
+        /**
+         * UUID of the alias to copy
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/bodhi/v1/models/{id}/copy';
+};
+export type CopyAliasErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: OpenAiApiError;
+    /**
+     * Not authenticated
+     */
+    401: OpenAiApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: OpenAiApiError;
+    /**
+     * Source alias not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: OpenAiApiError;
+};
+export type CopyAliasError = CopyAliasErrors[keyof CopyAliasErrors];
+export type CopyAliasResponses = {
+    /**
+     * Alias copied successfully
+     */
+    201: UserAliasResponse;
+};
+export type CopyAliasResponse = CopyAliasResponses[keyof CopyAliasResponses];
 export type GetQueueStatusData = {
     body?: never;
     path?: never;
@@ -3797,12 +5346,12 @@ export type DisableToolsetTypeData = {
     body?: never;
     path: {
         /**
-         * Toolset type identifier
+         * Toolset type identifier (e.g., 'builtin-exa-search')
          */
-        type_id: string;
+        toolset_type: string;
     };
     query?: never;
-    url: '/bodhi/v1/toolset_types/{type_id}/app-config';
+    url: '/bodhi/v1/toolset_types/{toolset_type}/app-config';
 };
 export type DisableToolsetTypeErrors = {
     /**
@@ -3831,19 +5380,19 @@ export type DisableToolsetTypeResponses = {
     /**
      * Toolset type disabled
      */
-    200: AppToolsetConfigResponse;
+    200: AppToolsetConfig;
 };
 export type DisableToolsetTypeResponse = DisableToolsetTypeResponses[keyof DisableToolsetTypeResponses];
 export type EnableToolsetTypeData = {
     body?: never;
     path: {
         /**
-         * Toolset type identifier
+         * Toolset type identifier (e.g., 'builtin-exa-search')
          */
-        type_id: string;
+        toolset_type: string;
     };
     query?: never;
-    url: '/bodhi/v1/toolset_types/{type_id}/app-config';
+    url: '/bodhi/v1/toolset_types/{toolset_type}/app-config';
 };
 export type EnableToolsetTypeErrors = {
     /**
@@ -3872,7 +5421,7 @@ export type EnableToolsetTypeResponses = {
     /**
      * Toolset type enabled
      */
-    200: AppToolsetConfigResponse;
+    200: AppToolsetConfig;
 };
 export type EnableToolsetTypeResponse = EnableToolsetTypeResponses[keyof EnableToolsetTypeResponses];
 export type ListToolsetsData = {
@@ -4070,7 +5619,7 @@ export type UpdateToolsetResponses = {
     200: ToolsetResponse;
 };
 export type UpdateToolsetResponse = UpdateToolsetResponses[keyof UpdateToolsetResponses];
-export type ExecuteToolsetData = {
+export type ExecuteToolsetToolData = {
     body: ExecuteToolsetRequest;
     path: {
         /**
@@ -4078,14 +5627,14 @@ export type ExecuteToolsetData = {
          */
         id: string;
         /**
-         * Tool method name
+         * Tool name to execute
          */
-        method: string;
+        tool_name: string;
     };
     query?: never;
-    url: '/bodhi/v1/toolsets/{id}/execute/{method}';
+    url: '/bodhi/v1/toolsets/{id}/tools/{tool_name}/execute';
 };
-export type ExecuteToolsetErrors = {
+export type ExecuteToolsetToolErrors = {
     /**
      * Invalid request parameters
      */
@@ -4107,14 +5656,14 @@ export type ExecuteToolsetErrors = {
      */
     500: OpenAiApiError;
 };
-export type ExecuteToolsetError = ExecuteToolsetErrors[keyof ExecuteToolsetErrors];
-export type ExecuteToolsetResponses = {
+export type ExecuteToolsetToolError = ExecuteToolsetToolErrors[keyof ExecuteToolsetToolErrors];
+export type ExecuteToolsetToolResponses = {
     /**
      * Tool execution result
      */
     200: ToolsetExecutionResponse;
 };
-export type ExecuteToolsetResponse = ExecuteToolsetResponses[keyof ExecuteToolsetResponses];
+export type ExecuteToolsetToolResponse = ExecuteToolsetToolResponses[keyof ExecuteToolsetToolResponses];
 export type GetCurrentUserData = {
     body?: never;
     path?: never;