@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/workbench/api/browser/mainThreadChatCodeMapper.d.ts

@@ -0,0 +1,15 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeMapperService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { ICodeMapperProgressDto, MainThreadCodeMapperShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatCodemapper extends Disposable implements MainThreadCodeMapperShape {
+    private readonly codeMapperService;
+    private providers;
+    private readonly _proxy;
+    private static _requestHandlePool;
+    private _responseMap;
+    constructor(extHostContext: IExtHostContext, codeMapperService: ICodeMapperService);
+    $registerCodeMapperProvider(handle: number, displayName: string): void;
+    $unregisterCodeMapperProvider(handle: number): void;
+    $handleProgress(requestId: string, data: ICodeMapperProgressDto): Promise<void>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadChatCodeMapper.js

@@ -0,0 +1,71 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ICodeMapperService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { NotebookDto } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+
+var MainThreadChatCodemapper_1;
+let MainThreadChatCodemapper = class MainThreadChatCodemapper extends Disposable {
+    static {
+        MainThreadChatCodemapper_1 = this;
+    }
+    static {
+        this._requestHandlePool = 0;
+    }
+    constructor(extHostContext, codeMapperService) {
+        super();
+        this.codeMapperService = codeMapperService;
+        this.providers = this._register(( new DisposableMap()));
+        this._responseMap = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostCodeMapper));
+    }
+    $registerCodeMapperProvider(handle, displayName) {
+        const impl = {
+            displayName,
+            mapCode: async (uiRequest, response, token) => {
+                const requestId = String(MainThreadChatCodemapper_1._requestHandlePool++);
+                this._responseMap.set(requestId, response);
+                const extHostRequest = {
+                    requestId,
+                    codeBlocks: uiRequest.codeBlocks,
+                    chatRequestId: uiRequest.chatRequestId,
+                    chatRequestModel: uiRequest.chatRequestModel,
+                    chatSessionResource: uiRequest.chatSessionResource,
+                    location: uiRequest.location
+                };
+                try {
+                    return await this._proxy.$mapCode(handle, extHostRequest, token).then(result => result ?? undefined);
+                } finally {
+                    this._responseMap.delete(requestId);
+                }
+            }
+        };
+        const disposable = this.codeMapperService.registerCodeMapperProvider(handle, impl);
+        this.providers.set(handle, disposable);
+    }
+    $unregisterCodeMapperProvider(handle) {
+        this.providers.deleteAndDispose(handle);
+    }
+    $handleProgress(requestId, data) {
+        const response = this._responseMap.get(requestId);
+        if (response) {
+            const edits = data.edits;
+            const resource = URI.revive(data.uri);
+            if (!edits.length) {
+                response.textEdit(resource, []);
+            } else if (edits.every(TextEdit.isTextEdit)) {
+                response.textEdit(resource, edits);
+            } else {
+                response.notebookEdit(resource, edits.map(NotebookDto.fromCellEditOperationDto));
+            }
+        }
+        return Promise.resolve();
+    }
+};
+MainThreadChatCodemapper = MainThreadChatCodemapper_1 = __decorate([extHostNamedCustomer(MainContext.MainThreadCodeMapper), ( __param(1, ICodeMapperService))], MainThreadChatCodemapper);
+
+export { MainThreadChatCodemapper };

package/vscode/src/vs/workbench/api/browser/mainThreadChatContext.d.ts

