@iblai/iblai-api 2025.11.13-teams-bot-renovation-ai → 2025.11.13-teams-bot-renovation-3-ai

package/src/services/AiMentorService.ts

@@ -41,6 +41,7 @@ import type { LinkCourseResponse } from '../models/LinkCourseResponse';
 import type { LLMModelForTenant } from '../models/LLMModelForTenant';
 import type { LLMResponse } from '../models/LLMResponse';
 import type { MCPServer } from '../models/MCPServer';
+import type { MCPServerConnection } from '../models/MCPServerConnection';
 import type { MemoryComponentMemoryDetail } from '../models/MemoryComponentMemoryDetail';
 import type { MemoryComponentResponse } from '../models/MemoryComponentResponse';
 import type { MemoryProgress } from '../models/MemoryProgress';
@@ -83,6 +84,7 @@ import type { PaginatedEdxCourseList } from '../models/PaginatedEdxCourseList';
 import type { PaginatedEmailPromptListList } from '../models/PaginatedEmailPromptListList';
 import type { PaginatedHumanSupportTicketList } from '../models/PaginatedHumanSupportTicketList';
 import type { PaginatedJobRunList } from '../models/PaginatedJobRunList';
+import type { PaginatedMCPServerConnectionList } from '../models/PaginatedMCPServerConnectionList';
 import type { PaginatedMCPServerList } from '../models/PaginatedMCPServerList';
 import type { PaginatedMentorList } from '../models/PaginatedMentorList';
 import type { PaginatedModerationLogList } from '../models/PaginatedModerationLogList';
@@ -103,6 +105,7 @@ import type { PatchedCourseCreationTaskFile } from '../models/PatchedCourseCreat
 import type { PatchedDisclaimer } from '../models/PatchedDisclaimer';
 import type { PatchedHumanSupportTicket } from '../models/PatchedHumanSupportTicket';
 import type { PatchedMCPServer } from '../models/PatchedMCPServer';
+import type { PatchedMCPServerConnection } from '../models/PatchedMCPServerConnection';
 import type { PatchedMentorCategoryGroupCreate } from '../models/PatchedMentorCategoryGroupCreate';
 import type { PatchedMentorCreate } from '../models/PatchedMentorCreate';
 import type { PatchedPeriodicAgentCreate } from '../models/PatchedPeriodicAgentCreate';
@@ -6351,6 +6354,236 @@ export class AiMentorService {
                                                                                                                                                             },
                                                                                                                                                         });
                                                                                                                                                     }
