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

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

@@ -1,15 +0,0 @@
-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 "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,71 +0,0 @@
-
-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 '../../services/extensions/common/extHostCustomers.js';
-import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { NotebookDto } from './mainThreadNotebookDto.js';
-
-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

@@ -1,16 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,95 +0,0 @@
-
-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 '../../services/extensions/common/extHostCustomers.js';
-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

@@ -1,22 +0,0 @@
-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 "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,286 +0,0 @@
-
-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 '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
-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 '../../services/extensions/common/extHostCustomers.js';
-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

@@ -1,10 +0,0 @@
-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 "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,38 +0,0 @@
-
-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 '../../services/extensions/common/extHostCustomers.js';
-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

@@ -1,9 +0,0 @@
-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 "../../services/extensions/common/extHostCustomers.js";
-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

@@ -1,22 +0,0 @@
-
-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 '../../services/extensions/common/extHostCustomers.js';
-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 };