@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

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

@@ -0,0 +1,330 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { getAuthenticationProviderActivationEvent, addAccountUsage, readAllowedExtensions, readAccountUsages, removeAccountUsage } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { fromNow } from 'vscode/vscode/vs/base/common/date';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+class MainThreadAuthenticationProvider extends Disposable {
+    constructor(_proxy, id, label, supportsMultipleAccounts, notificationService, storageService, quickInputService, dialogService) {
+        super();
+        this._proxy = _proxy;
+        this.id = id;
+        this.label = label;
+        this.supportsMultipleAccounts = supportsMultipleAccounts;
+        this.notificationService = notificationService;
+        this.storageService = storageService;
+        this.quickInputService = quickInputService;
+        this.dialogService = dialogService;
+    }
+    manageTrustedExtensions(accountName) {
+        const allowedExtensions = readAllowedExtensions(this.storageService, this.id, accountName);
+        if (!allowedExtensions.length) {
+            this.dialogService.info(( nls.localizeWithPath(
+                'vs/workbench/api/browser/mainThreadAuthentication',
+                'noTrustedExtensions',
+                "This account has not been used by any extensions."
+            )));
+            return;
+        }
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.canSelectMany = true;
+        quickPick.customButton = true;
+        quickPick.customLabel = ( nls.localizeWithPath(
+            'vs/workbench/api/browser/mainThreadAuthentication',
+            'manageTrustedExtensions.cancel',
+            'Cancel'
+        ));
+        const usages = readAccountUsages(this.storageService, this.id, accountName);
+        const items = ( allowedExtensions.map(extension => {
+            const usage = usages.find(usage => extension.id === usage.extensionId);
+            return {
+                label: extension.name,
+                description: usage
+                    ? ( nls.localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadAuthentication',
+                    { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] },
+                    "Last used this account {0}",
+                    fromNow(usage.lastUsed, true)
+                ))
+                    : ( nls.localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadAuthentication',
+                    'notUsed',
+                    "Has not used this account"
+                )),
+                extension
+            };
+        }));
+        quickPick.items = items;
+        quickPick.selectedItems = items.filter(item => item.extension.allowed === undefined || item.extension.allowed);
+        quickPick.title = ( nls.localizeWithPath(
+            'vs/workbench/api/browser/mainThreadAuthentication',
+            'manageTrustedExtensions',
+            "Manage Trusted Extensions"
+        ));
+        quickPick.placeholder = ( nls.localizeWithPath(
+            'vs/workbench/api/browser/mainThreadAuthentication',
+            'manageExtensions',
+            "Choose which extensions can access this account"
+        ));
+        quickPick.onDidAccept(() => {
+            const updatedAllowedList = ( quickPick.items
+                .map(i => i.extension));
+            this.storageService.store(`${this.id}-${accountName}`, JSON.stringify(updatedAllowedList), -1 , 0 );
+            quickPick.dispose();
+        });
+        quickPick.onDidChangeSelection((changed) => {
+            quickPick.items.forEach(item => {
+                if (item.extension) {
+                    item.extension.allowed = false;
+                }
+            });
+            changed.forEach((item) => item.extension.allowed = true);
+        });
+        quickPick.onDidHide(() => {
+            quickPick.dispose();
+        });
+        quickPick.onDidCustom(() => {
+            quickPick.hide();
+        });
+        quickPick.show();
+    }
+    async removeAccountSessions(accountName, sessions) {
+        const accountUsages = readAccountUsages(this.storageService, this.id, accountName);
+        const { confirmed } = await this.dialogService.confirm({
+            type: Severity.Info,
+            message: accountUsages.length
+                ? ( nls.localizeWithPath(
+                'vs/workbench/api/browser/mainThreadAuthentication',
+                'signOutMessage',
+                "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?",
+                accountName,
+                ( accountUsages.map(usage => usage.extensionName)).join('\n')
+            ))
+                : ( nls.localizeWithPath(
+                'vs/workbench/api/browser/mainThreadAuthentication',
+                'signOutMessageSimple',
+                "Sign out of '{0}'?",
+                accountName
+            )),
+            primaryButton: ( nls.localizeWithPath(
+                'vs/workbench/api/browser/mainThreadAuthentication',
+                { key: 'signOut', comment: ['&& denotes a mnemonic'] },
+                "&&Sign Out"
+            ))
+        });
+        if (confirmed) {
+            const removeSessionPromises = ( sessions.map(session => this.removeSession(session.id)));
+            await Promise.all(removeSessionPromises);
+            removeAccountUsage(this.storageService, this.id, accountName);
+            this.storageService.remove(`${this.id}-${accountName}`, -1 );
+        }
+    }
+    async getSessions(scopes) {
+        return this._proxy.$getSessions(this.id, scopes);
+    }
+    createSession(scopes, options) {
+        return this._proxy.$createSession(this.id, scopes, options);
+    }
+    async removeSession(sessionId) {
+        await this._proxy.$removeSession(this.id, sessionId);
+        this.notificationService.info(( nls.localizeWithPath(
+            'vs/workbench/api/browser/mainThreadAuthentication',
+            'signedOut',
+            "Successfully signed out."
+        )));
+    }
+}
+let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
+    constructor(extHostContext, authenticationService, dialogService, storageService, notificationService, quickInputService, extensionService, telemetryService) {
+        super();
+        this.authenticationService = authenticationService;
+        this.dialogService = dialogService;
+        this.storageService = storageService;
+        this.notificationService = notificationService;
+        this.quickInputService = quickInputService;
+        this.extensionService = extensionService;
+        this.telemetryService = telemetryService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostAuthentication));
+        this._register(this.authenticationService.onDidChangeSessions(e => {
+            this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label);
+        }));
+        this._proxy.$setProviders(this.authenticationService.declaredProviders);
+        this._register(this.authenticationService.onDidChangeDeclaredProviders(e => {
+            this._proxy.$setProviders(e);
+        }));
+    }
+    async $registerAuthenticationProvider(id, label, supportsMultipleAccounts) {
+        const provider = ( new MainThreadAuthenticationProvider(
+            this._proxy,
+            id,
+            label,
+            supportsMultipleAccounts,
+            this.notificationService,
+            this.storageService,
+            this.quickInputService,
+            this.dialogService
+        ));
+        this.authenticationService.registerAuthenticationProvider(id, provider);
+    }
+    $unregisterAuthenticationProvider(id) {
+        this.authenticationService.unregisterAuthenticationProvider(id);
+    }
+    $ensureProvider(id) {
+        return this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(id), 1 );
+    }
+    $sendDidChangeSessions(id, event) {
+        this.authenticationService.sessionsUpdate(id, event);
+    }
+    $removeSession(providerId, sessionId) {
+        return this.authenticationService.removeSession(providerId, sessionId);
+    }
+    async loginPrompt(providerName, extensionName, recreatingSession, detail) {
+        const message = recreatingSession
+            ? ( nls.localizeWithPath(
+            'vs/workbench/api/browser/mainThreadAuthentication',
+            'confirmRelogin',
+            "The extension '{0}' wants you to sign in again using {1}.",
+            extensionName,
+            providerName
+        ))
+            : ( nls.localizeWithPath(
+            'vs/workbench/api/browser/mainThreadAuthentication',
+            'confirmLogin',
+            "The extension '{0}' wants to sign in using {1}.",
+            extensionName,
+            providerName
+        ));
+        const { confirmed } = await this.dialogService.confirm({
+            type: Severity.Info,
+            message,
+            detail,
+            primaryButton: ( nls.localizeWithPath(
+                'vs/workbench/api/browser/mainThreadAuthentication',
+                { key: 'allow', comment: ['&& denotes a mnemonic'] },
+                "&&Allow"
+            ))
+        });
+        return confirmed;
+    }
+    async doGetSession(providerId, scopes, extensionId, extensionName, options) {
+        const sessions = await this.authenticationService.getSessions(providerId, scopes, true);
+        const supportsMultipleAccounts = this.authenticationService.supportsMultipleAccounts(providerId);
+        if (options.forceNewSession && options.createIfNone) {
+            throw new Error('Invalid combination of options. Please remove one of the following: forceNewSession, createIfNone');
+        }
+        if (options.forceNewSession && options.silent) {
+            throw new Error('Invalid combination of options. Please remove one of the following: forceNewSession, silent');
+        }
+        if (options.createIfNone && options.silent) {
+            throw new Error('Invalid combination of options. Please remove one of the following: createIfNone, silent');
+        }
+        if (!options.forceNewSession && sessions.length) {
+            if (supportsMultipleAccounts) {
+                if (options.clearSessionPreference) {
+                    this.authenticationService.removeSessionPreference(providerId, extensionId, scopes);
+                }
+                else {
+                    const existingSessionPreference = this.authenticationService.getSessionPreference(providerId, extensionId, scopes);
+                    if (existingSessionPreference) {
+                        const matchingSession = sessions.find(session => session.id === existingSessionPreference);
+                        if (matchingSession && this.authenticationService.isAccessAllowed(providerId, matchingSession.account.label, extensionId)) {
+                            return matchingSession;
+                        }
+                    }
+                }
+            }
+            else if (this.authenticationService.isAccessAllowed(providerId, sessions[0].account.label, extensionId)) {
+                return sessions[0];
+            }
+        }
+        if (options.createIfNone || options.forceNewSession) {
+            const providerName = this.authenticationService.getLabel(providerId);
+            const detail = (typeof options.forceNewSession === 'object') ? options.forceNewSession.detail : undefined;
+            const recreatingSession = !!(options.forceNewSession && sessions.length);
+            const isAllowed = await this.loginPrompt(providerName, extensionName, recreatingSession, detail);
+            if (!isAllowed) {
+                throw new Error('User did not consent to login.');
+            }
+            let session;
+            if (sessions?.length && !options.forceNewSession && supportsMultipleAccounts) {
+                session = await this.authenticationService.selectSession(providerId, extensionId, extensionName, scopes, sessions);
+            }
+            else {
+                let sessionToRecreate;
+                if (typeof options.forceNewSession === 'object' && options.forceNewSession.sessionToRecreate) {
+                    sessionToRecreate = options.forceNewSession.sessionToRecreate;
+                }
+                else {
+                    const sessionIdToRecreate = this.authenticationService.getSessionPreference(providerId, extensionId, scopes);
+                    sessionToRecreate = sessionIdToRecreate ? sessions.find(session => session.id === sessionIdToRecreate) : undefined;
+                }
+                session = await this.authenticationService.createSession(providerId, scopes, { activateImmediate: true, sessionToRecreate });
+            }
+            this.authenticationService.updateAllowedExtension(providerId, session.account.label, extensionId, extensionName, true);
+            this.authenticationService.updateSessionPreference(providerId, extensionId, session);
+            return session;
+        }
+        const validSession = sessions.find(session => this.authenticationService.isAccessAllowed(providerId, session.account.label, extensionId));
+        if (validSession) {
+            if (!this.authenticationService.getSessionPreference(providerId, extensionId, scopes)) {
+                if (this.storageService.get(`${extensionName}-${providerId}`, -1 )) {
+                    this.storageService.remove(`${extensionName}-${providerId}`, -1 );
+                }
+                this.authenticationService.updateAllowedExtension(providerId, validSession.account.label, extensionId, extensionName, true);
+                this.authenticationService.updateSessionPreference(providerId, extensionId, validSession);
+            }
+            return validSession;
+        }
+        if (!options.silent) {
+            sessions.length
+                ? this.authenticationService.requestSessionAccess(providerId, extensionId, extensionName, scopes, sessions)
+                : await this.authenticationService.requestNewSession(providerId, scopes, extensionId, extensionName);
+        }
+        return undefined;
+    }
+    async $getSession(providerId, scopes, extensionId, extensionName, options) {
+        const session = await this.doGetSession(providerId, scopes, extensionId, extensionName, options);
+        if (session) {
+            this.sendProviderUsageTelemetry(extensionId, providerId);
+            addAccountUsage(this.storageService, providerId, session.account.label, extensionId, extensionName);
+        }
+        return session;
+    }
+    async $getSessions(providerId, scopes, extensionId, extensionName) {
+        const sessions = await this.authenticationService.getSessions(providerId, [...scopes], true);
+        const accessibleSessions = sessions.filter(s => this.authenticationService.isAccessAllowed(providerId, s.account.label, extensionId));
+        if (accessibleSessions.length) {
+            this.sendProviderUsageTelemetry(extensionId, providerId);
+            for (const session of accessibleSessions) {
+                addAccountUsage(this.storageService, providerId, session.account.label, extensionId, extensionName);
+            }
+        }
+        return accessibleSessions;
+    }
+    sendProviderUsageTelemetry(extensionId, providerId) {
+        this.telemetryService.publicLog2('authentication.providerUsage', { providerId, extensionId });
+    }
+};
+MainThreadAuthentication = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadAuthentication),
+    ( __param(1, IAuthenticationService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IQuickInputService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, ITelemetryService))
+], MainThreadAuthentication);
+
+export { MainThreadAuthentication, MainThreadAuthenticationProvider };

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