+                                                                                                                                                    /**
+                                                                                                                                                     * ViewSet for MCP server connections.
+                                                                                                                                                     *
+                                                                                                                                                     * Tenant administrators can create user- or platform-scoped connections that
+                                                                                                                                                     * encapsulate the authentication configuration for invoking an MCP server.
+                                                                                                                                                     * @returns PaginatedMCPServerConnectionList
+                                                                                                                                                     * @throws ApiError
+                                                                                                                                                     */
+                                                                                                                                                    public static aiMentorOrgsUsersMcpServerConnectionsList({
+                                                                                                                                                        org,
+                                                                                                                                                        userId,
+                                                                                                                                                        authType,
+                                                                                                                                                        isActive,
+                                                                                                                                                        mentor,
+                                                                                                                                                        page,
+                                                                                                                                                        pageSize,
+                                                                                                                                                        scope,
+                                                                                                                                                        search,
+                                                                                                                                                        server,
+                                                                                                                                                        user,
+                                                                                                                                                    }: {
+                                                                                                                                                        org: string,
+                                                                                                                                                        userId: string,
+                                                                                                                                                        /**
+                                                                                                                                                         * * `none` - None
+                                                                                                                                                         * * `token` - Token
+                                                                                                                                                         * * `oauth2` - Oauth2
+                                                                                                                                                         */
+                                                                                                                                                        authType?: 'none' | 'oauth2' | 'token',
+                                                                                                                                                        isActive?: boolean,
+                                                                                                                                                        mentor?: string,
+                                                                                                                                                        /**
+                                                                                                                                                         * A page number within the paginated result set.
+                                                                                                                                                         */
+                                                                                                                                                        page?: number,
+                                                                                                                                                        /**
+                                                                                                                                                         * Number of results to return per page.
+                                                                                                                                                         */
+                                                                                                                                                        pageSize?: number,
+                                                                                                                                                        /**
+                                                                                                                                                         * Whether this connection is scoped to a user or shared across a platform.
+                                                                                                                                                         *
+                                                                                                                                                         * * `user` - User
+                                                                                                                                                         * * `mentor` - Mentor
+                                                                                                                                                         * * `platform` - Platform
+                                                                                                                                                         */
+                                                                                                                                                        scope?: 'mentor' | 'platform' | 'user',
+                                                                                                                                                        /**
+                                                                                                                                                         * A search term.
+                                                                                                                                                         */
+                                                                                                                                                        search?: string,
+                                                                                                                                                        server?: number,
+                                                                                                                                                        user?: string,
+                                                                                                                                                    }): CancelablePromise<PaginatedMCPServerConnectionList> {
+                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                            method: 'GET',
+                                                                                                                                                            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/mcp-server-connections/',
+                                                                                                                                                            path: {
+                                                                                                                                                                'org': org,
+                                                                                                                                                                'user_id': userId,
+                                                                                                                                                            },
+                                                                                                                                                            query: {
+                                                                                                                                                                'auth_type': authType,
+                                                                                                                                                                'is_active': isActive,
+                                                                                                                                                                'mentor': mentor,
+                                                                                                                                                                'page': page,
+                                                                                                                                                                'page_size': pageSize,
+                                                                                                                                                                'scope': scope,
+                                                                                                                                                                'search': search,
+                                                                                                                                                                'server': server,
+                                                                                                                                                                'user': user,
+                                                                                                                                                            },
+                                                                                                                                                        });
+                                                                                                                                                    }
+                                                                                                                                                    /**
+                                                                                                                                                     * ViewSet for MCP server connections.
+                                                                                                                                                     *
+                                                                                                                                                     * Tenant administrators can create user- or platform-scoped connections that
+                                                                                                                                                     * encapsulate the authentication configuration for invoking an MCP server.
+                                                                                                                                                     * @returns MCPServerConnection
+                                                                                                                                                     * @throws ApiError
+                                                                                                                                                     */
+                                                                                                                                                    public static aiMentorOrgsUsersMcpServerConnectionsCreate({
+                                                                                                                                                        org,
+                                                                                                                                                        userId,
+                                                                                                                                                        requestBody,
+                                                                                                                                                    }: {
+                                                                                                                                                        org: string,
+                                                                                                                                                        userId: string,
+                                                                                                                                                        requestBody: MCPServerConnection,
+                                                                                                                                                    }): CancelablePromise<MCPServerConnection> {
+                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                            method: 'POST',
+                                                                                                                                                            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/mcp-server-connections/',
+                                                                                                                                                            path: {
+                                                                                                                                                                'org': org,
+                                                                                                                                                                'user_id': userId,
+                                                                                                                                                            },
+                                                                                                                                                            body: requestBody,
+                                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                                        });
+                                                                                                                                                    }
+                                                                                                                                                    /**
+                                                                                                                                                     * ViewSet for MCP server connections.
+                                                                                                                                                     *
+                                                                                                                                                     * Tenant administrators can create user- or platform-scoped connections that
+                                                                                                                                                     * encapsulate the authentication configuration for invoking an MCP server.
+                                                                                                                                                     * @returns MCPServerConnection
+                                                                                                                                                     * @throws ApiError
+                                                                                                                                                     */
+                                                                                                                                                    public static aiMentorOrgsUsersMcpServerConnectionsRetrieve({
+                                                                                                                                                        id,
+                                                                                                                                                        org,
+                                                                                                                                                        userId,
+                                                                                                                                                    }: {
+                                                                                                                                                        /**
+                                                                                                                                                         * A unique integer value identifying this mcp server connection.
+                                                                                                                                                         */
+                                                                                                                                                        id: number,
+                                                                                                                                                        org: string,
+                                                                                                                                                        userId: string,
+                                                                                                                                                    }): CancelablePromise<MCPServerConnection> {
+                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                            method: 'GET',
+                                                                                                                                                            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/mcp-server-connections/{id}/',
+                                                                                                                                                            path: {
+                                                                                                                                                                'id': id,
+                                                                                                                                                                'org': org,
+                                                                                                                                                                'user_id': userId,
+                                                                                                                                                            },
+                                                                                                                                                        });
+                                                                                                                                                    }
+                                                                                                                                                    /**
+                                                                                                                                                     * ViewSet for MCP server connections.
+                                                                                                                                                     *
+                                                                                                                                                     * Tenant administrators can create user- or platform-scoped connections that
+                                                                                                                                                     * encapsulate the authentication configuration for invoking an MCP server.
+                                                                                                                                                     * @returns MCPServerConnection
+                                                                                                                                                     * @throws ApiError
+                                                                                                                                                     */
+                                                                                                                                                    public static aiMentorOrgsUsersMcpServerConnectionsUpdate({
+                                                                                                                                                        id,
+                                                                                                                                                        org,
+                                                                                                                                                        userId,
+                                                                                                                                                        requestBody,
+                                                                                                                                                    }: {
+                                                                                                                                                        /**
+                                                                                                                                                         * A unique integer value identifying this mcp server connection.
+                                                                                                                                                         */
+                                                                                                                                                        id: number,
+                                                                                                                                                        org: string,
+                                                                                                                                                        userId: string,
+                                                                                                                                                        requestBody: MCPServerConnection,
+                                                                                                                                                    }): CancelablePromise<MCPServerConnection> {
+                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                            method: 'PUT',
+                                                                                                                                                            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/mcp-server-connections/{id}/',
+                                                                                                                                                            path: {
+                                                                                                                                                                'id': id,
+                                                                                                                                                                'org': org,
+                                                                                                                                                                'user_id': userId,
+                                                                                                                                                            },
+                                                                                                                                                            body: requestBody,
+                                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                                        });
+                                                                                                                                                    }
+                                                                                                                                                    /**
+                                                                                                                                                     * ViewSet for MCP server connections.
+                                                                                                                                                     *
+                                                                                                                                                     * Tenant administrators can create user- or platform-scoped connections that
+                                                                                                                                                     * encapsulate the authentication configuration for invoking an MCP server.
+                                                                                                                                                     * @returns MCPServerConnection
+                                                                                                                                                     * @throws ApiError
+                                                                                                                                                     */
+                                                                                                                                                    public static aiMentorOrgsUsersMcpServerConnectionsPartialUpdate({
+                                                                                                                                                        id,
+                                                                                                                                                        org,
+                                                                                                                                                        userId,
+                                                                                                                                                        requestBody,
+                                                                                                                                                    }: {
+                                                                                                                                                        /**
+                                                                                                                                                         * A unique integer value identifying this mcp server connection.
+                                                                                                                                                         */
+                                                                                                                                                        id: number,
+                                                                                                                                                        org: string,
+                                                                                                                                                        userId: string,
+                                                                                                                                                        requestBody?: PatchedMCPServerConnection,
+                                                                                                                                                    }): CancelablePromise<MCPServerConnection> {
+                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                            method: 'PATCH',
+                                                                                                                                                            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/mcp-server-connections/{id}/',
+                                                                                                                                                            path: {
+                                                                                                                                                                'id': id,
+                                                                                                                                                                'org': org,
+                                                                                                                                                                'user_id': userId,
+                                                                                                                                                            },
+                                                                                                                                                            body: requestBody,
+                                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                                        });
+                                                                                                                                                    }
+                                                                                                                                                    /**
+                                                                                                                                                     * ViewSet for MCP server connections.
+                                                                                                                                                     *
+                                                                                                                                                     * Tenant administrators can create user- or platform-scoped connections that
+                                                                                                                                                     * encapsulate the authentication configuration for invoking an MCP server.
+                                                                                                                                                     * @returns void
+                                                                                                                                                     * @throws ApiError
+                                                                                                                                                     */
+                                                                                                                                                    public static aiMentorOrgsUsersMcpServerConnectionsDestroy({
+                                                                                                                                                        id,
+                                                                                                                                                        org,
+                                                                                                                                                        userId,
+                                                                                                                                                    }: {
+                                                                                                                                                        /**
+                                                                                                                                                         * A unique integer value identifying this mcp server connection.
+                                                                                                                                                         */
+                                                                                                                                                        id: number,
+                                                                                                                                                        org: string,
+                                                                                                                                                        userId: string,
+                                                                                                                                                    }): CancelablePromise<void> {
+                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                            method: 'DELETE',
+                                                                                                                                                            url: '/api/ai-mentor/orgs/{org}/users/{user_id}/mcp-server-connections/{id}/',
+                                                                                                                                                            path: {
+                                                                                                                                                                'id': id,
+                                                                                                                                                                'org': org,
+                                                                                                                                                                'user_id': userId,
+                                                                                                                                                            },
+                                                                                                                                                        });
+                                                                                                                                                    }
                                                                                                                                                     /**
                                                                                                                                                      * List all MCP servers.
                                                                                                                                                      *

package/dist/types/models/ConnectedServiceProviderEnum.d.ts

@@ -1,6 +0,0 @@
-/**
- * * `google` - Google
- */
-export declare enum ConnectedServiceProviderEnum {
-    GOOGLE = "google"
-}