@@ -0,0 +1,16 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { IChatContextItemDto, ITabSelectorDto, MainThreadChatContextShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IChatContextService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.service";
+export declare class MainThreadChatContext extends Disposable implements MainThreadChatContextShape {
+    private readonly _chatContextService;
+    private readonly _proxy;
+    private readonly _providers;
+    constructor(extHostContext: IExtHostContext, _chatContextService: IChatContextService);
+    $registerChatWorkspaceContextProvider(handle: number, id: string): void;
+    $registerChatExplicitContextProvider(handle: number, id: string): void;
+    $registerChatResourceContextProvider(handle: number, id: string, selector: ITabSelectorDto): void;
+    $unregisterChatContextProvider(handle: number): void;
+    $updateWorkspaceContextItems(handle: number, items: IChatContextItemDto[]): void;
+    $executeChatContextItemCommand(itemHandle: number): Promise<void>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadChatContext.js

@@ -0,0 +1,95 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatContextService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IconPath } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHostTypeConverters';
+
+function reviveContextItem(item) {
+    return {
+        ...item,
+        iconPath: IconPath.to(item.iconPath),
+        resourceUri: item.resourceUri ? URI.revive(item.resourceUri) : undefined
+    };
+}
+function reviveContextItems(items) {
+    return items.map(reviveContextItem);
+}
+let MainThreadChatContext = class MainThreadChatContext extends Disposable {
+    constructor(extHostContext, _chatContextService) {
+        super();
+        this._chatContextService = _chatContextService;
+        this._providers = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatContext));
+        this._chatContextService.setExecuteCommandCallback(itemHandle => this._proxy.$executeChatContextItemCommand(itemHandle));
+    }
+    $registerChatWorkspaceContextProvider(handle, id) {
+        this._providers.set(handle, {
+            id
+        });
+        this._chatContextService.registerChatWorkspaceContextProvider(id, {
+            provideWorkspaceChatContext: async token => {
+                const items = await this._proxy.$provideWorkspaceChatContext(handle, token);
+                return reviveContextItems(items);
+            }
+        });
+    }
+    $registerChatExplicitContextProvider(handle, id) {
+        this._providers.set(handle, {
+            id
+        });
+        this._chatContextService.registerChatExplicitContextProvider(id, {
+            provideChatContext: async token => {
+                const items = await this._proxy.$provideExplicitChatContext(handle, token);
+                return reviveContextItems(items);
+            },
+            resolveChatContext: async (context, token) => {
+                const result = await this._proxy.$resolveExplicitChatContext(handle, context, token);
+                return reviveContextItem(result);
+            }
+        });
+    }
+    $registerChatResourceContextProvider(handle, id, selector) {
+        this._providers.set(handle, {
+            id,
+            selector
+        });
+        this._chatContextService.registerChatResourceContextProvider(id, selector, {
+            provideChatContext: async (resource, withValue, viewType, token) => {
+                const result = await this._proxy.$provideResourceChatContext(handle, {
+                    resource,
+                    withValue,
+                    viewType
+                }, token);
+                return result ? reviveContextItem(result) : undefined;
+            },
+            resolveChatContext: async (context, token) => {
+                const result = await this._proxy.$resolveResourceChatContext(handle, context, token);
+                return reviveContextItem(result);
+            }
+        });
+    }
+    $unregisterChatContextProvider(handle) {
+        const provider = this._providers.get(handle);
+        if (!provider) {
+            return;
+        }
+        this._chatContextService.unregisterChatContextProvider(provider.id);
+        this._providers.delete(handle);
+    }
+    $updateWorkspaceContextItems(handle, items) {
+        const provider = this._providers.get(handle);
+        if (!provider) {
+            return;
+        }
+        this._chatContextService.updateWorkspaceContextItems(provider.id, reviveContextItems(items));
+    }
+    $executeChatContextItemCommand(itemHandle) {
+        return this._proxy.$executeChatContextItemCommand(itemHandle);
+    }
+};
+MainThreadChatContext = __decorate([extHostNamedCustomer(MainContext.MainThreadChatContext), ( __param(1, IChatContextService))], MainThreadChatContext);
+
+export { MainThreadChatContext };

package/vscode/src/vs/workbench/api/browser/mainThreadChatDebug.d.ts