@@ -0,0 +1,68 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { decodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { IBulkEditService, ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ResourceNotebookCellEdit } from 'vscode/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadBulkEdits = class MainThreadBulkEdits {
+    constructor(_extHostContext, _bulkEditService, _logService, _uriIdentService) {
+        this._bulkEditService = _bulkEditService;
+        this._logService = _logService;
+        this._uriIdentService = _uriIdentService;
+    }
+    dispose() { }
+    $tryApplyWorkspaceEdit(dto, undoRedoGroupId, isRefactoring) {
+        const edits = reviveWorkspaceEditDto(dto, this._uriIdentService);
+        return this._bulkEditService.apply(edits, { undoRedoGroupId, respectAutoSaveConfig: isRefactoring }).then((res) => res.isApplied, err => {
+            this._logService.warn(`IGNORING workspace edit: ${err}`);
+            return false;
+        });
+    }
+};
+MainThreadBulkEdits = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadBulkEdits),
+    ( __param(1, IBulkEditService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IUriIdentityService))
+], MainThreadBulkEdits);
+function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFile) {
+    if (!data || !data.edits) {
+        return data;
+    }
+    const result = revive(data);
+    for (const edit of result.edits) {
+        if (ResourceTextEdit.is(edit)) {
+            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+        }
+        if (ResourceFileEdit.is(edit)) {
+            if (edit.options) {
+                const inContents = edit.options?.contents;
+                if (inContents) {
+                    if (inContents.type === 'base64') {
+                        edit.options.contents = Promise.resolve(decodeBase64(inContents.value));
+                    }
+                    else {
+                        if (resolveDataTransferFile) {
+                            edit.options.contents = resolveDataTransferFile(inContents.id);
+                        }
+                        else {
+                            throw new Error('Could not revive data transfer file');
+                        }
+                    }
+                }
+            }
+            edit.newResource = edit.newResource && uriIdentityService.asCanonicalUri(edit.newResource);
+            edit.oldResource = edit.oldResource && uriIdentityService.asCanonicalUri(edit.oldResource);
+        }
+        if (ResourceNotebookCellEdit.is(edit)) {
+            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+        }
+    }
+    return data;
+}
+
+export { MainThreadBulkEdits, reviveWorkspaceEditDto };

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