package/dist/types/models/ServiceEnum.d.ts

@@ -1,12 +0,0 @@
-/**
- * * `google_drive` - Google Drive
- * * `google_document` - Google Document
- * * `google_slides` - Google Slides
- * * `google_calendar` - Google Calendar
- */
-export declare enum ServiceEnum {
-    GOOGLE_DRIVE = "google_drive",
-    GOOGLE_DOCUMENT = "google_document",
-    GOOGLE_SLIDES = "google_slides",
-    GOOGLE_CALENDAR = "google_calendar"
-}

package/src/models/ConnectedServiceProviderEnum.ts

@@ -1,10 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-/**
- * * `google` - Google
- */
-export enum ConnectedServiceProviderEnum {
-    GOOGLE = 'google',
-}

package/src/models/ServiceEnum.ts

@@ -1,16 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-/**
- * * `google_drive` - Google Drive
- * * `google_document` - Google Document
- * * `google_slides` - Google Slides
- * * `google_calendar` - Google Calendar
- */
-export enum ServiceEnum {
-    GOOGLE_DRIVE = 'google_drive',
-    GOOGLE_DOCUMENT = 'google_document',
-    GOOGLE_SLIDES = 'google_slides',
-    GOOGLE_CALENDAR = 'google_calendar',
-}