@@ -0,0 +1,22 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { IChatDebugEventDto, MainThreadChatDebugShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatDebug extends Disposable implements MainThreadChatDebugShape {
+    private readonly _chatDebugService;
+    private readonly _chatService;
+    private readonly _proxy;
+    private readonly _providerDisposables;
+    private readonly _activeSessionResources;
+    private readonly _coreEventForwarder;
+    constructor(extHostContext: IExtHostContext, _chatDebugService: IChatDebugService, _chatService: IChatService);
+    $subscribeToCoreDebugEvents(): void;
+    $unsubscribeFromCoreDebugEvents(): void;
+    $registerChatDebugLogProvider(handle: number): void;
+    $unregisterChatDebugLogProvider(handle: number): void;
+    $acceptChatDebugEvent(handle: number, dto: IChatDebugEventDto): void;
+    private _serializeEvent;
+    private _reviveEvent;
+    private _reviveResolvedContent;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadChatDebug.js

@@ -0,0 +1,286 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { ChatDebugHookResult } from '../../contrib/chat/common/chatDebugService.js';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
+    constructor(extHostContext, _chatDebugService, _chatService) {
+        super();
+        this._chatDebugService = _chatDebugService;
+        this._chatService = _chatService;
+        this._providerDisposables = ( new Map());
+        this._activeSessionResources = ( new Map());
+        this._coreEventForwarder = this._register(( new MutableDisposable()));
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatDebug));
+    }
+    $subscribeToCoreDebugEvents() {
+        this._coreEventForwarder.value = this._chatDebugService.onDidAddEvent(event => {
+            if (this._chatDebugService.isCoreEvent(event)) {
+                this._proxy.$onCoreDebugEvent(this._serializeEvent(event));
+            }
+        });
+    }
+    $unsubscribeFromCoreDebugEvents() {
+        this._coreEventForwarder.clear();
+    }
+    $registerChatDebugLogProvider(handle) {
+        const disposables = ( new DisposableStore());
+        this._providerDisposables.set(handle, disposables);
+        disposables.add(this._chatDebugService.registerProvider({
+            provideChatDebugLog: async (sessionResource, token) => {
+                this._activeSessionResources.set(handle, sessionResource);
+                const dtos = await this._proxy.$provideChatDebugLog(handle, sessionResource, token);
+                return dtos?.map(dto => this._reviveEvent(dto, sessionResource));
+            },
+            resolveChatDebugLogEvent: async (eventId, token) => {
+                const dto = await this._proxy.$resolveChatDebugLogEvent(handle, eventId, token);
+                return dto ? this._reviveResolvedContent(dto) : undefined;
+            },
+            provideChatDebugLogExport: async (sessionResource, token) => {
+                const coreEventDtos = this._chatDebugService.getEvents(sessionResource).filter(e => this._chatDebugService.isCoreEvent(e)).map(e => this._serializeEvent(e));
+                const sessionTitle = this._chatService.getSessionTitle(sessionResource);
+                const result = await this._proxy.$exportChatDebugLog(handle, sessionResource, coreEventDtos, sessionTitle, token);
+                return result?.buffer;
+            },
+            resolveChatDebugLogImport: async (data, token) => {
+                const result = await this._proxy.$importChatDebugLog(handle, VSBuffer.wrap(data), token);
+                if (!result) {
+                    return undefined;
+                }
+                const uri = URI.revive(result.uri);
+                if (result.sessionTitle) {
+                    this._chatDebugService.setImportedSessionTitle(uri, result.sessionTitle);
+                }
+                return uri;
+            }
+        }));
+        disposables.add(this._chatDebugService.registerAvailableSessionsFetcher(async token => {
+            const entries = await this._proxy.$getAvailableDebugSessionResources(handle, token);
+            return entries.map(e => ({
+                uri: URI.revive(e.uri),
+                title: e.title
+            }));
+        }));
+    }
+    $unregisterChatDebugLogProvider(handle) {
+        const disposables = this._providerDisposables.get(handle);
+        disposables?.dispose();
+        this._providerDisposables.delete(handle);
+        this._activeSessionResources.delete(handle);
+    }
+    $acceptChatDebugEvent(handle, dto) {
+        const sessionResource = (dto.sessionResource ? URI.revive(dto.sessionResource) : undefined) ?? this._activeSessionResources.get(handle) ?? this._chatDebugService.activeSessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        const revived = this._reviveEvent(dto, sessionResource);
+        this._chatDebugService.addProviderEvent(revived);
+    }
+    _serializeEvent(event) {
+        const base = {
+            id: event.id,
+            sessionResource: event.sessionResource,
+            created: event.created.getTime(),
+            parentEventId: event.parentEventId
+        };
+        switch (event.kind) {
+        case "toolCall":
+            return {
+                ...base,
+                kind: "toolCall",
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                input: event.input,
+                output: event.output,
+                result: event.result,
+                durationInMillis: event.durationInMillis
+            };
+        case "modelTurn":
+            return {
+                ...base,
+                kind: "modelTurn",
+                model: event.model,
+                requestName: event.requestName,
+                inputTokens: event.inputTokens,
+                outputTokens: event.outputTokens,
+                cachedTokens: event.cachedTokens,
+                totalTokens: event.totalTokens,
+                copilotUsageNanoAiu: event.copilotUsageNanoAiu,
+                durationInMillis: event.durationInMillis
+            };
+        case "generic":
+            return {
+                ...base,
+                kind: "generic",
+                name: event.name,
+                details: event.details,
+                level: event.level,
+                category: event.category
+            };
+        case "subagentInvocation":
+            return {
+                ...base,
+                kind: "subagentInvocation",
+                agentName: event.agentName,
+                description: event.description,
+                status: event.status,
+                durationInMillis: event.durationInMillis,
+                toolCallCount: event.toolCallCount,
+                modelTurnCount: event.modelTurnCount
+            };
+        case "userMessage":
+            return {
+                ...base,
+                kind: "userMessage",
+                message: event.message,
+                sections: event.sections.map(s => ({
+                    name: s.name,
+                    content: s.content
+                }))
+            };
+        case "agentResponse":
+            return {
+                ...base,
+                kind: "agentResponse",
+                message: event.message,
+                sections: event.sections.map(s => ({
+                    name: s.name,
+                    content: s.content
+                }))
+            };
+        }
+    }
+    _reviveEvent(dto, sessionResource) {
+        const base = {
+            id: dto.id,
+            sessionResource,
+            created: ( new Date(dto.created)),
+            parentEventId: dto.parentEventId
+        };
+        switch (dto.kind) {
+        case "toolCall":
+            return {
+                ...base,
+                kind: "toolCall",
+                toolName: dto.toolName,
+                toolCallId: dto.toolCallId,
+                input: dto.input,
+                output: dto.output,
+                result: dto.result,
+                durationInMillis: dto.durationInMillis
+            };
+        case "modelTurn":
+            return {
+                ...base,
+                kind: "modelTurn",
+                model: dto.model,
+                requestName: dto.requestName,
+                inputTokens: dto.inputTokens,
+                outputTokens: dto.outputTokens,
+                cachedTokens: dto.cachedTokens,
+                totalTokens: dto.totalTokens,
+                copilotUsageNanoAiu: dto.copilotUsageNanoAiu,
+                durationInMillis: dto.durationInMillis
+            };
+        case "generic":
+            return {
+                ...base,
+                kind: "generic",
+                name: dto.name,
+                details: dto.details,
+                level: dto.level,
+                category: dto.category
+            };
+        case "subagentInvocation":
+            return {
+                ...base,
+                kind: "subagentInvocation",
+                agentName: dto.agentName,
+                description: dto.description,
+                status: dto.status,
+                durationInMillis: dto.durationInMillis,
+                toolCallCount: dto.toolCallCount,
+                modelTurnCount: dto.modelTurnCount
+            };
+        case "userMessage":
+            return {
+                ...base,
+                kind: "userMessage",
+                message: dto.message,
+                sections: dto.sections
+            };
+        case "agentResponse":
+            return {
+                ...base,
+                kind: "agentResponse",
+                message: dto.message,
+                sections: dto.sections
+            };
+        }
+    }
+    _reviveResolvedContent(dto) {
+        switch (dto.kind) {
+        case "text":
+            return {
+                kind: "text",
+                value: dto.value
+            };
+        case "message":
+            return {
+                kind: "message",
+                type: dto.type,
+                message: dto.message,
+                sections: dto.sections
+            };
+        case "toolCall":
+            return {
+                kind: "toolCall",
+                toolName: dto.toolName,
+                result: dto.result,
+                durationInMillis: dto.durationInMillis,
+                input: dto.input,
+                output: dto.output
+            };
+        case "modelTurn":
+            return {
+                kind: "modelTurn",
+                requestName: dto.requestName,
+                model: dto.model,
+                status: dto.status,
+                durationInMillis: dto.durationInMillis,
+                timeToFirstTokenInMillis: dto.timeToFirstTokenInMillis,
+                requestId: dto.requestId,
+                maxInputTokens: dto.maxInputTokens,
+                maxOutputTokens: dto.maxOutputTokens,
+                inputTokens: dto.inputTokens,
+                outputTokens: dto.outputTokens,
+                cachedTokens: dto.cachedTokens,
+                totalTokens: dto.totalTokens,
+                requestOptions: dto.requestOptions,
+                errorMessage: dto.errorMessage,
+                sections: dto.sections
+            };
+        case "hook":
+            return {
+                kind: "hook",
+                hookType: dto.hookType,
+                command: dto.command,
+                result: dto.result === "success" ? ChatDebugHookResult.Success : dto.result === "error" ? ChatDebugHookResult.Error : dto.result === "nonBlockingError" ? ChatDebugHookResult.NonBlockingError : undefined,
+                durationInMillis: dto.durationInMillis,
+                input: dto.input,
+                output: dto.output,
+                exitCode: dto.exitCode,
+                errorMessage: dto.errorMessage
+            };
+        }
+    }
+};
+MainThreadChatDebug = __decorate([extHostNamedCustomer(MainContext.MainThreadChatDebug), ( __param(1, IChatDebugService)), ( __param(2, IChatService))], MainThreadChatDebug);
+
+export { MainThreadChatDebug };

