@bodhiapp/ts-client 0.1.12 → 0.1.14

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

@@ -668,7 +668,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/bodhi/v1/user": {
+    "/bodhi/v1/toolset_types": {
         parameters: {
             query?: never;
             header?: never;
@@ -676,10 +676,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Current User Information
-         * @description Retrieves information about the currently authenticated user. This endpoint supports optional authentication - returns `logged_out` status if not authenticated, or user details with roles/scopes if authenticated via any method (session, API token, or OAuth exchange).
+         * List all available toolset types with their tools
+         * @description For OAuth tokens, filters types by scope_toolset-* scopes in the token.
          */
-        get: operations["getCurrentUser"];
+        get: operations["listToolsetTypes"];
         put?: never;
         post?: never;
         delete?: never;
@@ -688,7 +688,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/bodhi/v1/user/request-access": {
+    "/bodhi/v1/toolset_types/{type_id}/app-config": {
         parameters: {
             query?: never;
             header?: never;
@@ -696,19 +696,17 @@ export interface paths {
             cookie?: never;
         };
         get?: never;
-        put?: never;
-        /**
-         * Request User Access
-         * @description Authenticated users without roles can request access to the system. Only one pending request is allowed per user.
-         */
-        post: operations["requestUserAccess"];
-        delete?: 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/user/request-status": {
+    "/bodhi/v1/toolsets": {
         parameters: {
             query?: never;
             header?: never;
@@ -716,39 +714,39 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Access Request Status
-         * @description Check the status of the current user's access request.
+         * List all toolsets for the authenticated user
+         * @description For OAuth tokens, filters toolsets by scope_toolset-* scopes in the token.
          */
-        get: operations["getUserAccessStatus"];
+        get: operations["listToolsets"];
         put?: never;
-        post?: never;
+        /** Create a new toolset */
+        post: operations["createToolset"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/bodhi/v1/users": {
+    "/bodhi/v1/toolsets/{id}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /**
-         * List users
-         * @description List all users with roles and status information. Available to managers and admins.
-         */
-        get: operations["listUsers"];
-        put?: never;
+        /** Get a specific toolset by ID */
+        get: operations["getToolset"];
+        /** Update a toolset (full PUT semantics) */
+        put: operations["updateToolset"];
         post?: never;
-        delete?: never;
+        /** Delete a toolset */
+        delete: operations["deleteToolset"];
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/bodhi/v1/users/{user_id}": {
+    "/bodhi/v1/toolsets/{id}/execute/{method}": {
         parameters: {
             query?: never;
             header?: never;
@@ -757,18 +755,35 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        post?: 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;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
-         * Remove user access
-         * @description Remove a user's access to the application. Only admins can remove users.
+         * Get Current User Information
+         * @description Retrieves information about the currently authenticated user. This endpoint supports optional authentication - returns `logged_out` status if not authenticated, or user details with roles/scopes if authenticated via any method (session, API token, or OAuth exchange).
          */
-        delete: operations["removeUser"];
+        get: operations["getCurrentUser"];
+        put?: never;
+        post?: never;
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/bodhi/v1/users/{user_id}/role": {
+    "/bodhi/v1/user/request-access": {
         parameters: {
             query?: never;
             header?: never;
@@ -776,19 +791,19 @@ export interface paths {
             cookie?: never;
         };
         get?: never;
+        put?: never;
         /**
-         * Change user role
-         * @description Assign a new role to a user. Admins can assign any role, managers can assign user/power_user/manager roles.
+         * Request User Access
+         * @description Authenticated users without roles can request access to the system. Only one pending request is allowed per user.
          */
-        put: operations["changeUserRole"];
-        post?: never;
+        post: operations["requestUserAccess"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/health": {
+    "/bodhi/v1/user/request-status": {
         parameters: {
             query?: never;
             header?: never;
@@ -796,10 +811,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Health Check
-         * @description Comprehensive health check to verify all application components are operational
+         * Get Access Request Status
+         * @description Check the status of the current user's access request.
          */
-        get: operations["healthCheck"];
+        get: operations["getUserAccessStatus"];
         put?: never;
         post?: never;
         delete?: never;
@@ -808,7 +823,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/ping": {
+    "/bodhi/v1/users": {
         parameters: {
             query?: never;
             header?: never;
@@ -816,10 +831,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Ping Server
-         * @description Simple connectivity check to verify the server is responding
+         * List users
+         * @description List all users with roles and status information. Available to managers and admins.
          */
-        get: operations["pingServer"];
+        get: operations["listUsers"];
         put?: never;
         post?: never;
         delete?: never;
@@ -828,28 +843,27 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/toolsets": {
+    "/bodhi/v1/users/{user_id}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /**
-         * List all available toolset definitions with app-enabled status (for UI)
-         * @description For OAuth tokens, filters toolsets based on scope_toolset-* scopes in the token.
-         *     For session auth, returns all toolsets.
-         */
-        get: operations["list_all_toolsets_handler"];
+        get?: never;
         put?: never;
         post?: never;
-        delete?: never;
+        /**
+         * Remove user access
+         * @description Remove a user's access to the application. Only admins can remove users.
+         */
+        delete: operations["removeUser"];
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/toolsets/{toolset_id}/app-config": {
+    "/bodhi/v1/users/{user_id}/role": {
         parameters: {
             query?: never;
             header?: never;
@@ -857,46 +871,52 @@ export interface paths {
             cookie?: never;
         };
         get?: never;
-        /** Enable a toolset for this app instance (admin only) */
-        put: operations["enable_app_toolset_handler"];
+        /**
+         * Change user role
+         * @description Assign a new role to a user. Admins can assign any role, managers can assign user/power_user/manager roles.
+         */
+        put: operations["changeUserRole"];
         post?: never;
-        /** Disable a toolset for this app instance (admin only) */
-        delete: operations["disable_app_toolset_handler"];
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/toolsets/{toolset_id}/config": {
+    "/health": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Get user's configuration for a specific toolset (with app-level status) */
-        get: operations["get_toolset_config_handler"];
-        /** Update user's toolset configuration */
-        put: operations["update_toolset_config_handler"];
+        /**
+         * Health Check
+         * @description Comprehensive health check to verify all application components are operational
+         */
+        get: operations["healthCheck"];
+        put?: never;
         post?: never;
-        /** Delete user's toolset configuration (clears API key) */
-        delete: operations["delete_toolset_config_handler"];
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/toolsets/{toolset_id}/execute/{method}": {
+    "/ping": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * Ping Server
+         * @description Simple connectivity check to verify the server is responding
+         */
+        get: operations["pingServer"];
         put?: never;
-        /** Execute a toolset for the user */
-        post: operations["execute_toolset_handler"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
@@ -1060,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 {
@@ -1130,7 +1160,7 @@ export interface components {
             /** @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;
+            app_client_config_version?: string | null;
         };
         /** @description Toolset configuration from app-client registration */
         AppClientToolset: {
@@ -1932,6 +1962,19 @@ 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;
@@ -2024,15 +2067,6 @@ export interface components {
         };
         /** @enum {string} */
         EncodingFormat: "float" | "base64";
-        /** @description Enhanced toolset config response with app-level status */
-        EnhancedToolsetConfigResponse: {
-            /** @description Toolset identifier */
-            toolset_id: string;
-            /** @description Whether the toolset is enabled at app level */
-            app_enabled: boolean;
-            /** @description User's configuration */
-            config: components["schemas"]["UserToolsetConfig"];
-        };
         /** @example {
          *       "code": "validation_error",
          *       "message": "Validation failed: name is required",
@@ -2063,8 +2097,6 @@ export interface components {
         };
         /** @description Request to execute a toolset */
         ExecuteToolsetRequest: {
-            /** @description Tool call ID from LLM */
-            tool_call_id: string;
             /** @description Function parameters as JSON */
             params: unknown;
         };
@@ -2173,9 +2205,13 @@ export interface components {
             object: string;
             data: components["schemas"]["Model"][];
         };
-        /** @description Response with list of toolset definitions (enhanced with status) */
+        /** @description List of toolset types */
+        ListToolsetTypesResponse: {
+            types: components["schemas"]["ToolsetTypeResponse"][];
+        };
+        /** @description List of toolsets */
         ListToolsetsResponse: {
-            toolsets: components["schemas"]["ToolsetWithTools"][];
+            toolsets: components["schemas"]["ToolsetResponse"][];
         };
         /** @description List users query parameters */
         ListUsersParams: {
@@ -2745,16 +2781,83 @@ export interface components {
             /** @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 with app-level and user-level configuration status (API response model) */
+        /** @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;
@@ -2764,7 +2867,6 @@ export interface components {
             description: string;
             /** @description Whether the toolset is enabled at app level (admin-controlled) */
             app_enabled: boolean;
-            user_config?: null | components["schemas"]["UserToolsetConfigSummary"];
             /** @description Tools provided by this toolset */
             tools: components["schemas"]["ToolDefinition"][];
         };
@@ -2841,12 +2943,16 @@ export interface components {
             /** @description New value for the setting (type depends on setting metadata) */
             value: unknown;
         };
-        /** @description Request to update a user's toolset configuration */
-        UpdateToolsetConfigRequest: {
-            /** @description Whether the toolset is enabled for this user */
+        /** @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 Optional API key for the toolset (will be encrypted) */
-            api_key?: string | null;
+            /** @description API key update action (Keep or Set) */
+            api_key?: components["schemas"]["ApiKeyUpdateDto"];
         };
         UrlCitation: {
             /**
@@ -2996,33 +3102,6 @@ export interface components {
         });
         /** @enum {string} */
         UserScope: "scope_user_user" | "scope_user_power_user" | "scope_user_manager" | "scope_user_admin";
-        /** @description User's configuration for a specific toolset (API model - no sensitive data).
-         *     API key is stored at toolset level (one key for all tools in toolset). */
-        UserToolsetConfig: {
-            /** @description Toolset identifier (e.g., "builtin-exa-web-search") */
-            toolset_id: string;
-            /** @description Whether the toolset is enabled for this user */
-            enabled: boolean;
-            /**
-             * 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 Summary of user's toolset configuration (for list responses) */
-        UserToolsetConfigSummary: {
-            /** @description Whether the user has enabled this toolset */
-            enabled: boolean;
-            /** @description Whether the user has configured an API key */
-            has_api_key: boolean;
-        };
         /**
          * @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}
@@ -6076,7 +6155,7 @@ export interface operations {
             };
         };
     };
-    getCurrentUser: {
+    listToolsetTypes: {
         parameters: {
             query?: never;
             header?: never;
@@ -6085,13 +6164,13 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description User information (authenticated or not) */
+            /** @description List of all toolset types */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["UserResponse"];
+                    "application/json": components["schemas"]["ListToolsetTypesResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6132,21 +6211,26 @@ export interface operations {
             };
         };
     };
-    requestUserAccess: {
+    enableToolsetType: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                /** @description Toolset type identifier */
+                type_id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Access request created successfully */
-            201: {
+            /** @description Toolset type enabled */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["AppToolsetConfigResponse"];
+                };
             };
             /** @description Invalid request parameters */
             400: {
@@ -6175,23 +6259,12 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Pending request already exists */
-            409: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["OpenAIApiError"];
-                };
-            };
-            /** @description User already has role */
-            422: {
+            /** @description Toolset type not found */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["OpenAIApiError"];
-                };
+                content?: never;
             };
             /** @description Internal server error */
             500: {
@@ -6204,22 +6277,25 @@ export interface operations {
             };
         };
     };
-    getUserAccessStatus: {
+    disableToolsetType: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                /** @description Toolset type identifier */
+                type_id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Request status retrieved */
+            /** @description Toolset type disabled */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["UserAccessStatusResponse"];
+                    "application/json": components["schemas"]["AppToolsetConfigResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6249,14 +6325,12 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Request not found */
+            /** @description Toolset type not found */
             404: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["OpenAIApiError"];
-                };
+                content?: never;
             };
             /** @description Internal server error */
             500: {
@@ -6269,33 +6343,22 @@ export interface operations {
             };
         };
     };
-    listUsers: {
+    listToolsets: {
         parameters: {
-            query?: {
-                /**
-                 * @description Page number (1-based)
-                 * @example 1
-                 */
-                page?: number;
-                /**
-                 * @description Number of users per page
-                 * @example 10
-                 */
-                page_size?: number;
-            };
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Users retrieved successfully */
+            /** @description List of user's toolsets */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["UserListResponse"];
+                    "application/json": components["schemas"]["ListToolsetsResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6336,24 +6399,27 @@ export interface operations {
             };
         };
     };
-    removeUser: {
+    createToolset: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                /** @description User ID to remove */
-                user_id: string;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateToolsetRequest"];
+            };
+        };
         responses: {
-            /** @description User removed successfully */
-            200: {
+            /** @description Toolset created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["ToolsetResponse"];
+                };
             };
             /** @description Invalid request parameters */
             400: {
@@ -6382,8 +6448,65 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description User not found */
-            404: {
+            /** @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;
                 };
@@ -6391,6 +6514,13 @@ export interface operations {
                     "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: {
@@ -6402,28 +6532,30 @@ export interface operations {
             };
         };
     };
-    changeUserRole: {
+    updateToolset: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                /** @description User ID to change role for */
-                user_id: string;
+                /** @description Toolset instance UUID */
+                id: string;
             };
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ChangeRoleRequest"];
+                "application/json": components["schemas"]["UpdateToolsetRequest"];
             };
         };
         responses: {
-            /** @description Role changed successfully */
+            /** @description Toolset updated */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["ToolsetResponse"];
+                };
             };
             /** @description Invalid request parameters */
             400: {
@@ -6452,14 +6584,19 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description User not found */
+            /** @description Toolset not found or not owned */
             404: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["OpenAIApiError"];
+                content?: never;
+            };
+            /** @description Name already exists */
+            409: {
+                headers: {
+                    [name: string]: unknown;
                 };
+                content?: never;
             };
             /** @description Internal server error */
             500: {
@@ -6472,26 +6609,24 @@ export interface operations {
             };
         };
     };
-    healthCheck: {
+    deleteToolset: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                /** @description Toolset instance UUID */
+                id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Application is healthy and fully operational */
-            200: {
+            /** @description Toolset deleted */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    /** @example {
-                     *       "message": "pong"
-                     *     } */
-                    "application/json": components["schemas"]["PingResponse"];
-                };
+                content?: never;
             };
             /** @description Invalid request parameters */
             400: {
@@ -6502,6 +6637,31 @@ export interface operations {
                     "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: {
@@ -6513,25 +6673,31 @@ export interface operations {
             };
         };
     };
-    pingServer: {
+    executeToolset: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                /** @description Toolset instance UUID */
+                id: string;
+                /** @description Tool method name */
+                method: string;
+            };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ExecuteToolsetRequest"];
+            };
+        };
         responses: {
-            /** @description Server is responding normally */
+            /** @description Tool execution result */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    /** @example {
-                     *       "message": "pong"
-                     *     } */
-                    "application/json": components["schemas"]["PingResponse"];
+                    "application/json": components["schemas"]["ToolsetExecutionResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6543,6 +6709,31 @@ export interface operations {
                     "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: {
@@ -6554,7 +6745,7 @@ export interface operations {
             };
         };
     };
-    list_all_toolsets_handler: {
+    getCurrentUser: {
         parameters: {
             query?: never;
             header?: never;
@@ -6563,13 +6754,13 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description List of all available toolsets with status */
+            /** @description User information (authenticated or not) */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ListToolsetsResponse"];
+                    "application/json": components["schemas"]["UserResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6610,26 +6801,21 @@ export interface operations {
             };
         };
     };
-    enable_app_toolset_handler: {
+    requestUserAccess: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                /** @description Toolset identifier */
-                toolset_id: string;
-            };
+            path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Toolset enabled for app instance */
-            200: {
+            /** @description Access request created successfully */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["AppToolsetConfigResponse"];
-                };
+                content?: never;
             };
             /** @description Invalid request parameters */
             400: {
@@ -6658,12 +6844,23 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Toolset not found */
-            404: {
+            /** @description Pending request already exists */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
+            };
+            /** @description User already has role */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
             };
             /** @description Internal server error */
             500: {
@@ -6676,25 +6873,22 @@ export interface operations {
             };
         };
     };
-    disable_app_toolset_handler: {
+    getUserAccessStatus: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                /** @description Toolset identifier */
-                toolset_id: string;
-            };
+            path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Toolset disabled for app instance */
+            /** @description Request status retrieved */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["AppToolsetConfigResponse"];
+                    "application/json": components["schemas"]["UserAccessStatusResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6724,12 +6918,14 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Toolset not found */
+            /** @description Request not found */
             404: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
             };
             /** @description Internal server error */
             500: {
@@ -6742,25 +6938,33 @@ export interface operations {
             };
         };
     };
-    get_toolset_config_handler: {
+    listUsers: {
         parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description Toolset identifier */
-                toolset_id: string;
+            query?: {
+                /**
+                 * @description Page number (1-based)
+                 * @example 1
+                 */
+                page?: number;
+                /**
+                 * @description Number of users per page
+                 * @example 10
+                 */
+                page_size?: number;
             };
+            header?: never;
+            path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Toolset configuration with app status */
+            /** @description Users retrieved successfully */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["EnhancedToolsetConfigResponse"];
+                    "application/json": components["schemas"]["UserListResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6790,13 +6994,6 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Toolset not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -6808,30 +7005,24 @@ export interface operations {
             };
         };
     };
-    update_toolset_config_handler: {
+    removeUser: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                /** @description Toolset identifier */
-                toolset_id: string;
+                /** @description User ID to remove */
+                user_id: string;
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["UpdateToolsetConfigRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description Updated toolset configuration */
+            /** @description User removed successfully */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["EnhancedToolsetConfigResponse"];
-                };
+                content?: never;
             };
             /** @description Invalid request parameters */
             400: {
@@ -6860,12 +7051,14 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Toolset not found */
+            /** @description User not found */
             404: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
             };
             /** @description Internal server error */
             500: {
@@ -6878,20 +7071,24 @@ export interface operations {
             };
         };
     };
-    delete_toolset_config_handler: {
+    changeUserRole: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                /** @description Toolset identifier */
-                toolset_id: string;
+                /** @description User ID to change role for */
+                user_id: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChangeRoleRequest"];
+            };
+        };
         responses: {
-            /** @description Toolset configuration deleted */
-            204: {
+            /** @description Role changed successfully */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -6924,12 +7121,14 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Toolset not found */
+            /** @description User not found */
             404: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
             };
             /** @description Internal server error */
             500: {
@@ -6942,31 +7141,25 @@ export interface operations {
             };
         };
     };
-    execute_toolset_handler: {
+    healthCheck: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                /** @description Toolset identifier */
-                toolset_id: string;
-                /** @description Tool method name (e.g., search, findSimilar, contents, answer) */
-                method: string;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["ExecuteToolsetRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description Toolset execution result */
+            /** @description Application is healthy and fully operational */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ToolsetExecutionResponse"];
+                    /** @example {
+                     *       "message": "pong"
+                     *     } */
+                    "application/json": components["schemas"]["PingResponse"];
                 };
             };
             /** @description Invalid request parameters */
@@ -6978,8 +7171,8 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Not authenticated */
-            401: {
+            /** @description Internal server error */
+            500: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -6987,21 +7180,37 @@ export interface operations {
                     "application/json": components["schemas"]["OpenAIApiError"];
                 };
             };
-            /** @description Insufficient permissions */
-            403: {
+        };
+    };
+    pingServer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Server is responding normally */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["OpenAIApiError"];
+                    /** @example {
+                     *       "message": "pong"
+                     *     } */
+                    "application/json": components["schemas"]["PingResponse"];
                 };
             };
-            /** @description Toolset or method not found */
-            404: {
+            /** @description Invalid request parameters */
+            400: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["OpenAIApiError"];
+                };
             };
             /** @description Internal server error */
             500: {