@@ -0,0 +1,174 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
+import { isCompleteInteractiveProgressTreeData } from '../../contrib/chat/common/chatModel.js';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChat = class MainThreadChat extends Disposable {
+    constructor(extHostContext, _chatService, _chatWidgetService, chatContribService) {
+        super();
+        this._chatService = _chatService;
+        this._chatWidgetService = _chatWidgetService;
+        this.chatContribService = chatContribService;
+        this._providerRegistrations = this._register(( new DisposableMap()));
+        this._activeRequestProgressCallbacks = ( new Map());
+        this._stateEmitters = ( new Map());
+        this._responsePartHandlePool = 0;
+        this._activeResponsePartPromises = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChat));
+        this._register(this._chatService.onDidPerformUserAction(e => {
+            this._proxy.$onDidPerformUserAction(e);
+        }));
+    }
+    $transferChatSession(sessionId, toWorkspace) {
+        const sessionIdStr = this._chatService.getSessionId(sessionId);
+        if (!sessionIdStr) {
+            throw new Error(`Failed to transfer session. Unknown session provider ID: ${sessionId}`);
+        }
+        const widget = this._chatWidgetService.getWidgetBySessionId(sessionIdStr);
+        const inputValue = widget?.inputEditor.getValue() ?? '';
+        this._chatService.transferChatSession({ sessionId: sessionIdStr, inputValue: inputValue }, URI.revive(toWorkspace));
+    }
+    async $registerChatProvider(handle, id) {
+        const registration = this.chatContribService.registeredProviders.find(staticProvider => staticProvider.id === id);
+        if (!registration) {
+            throw new Error(`Provider ${id} must be declared in the package.json.`);
+        }
+        const unreg = this._chatService.registerProvider({
+            id,
+            displayName: registration.label,
+            prepareSession: async (initialState, token) => {
+                const session = await this._proxy.$prepareChat(handle, initialState, token);
+                if (!session) {
+                    return undefined;
+                }
+                const responderAvatarIconUri = session.responderAvatarIconUri ?
+                    URI.revive(session.responderAvatarIconUri) :
+                    registration.extensionIcon;
+                const emitter = ( new Emitter());
+                this._stateEmitters.set(session.id, emitter);
+                return {
+                    id: session.id,
+                    requesterUsername: session.requesterUsername,
+                    requesterAvatarIconUri: URI.revive(session.requesterAvatarIconUri),
+                    responderUsername: session.responderUsername,
+                    responderAvatarIconUri,
+                    inputPlaceholder: session.inputPlaceholder,
+                    onDidChangeState: emitter.event,
+                    dispose: () => {
+                        emitter.dispose();
+                        this._stateEmitters.delete(session.id);
+                        this._proxy.$releaseSession(session.id);
+                    }
+                };
+            },
+            resolveRequest: async (session, context, token) => {
+                const dto = await this._proxy.$resolveRequest(handle, session.id, context, token);
+                return {
+                    session,
+                    ...dto
+                };
+            },
+            provideReply: async (request, progress, token) => {
+                const id = `${handle}_${request.session.id}`;
+                this._activeRequestProgressCallbacks.set(id, progress);
+                try {
+                    const requestDto = {
+                        message: request.message,
+                        variables: request.variables
+                    };
+                    const dto = await this._proxy.$provideReply(handle, request.session.id, requestDto, token);
+                    return {
+                        session: request.session,
+                        ...dto
+                    };
+                }
+                finally {
+                    this._activeRequestProgressCallbacks.delete(id);
+                }
+            },
+            provideWelcomeMessage: (token) => {
+                return this._proxy.$provideWelcomeMessage(handle, token);
+            },
+            provideSlashCommands: (session, token) => {
+                return this._proxy.$provideSlashCommands(handle, session.id, token);
+            },
+            provideFollowups: (session, token) => {
+                return this._proxy.$provideFollowups(handle, session.id, token);
+            },
+            removeRequest: (session, requestId) => {
+                return this._proxy.$removeRequest(handle, session.id, requestId);
+            }
+        });
+        this._providerRegistrations.set(handle, unreg);
+    }
+    async $acceptResponseProgress(handle, sessionId, progress, responsePartHandle) {
+        const id = `${handle}_${sessionId}`;
+        if ('placeholder' in progress) {
+            const responsePartId = `${id}_${++this._responsePartHandlePool}`;
+            const deferredContentPromise = ( new DeferredPromise());
+            this._activeResponsePartPromises.set(responsePartId, deferredContentPromise);
+            this._activeRequestProgressCallbacks.get(id)?.({ ...progress, resolvedContent: deferredContentPromise.p });
+            return this._responsePartHandlePool;
+        }
+        else if (responsePartHandle) {
+            const responsePartId = `${id}_${responsePartHandle}`;
+            const deferredContentPromise = this._activeResponsePartPromises.get(responsePartId);
+            if (deferredContentPromise && isCompleteInteractiveProgressTreeData(progress)) {
+                const withRevivedUris = revive(progress);
+                deferredContentPromise.complete(withRevivedUris);
+                this._activeResponsePartPromises.delete(responsePartId);
+            }
+            else if (deferredContentPromise && 'content' in progress) {
+                deferredContentPromise.complete(progress.content);
+                this._activeResponsePartPromises.delete(responsePartId);
+            }
+            return;
+        }
+        if (isCompleteInteractiveProgressTreeData(progress)) {
+            return;
+        }
+        if ('documents' in progress) {
+            const usedContext = {
+                documents: ( progress.documents.map(({ uri, version, ranges }) => ({
+                    uri: URI.revive(uri),
+                    version,
+                    ranges,
+                }))),
+            };
+            this._activeRequestProgressCallbacks.get(id)?.(usedContext);
+            return;
+        }
+        this._activeRequestProgressCallbacks.get(id)?.(progress);
+    }
+    async $acceptChatState(sessionId, state) {
+        this._stateEmitters.get(sessionId)?.fire(state);
+    }
+    $addRequest(context) {
+        this._chatService.addRequest(context);
+    }
+    async $sendRequestToProvider(providerId, message) {
+        const widget = await this._chatWidgetService.revealViewForProvider(providerId);
+        if (widget && widget.viewModel) {
+            this._chatService.sendRequestToProvider(widget.viewModel.sessionId, message);
+        }
+    }
+    async $unregisterChatProvider(handle) {
+        this._providerRegistrations.deleteAndDispose(handle);
+    }
+};
+MainThreadChat = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChat),
+    ( __param(1, IChatService)),
+    ( __param(2, IChatWidgetService)),
+    ( __param(3, IChatContributionService))
+], MainThreadChat);
+
+export { MainThreadChat };

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

@@ -0,0 +1,52 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatAgents = class MainThreadChatAgents {
+    constructor(extHostContext, _chatAgentService) {
+        this._chatAgentService = _chatAgentService;
+        this._agents = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents));
+    }
+    $unregisterAgent(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+    dispose() {
+        this._agents.clearAndDisposeAll();
+    }
+    $registerAgent(handle, name, metadata) {
+        if (!this._chatAgentService.hasAgent(name)) {
+            this._chatAgentService.registerAgentData({
+                id: name,
+                metadata: revive(metadata)
+            });
+        }
+        const d = this._chatAgentService.registerAgentCallback(name, async (prompt, progress, history, token) => {
+            const requestId = Math.random();
+            this._pendingProgress.set(requestId, progress);
+            try {
+                return await this._proxy.$invokeAgent(handle, requestId, prompt, { history }, token);
+            }
+            finally {
+                this._pendingProgress.delete(requestId);
+            }
+        });
+        this._agents.set(handle, d);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(revive(chunk));
+    }
+    $unregisterCommand(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+};
+MainThreadChatAgents = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatAgents),
+    ( __param(1, IChatAgentService))
+], MainThreadChatAgents);
+
+export { MainThreadChatAgents };