package/vscode/src/vs/workbench/api/browser/mainThreadChatInputNotification.d.ts

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { ChatInputNotificationDto, MainThreadChatInputNotificationShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatInputNotification extends Disposable implements MainThreadChatInputNotificationShape {
+    private readonly _chatInputNotificationService;
+    constructor(_extHostContext: IExtHostContext, _chatInputNotificationService: IChatInputNotificationService);
+    $setNotification(notification: ChatInputNotificationDto): void;
+    $disposeNotification(id: string): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadChatInputNotification.js

@@ -0,0 +1,38 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ChatInputNotificationActionKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadChatInputNotification = class MainThreadChatInputNotification extends Disposable {
+    constructor(_extHostContext, _chatInputNotificationService) {
+        super();
+        this._chatInputNotificationService = _chatInputNotificationService;
+    }
+    $setNotification(notification) {
+        this._chatInputNotificationService.setNotification({
+            id: notification.id,
+            severity: notification.severity,
+            message: notification.message,
+            description: notification.description,
+            actions: notification.actions.map(action => ({
+                ...action,
+                kind: ChatInputNotificationActionKind.Command
+            })),
+            dismissible: notification.dismissible,
+            autoDismissOnMessage: notification.autoDismissOnMessage,
+            sessionTypes: notification.sessionTypes
+        });
+    }
+    $disposeNotification(id) {
+        this._chatInputNotificationService.deleteNotification(id);
+    }
+};
+MainThreadChatInputNotification = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatInputNotification),
+    ( __param(1, IChatInputNotificationService))
+], MainThreadChatInputNotification);
+
+export { MainThreadChatInputNotification };

package/vscode/src/vs/workbench/api/browser/mainThreadChatQuota.d.ts

@@ -0,0 +1,9 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { IQuotaSnapshotsDto, MainThreadChatQuotaShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatQuota extends Disposable implements MainThreadChatQuotaShape {
+    private readonly _chatEntitlementService;
+    constructor(extHostContext: IExtHostContext, _chatEntitlementService: IChatEntitlementService);
+    $updateQuotas(quotas: IQuotaSnapshotsDto): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadChatQuota.js

@@ -0,0 +1,22 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadChatQuota = class MainThreadChatQuota extends Disposable {
+    constructor(extHostContext, _chatEntitlementService) {
+        super();
+        this._chatEntitlementService = _chatEntitlementService;
+    }
+    $updateQuotas(quotas) {
+        this._chatEntitlementService.acceptQuotas({
+            ...this._chatEntitlementService.quotas,
+            ...quotas
+        });
+    }
+};
+MainThreadChatQuota = __decorate([extHostNamedCustomer(MainContext.MainThreadChatQuota), ( __param(1, IChatEntitlementService))], MainThreadChatQuota);
+
+export { MainThreadChatQuota };