@codingame/monaco-vscode-extensions-service-override 6.0.3 → 7.0.1

package/extensions.js

@@ -1,7 +1,6 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { toExtensionDescription } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
@@ -45,6 +44,7 @@ import './vscode/src/vs/workbench/api/browser/mainThreadBulkEdits.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadLanguageModels.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadChatVariables.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadLanguageModelTools.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadEmbeddings.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadCodeInsets.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadCLICommands.js';
@@ -215,12 +215,6 @@ let ExtensionServiceOverride = class ExtensionServiceOverride extends ExtensionS
     async deltaExtensions(toAdd, toRemove) {
         await this._handleDeltaExtensions(new DeltaExtensionsQueueItem(toAdd, toRemove));
     }
-    async _scanSingleExtension(extension) {
-        if (extension.location.scheme === CustomSchemas.extensionFile) {
-            return toExtensionDescription(extension);
-        }
-        return super._scanSingleExtension(extension);
-    }
 };
 ExtensionServiceOverride = __decorate([
     ( __param(1, IInstantiationService)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "6.0.3",
+  "version": "7.0.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@6.0.3",
-    "@codingame/monaco-vscode-files-service-override": "6.0.3"
+    "vscode": "npm:@codingame/monaco-vscode-api@7.0.1",
+    "@codingame/monaco-vscode-files-service-override": "7.0.1"
   }
 }

package/vscode/src/vs/platform/extensionManagement/common/extensionManagementCLI.js

@@ -145,7 +145,7 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
                 if (areSameExtensions(oldVersion.identifier, newVersion.identifier) && semverExports.gt(newVersion.version, oldVersion.manifest.version)) {
                     extensionsToUpdate.push({
                         extension: newVersion,
-                        options: { operation: InstallOperation.Update, installPreReleaseVersion: oldVersion.preRelease, profileLocation }
+                        options: { operation: InstallOperation.Update, installPreReleaseVersion: oldVersion.preRelease, profileLocation, isApplicationScoped: oldVersion.isApplicationScoped }
                     });
                 }
             }
@@ -255,7 +255,7 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
             }
             extensionsToInstall.push({
                 extension: gallery,
-                options: { ...installOptions, installGivenVersion: !!version },
+                options: { ...installOptions, installGivenVersion: !!version, isApplicationScoped: installedExtension?.isApplicationScoped },
             });
         }))));
         if (extensionsToInstall.length) {

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

@@ -29,8 +29,8 @@ class MainThreadAuthenticationProvider extends Disposable {
         this.notificationService = notificationService;
         this.onDidChangeSessions = onDidChangeSessionsEmitter.event;
     }
-    async getSessions(scopes) {
-        return this._proxy.$getSessions(this.id, scopes);
+    async getSessions(scopes, options) {
+        return this._proxy.$getSessions(this.id, scopes, options);
     }
     createSession(scopes, options) {
         return this._proxy.$createSession(this.id, scopes, options);
@@ -145,7 +145,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         return result ?? false;
     }
     async doGetSession(providerId, scopes, extensionId, extensionName, options) {
-        const sessions = await this.authenticationService.getSessions(providerId, scopes, true);
+        const sessions = await this.authenticationService.getSessions(providerId, scopes, options.account, true);
         const provider = this.authenticationService.getProvider(providerId);
         if (options.forceNewSession && options.createIfNone) {
             throw ( (new Error(
@@ -193,20 +193,17 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             }
             let session;
             if (sessions?.length && !options.forceNewSession) {
-                session = provider.supportsMultipleAccounts
+                session = provider.supportsMultipleAccounts && !options.account
                     ? await this.authenticationExtensionsService.selectSession(providerId, extensionId, extensionName, scopes, sessions)
                     : sessions[0];
             }
             else {
-                let sessionToRecreate;
-                if (typeof options.forceNewSession === 'object' && options.forceNewSession.sessionToRecreate) {
-                    sessionToRecreate = options.forceNewSession.sessionToRecreate;
-                }
-                else {
+                let account = options.account;
+                if (!account) {
                     const sessionIdToRecreate = this.authenticationExtensionsService.getSessionPreference(providerId, extensionId, scopes);
-                    sessionToRecreate = sessionIdToRecreate ? sessions.find(session => session.id === sessionIdToRecreate) : undefined;
+                    account = sessionIdToRecreate ? sessions.find(session => session.id === sessionIdToRecreate)?.account : undefined;
                 }
-                session = await this.authenticationService.createSession(providerId, scopes, { activateImmediate: true, sessionToRecreate });
+                session = await this.authenticationService.createSession(providerId, scopes, { activateImmediate: true, account });
             }
             this.authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{ id: extensionId, name: extensionName, allowed: true }]);
             this.authenticationExtensionsService.updateSessionPreference(providerId, extensionId, session);
@@ -231,16 +228,17 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         }
         return session;
     }
-    async $getSessions(providerId, scopes, extensionId, extensionName) {
-        const sessions = await this.authenticationService.getSessions(providerId, [...scopes], true);
-        const accessibleSessions = sessions.filter(s => this.authenticationAccessService.isAccessAllowed(providerId, s.account.label, extensionId));
-        if (accessibleSessions.length) {
-            this.sendProviderUsageTelemetry(extensionId, providerId);
-            for (const session of accessibleSessions) {
-                this.authenticationUsageService.addAccountUsage(providerId, session.account.label, extensionId, extensionName);
+    async $getAccounts(providerId) {
+        const sessions = await this.authenticationService.getSessions(providerId);
+        const accounts = ( (new Array()));
+        const seenAccounts = ( (new Set()));
+        for (const session of sessions) {
+            if (!( (seenAccounts.has(session.account.label)))) {
+                seenAccounts.add(session.account.label);
+                accounts.push(session.account);
             }
         }
-        return accessibleSessions;
+        return accounts;
     }
     sendProviderUsageTelemetry(extensionId, providerId) {
         this.telemetryService.publicLog2('authentication.providerUsage', { providerId, extensionId });

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

@@ -160,7 +160,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $updateAgent(handle, metadataUpdate) {
         const data = this._agents.get(handle);
         if (!data) {
-            throw ( new Error(`No agent with handle ${handle} registered`));
+            this._logService.error(`MainThreadChatAgents2#$updateAgent: No agent with handle ${handle} registered`);
+            return;
         }
         data.hasFollowups = metadataUpdate.hasFollowups;
         this._chatAgentService.updateAgent(data.id, revive(metadataUpdate));

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

@@ -32,9 +32,6 @@ let MainThreadChatVariables = class MainThreadChatVariables {
     $unregisterVariable(handle) {
         this._variables.deleteAndDispose(handle);
     }
-    $attachContext(name, value, location) {
-        this._chatVariablesService.attachContext(name, revive(value), location);
-    }
 };
 MainThreadChatVariables = __decorate([
     extHostNamedCustomer(MainContext.MainThreadChatVariables),

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

@@ -19,6 +19,9 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { MarshalledId } from 'vscode/vscode/vs/base/common/marshallingIds';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
+import { revealCommentThread } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsController';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 
 const _moduleId = "vs/workbench/api/browser/mainThreadComments";
 class MainThreadCommentThread {
@@ -108,7 +111,7 @@ class MainThreadCommentThread {
     get isTemplate() {
         return this._isTemplate;
     }
-    constructor(commentThreadHandle, controllerHandle, extensionId, threadId, resource, _range, _canReply, _isTemplate, editorId) {
+    constructor(commentThreadHandle, controllerHandle, extensionId, threadId, resource, _range, comments, _canReply, _isTemplate, editorId) {
         this.commentThreadHandle = commentThreadHandle;
         this.controllerHandle = controllerHandle;
         this.extensionId = extensionId;
@@ -137,6 +140,9 @@ class MainThreadCommentThread {
         if (_isTemplate) {
             this.comments = [];
         }
+        else if (comments) {
+            this._comments = comments;
+        }
     }
     batchUpdate(changes) {
         const modified = (value) => Object.prototype.hasOwnProperty.call(changes, value);
@@ -232,7 +238,7 @@ class MainThreadCommentController {
     updateFeatures(features) {
         this._features = features;
     }
-    createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, isTemplate, editorId) {
+    createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, comments, isTemplate, editorId) {
         const thread = ( (new MainThreadCommentThread(
             commentThreadHandle,
             this.handle,
@@ -240,6 +246,7 @@ class MainThreadCommentController {
             threadId,
              (URI.revive(resource).toString()),
             range,
+            comments,
             true,
             isTemplate,
             editorId
@@ -411,11 +418,13 @@ class MainThreadCommentController {
 }
 const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localizeWithPath(_moduleId, 0, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
-    constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService) {
+    constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService, _uriIdentityService, _editorService) {
         super();
         this._commentService = _commentService;
         this._viewsService = _viewsService;
         this._viewDescriptorService = _viewDescriptorService;
+        this._uriIdentityService = _uriIdentityService;
+        this._editorService = _editorService;
         this._handlers = ( (new Map()));
         this._commentControllers = ( (new Map()));
         this._activeEditingCommentThreadDisposables = this._register(( (new DisposableStore())));
@@ -464,12 +473,12 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }
         provider.updateFeatures(features);
     }
-    $createCommentThread(handle, commentThreadHandle, threadId, resource, range, extensionId, isTemplate, editorId) {
+    $createCommentThread(handle, commentThreadHandle, threadId, resource, range, comments, extensionId, isTemplate, editorId) {
         const provider = this._commentControllers.get(handle);
         if (!provider) {
             return undefined;
         }
-        return provider.createCommentThread(extensionId.value, commentThreadHandle, threadId, resource, range, isTemplate, editorId);
+        return provider.createCommentThread(extensionId.value, commentThreadHandle, threadId, resource, range, comments, isTemplate, editorId);
     }
     $updateCommentThread(handle, commentThreadHandle, threadId, resource, changes) {
         const provider = this._commentControllers.get(handle);
@@ -492,6 +501,17 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }
         provider.updateCommentingRanges(resourceHints);
     }
+    async $revealCommentThread(handle, commentThreadHandle, options) {
+        const provider = this._commentControllers.get(handle);
+        if (!provider) {
+            return Promise.resolve();
+        }
+        const thread = provider.getAllComments().find(thread => thread.commentThreadHandle === commentThreadHandle);
+        if (!thread || !thread.isDocumentCommentThread()) {
+            return Promise.resolve();
+        }
+        revealCommentThread(this._commentService, this._editorService, this._uriIdentityService, thread, undefined, options.focusReply, undefined, options.preserveFocus);
+    }
     registerView(commentsViewAlreadyRegistered) {
         if (!commentsViewAlreadyRegistered) {
             const VIEW_CONTAINER = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
@@ -570,7 +590,9 @@ MainThreadComments = __decorate([
     extHostNamedCustomer(MainContext.MainThreadComments),
     ( (__param(1, ICommentService))),
     ( (__param(2, IViewsService))),
-    ( (__param(3, IViewDescriptorService)))
+    ( (__param(3, IViewDescriptorService))),
+    ( (__param(4, IUriIdentityService))),
+    ( (__param(5, IEditorService)))
 ], MainThreadComments);
 
 export { MainThreadCommentController, MainThreadCommentThread, MainThreadComments };

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

@@ -274,6 +274,7 @@ let MainThreadDebugService = class MainThreadDebugService {
             compact: options.compact,
             compoundRoot: parentSession?.compoundRoot,
             saveBeforeRestart: saveBeforeStart,
+            testRun: options.testRun,
             suppressDebugStatusbar: options.suppressDebugStatusbar,
             suppressDebugToolbar: options.suppressDebugToolbar,
             suppressDebugView: options.suppressDebugView,

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

@@ -1,5 +1,5 @@
 import { __decorate } from 'vscode/external/tslib/tslib.es6.js';
-import { ErrorNoTelemetry, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { transformErrorFromSerialization, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 
@@ -8,11 +8,7 @@ let MainThreadErrors = class MainThreadErrors {
     }
     $onUnexpectedError(err) {
         if (err && err.$isError) {
-            const { name, message, stack } = err;
-            err = err.noTelemetry ? ( new ErrorNoTelemetry()) : ( new Error());
-            err.message = message;
-            err.name = name;
-            err.stack = stack;
+            err = transformErrorFromSerialization(err);
         }
         onUnexpectedError(err);
     }

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

@@ -1,6 +1,7 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Action } from 'vscode/vscode/vs/base/common/actions';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { transformErrorFromSerialization } from 'vscode/vscode/vs/base/common/errors';
 import { FileAccess } from 'vscode/vscode/vs/base/common/network';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -54,19 +55,13 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
     }
     $onExtensionRuntimeError(extensionId, data) {
-        const error = ( (new Error()));
-        error.name = data.name;
-        error.message = data.message;
-        error.stack = data.stack;
+        const error = transformErrorFromSerialization(data);
         this._internalExtensionService._onExtensionRuntimeError(extensionId, error);
         console.error(`[${extensionId.value}]${error.message}`);
         console.error(error.stack);
     }
     async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {
-        const error = ( (new Error()));
-        error.name = data.name;
-        error.message = data.message;
-        error.stack = data.stack;
+        const error = transformErrorFromSerialization(data);
         this._internalExtensionService._onDidActivateExtensionError(extensionId, error);
         if (missingExtensionDependency) {
             const extension = await this._extensionService.getExtension(extensionId.value);

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

@@ -497,6 +497,9 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             provideInlineCompletions: async (model, position, context, token) => {
                 return this._proxy.$provideInlineCompletions(handle, model.uri, position, context, token);
             },
+            provideInlineEdits: async (model, range, context, token) => {
+                return this._proxy.$provideInlineEdits(handle, model.uri, range, context, token);
+            },
             handleItemDidShow: async (completions, item, updatedInsertText) => {
                 if (supportsHandleEvents) {
                     await this._proxy.$handleInlineCompletionDidShow(handle, completions.pid, item.idx, updatedInsertText);
@@ -936,14 +939,19 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
             if (!edits) {
                 return;
             }
-            return ( edits.map(edit => {
-                return {
-                    ...edit,
-                    yieldTo: edit.yieldTo?.map(x => ({ kind: ( new HierarchicalKind(x)) })),
-                    kind: edit.kind ? ( new HierarchicalKind(edit.kind)) : undefined,
-                    additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService, dataId => this.resolveDocumentOnDropFileData(request.id, dataId)),
-                };
-            }));
+            return {
+                edits: ( edits.map(edit => {
+                    return {
+                        ...edit,
+                        yieldTo: edit.yieldTo?.map(x => ({ kind: ( new HierarchicalKind(x)) })),
+                        kind: edit.kind ? ( new HierarchicalKind(edit.kind)) : undefined,
+                        additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService, dataId => this.resolveDocumentOnDropFileData(request.id, dataId)),
+                    };
+                })),
+                dispose: () => {
+                    this._proxy.$releaseDocumentOnDropEdits(this._handle, request.id);
+                },
+            };
         }
         finally {
             request.dispose();

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

@@ -0,0 +1,38 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ILanguageModelToolsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Disposable {
+    constructor(extHostContext, _languageModelToolsService) {
+        super();
+        this._languageModelToolsService = _languageModelToolsService;
+        this._tools = this._register(( new DisposableMap()));
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLanguageModelTools));
+        this._register(this._languageModelToolsService.onDidChangeTools(e => this._proxy.$acceptToolDelta(e)));
+    }
+    async $getTools() {
+        return Array.from(this._languageModelToolsService.getTools());
+    }
+    $invokeTool(name, parameters, token) {
+        return this._languageModelToolsService.invokeTool(name, parameters, token);
+    }
+    $registerTool(name) {
+        const disposable = this._languageModelToolsService.registerToolImplementation(name, {
+            invoke: async (parameters, token) => {
+                return await this._proxy.$invokeTool(name, parameters, token);
+            },
+        });
+        this._tools.set(name, disposable);
+    }
+    $unregisterTool(name) {
+        this._tools.deleteAndDispose(name);
+    }
+};
+MainThreadLanguageModelTools = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLanguageModelTools),
+    ( __param(1, ILanguageModelToolsService))
+], MainThreadLanguageModelTools);
+
+export { MainThreadLanguageModelTools };

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

@@ -1,9 +1,10 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { DeferredPromise, AsyncIterableSource } from 'vscode/vscode/vs/base/common/async';
+import { transformErrorFromSerialization, transformErrorForSerialization } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore, DisposableMap, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { ILanguageModelStatsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModelStats.service';
 import { ILanguageModelsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModels.service';
@@ -39,15 +40,22 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         const dipsosables = ( (new DisposableStore()));
         dipsosables.add(this._chatProviderService.registerLanguageModelChat(identifier, {
             metadata,
-            provideChatResponse: async (messages, from, options, progress, token) => {
+            sendChatRequest: async (messages, from, options, token) => {
                 const requestId = (Math.random() * 1e6) | 0;
-                this._pendingProgress.set(requestId, progress);
+                const defer = ( (new DeferredPromise()));
+                const stream = ( (new AsyncIterableSource()));
                 try {
-                    await this._proxy.$provideLanguageModelResponse(handle, requestId, from, messages, options, token);
+                    this._pendingProgress.set(requestId, { defer, stream });
+                    await this._proxy.$startChatRequest(handle, requestId, from, messages, options, token);
                 }
-                finally {
+                catch (err) {
                     this._pendingProgress.delete(requestId);
+                    throw err;
                 }
+                return {
+                    result: defer.p,
+                    stream: stream.asyncIterable
+                };
             },
             provideTokenCount: (str, token) => {
                 return this._proxy.$provideTokenLength(handle, str, token);
@@ -58,8 +66,28 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         }
         this._providerRegistrations.set(handle, dipsosables);
     }
-    async $handleProgressChunk(requestId, chunk) {
-        this._pendingProgress.get(requestId)?.report(chunk);
+    async $reportResponsePart(requestId, chunk) {
+        const data = this._pendingProgress.get(requestId);
+        this._logService.trace('[LM] report response PART', Boolean(data), requestId, chunk);
+        if (data) {
+            data.stream.emitOne(chunk);
+        }
+    }
+    async $reportResponseDone(requestId, err) {
+        const data = this._pendingProgress.get(requestId);
+        this._logService.trace('[LM] report response DONE', Boolean(data), requestId, err);
+        if (data) {
+            this._pendingProgress.delete(requestId);
+            if (err) {
+                const error = transformErrorFromSerialization(err);
+                data.stream.reject(error);
+                data.defer.error(error);
+            }
+            else {
+                data.stream.resolve();
+                data.defer.complete(undefined);
+            }
+        }
     }
     $unregisterProvider(handle) {
         this._providerRegistrations.deleteAndDispose(handle);
@@ -70,18 +98,29 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
     $whenLanguageModelChatRequestMade(identifier, extensionId, participant, tokenCount) {
         this._languageModelStatsService.update(identifier, extensionId, participant, tokenCount);
     }
-    async $fetchResponse(extension, providerId, requestId, messages, options, token) {
-        this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
-        const task = this._chatProviderService.makeLanguageModelChatRequest(providerId, extension, messages, options, ( (new Progress(value => {
-            this._proxy.$handleResponseFragment(requestId, value);
-        }))), token);
-        task.catch(err => {
-            this._logService.error('[CHAT] extension request ERRORED', err, extension.value, requestId);
-            throw err;
-        }).finally(() => {
+    async $tryStartChatRequest(extension, providerId, requestId, messages, options, token) {
+        this._logService.trace('[CHAT] request STARTED', extension.value, requestId);
+        const response = await this._chatProviderService.sendChatRequest(providerId, extension, messages, options, token);
+        const streaming = (async () => {
+            try {
+                for await (const part of response.stream) {
+                    this._logService.trace('[CHAT] request PART', extension.value, requestId, part);
+                    await this._proxy.$acceptResponsePart(requestId, part);
+                }
+                this._logService.trace('[CHAT] request DONE', extension.value, requestId);
+            }
+            catch (err) {
+                this._logService.error('[CHAT] extension request ERRORED in STREAM', err, extension.value, requestId);
+                this._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
+            }
+        })();
+        Promise.allSettled([response.result, streaming]).then(() => {
             this._logService.debug('[CHAT] extension request DONE', extension.value, requestId);
+            this._proxy.$acceptResponseDone(requestId, undefined);
+        }, err => {
+            this._logService.error('[CHAT] extension request ERRORED', err, extension.value, requestId);
+            this._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
         });
-        return task;
     }
     $countTokens(provider, value, token) {
         return this._chatProviderService.computeTokenLength(provider, value, token);
@@ -140,9 +179,9 @@ class LanguageModelAccessAuthProvider {
         if (this._session) {
             return [this._session];
         }
-        return [await this.createSession(scopes || [], {})];
+        return [await this.createSession(scopes || [])];
     }
-    async createSession(scopes, options) {
+    async createSession(scopes) {
         this._session = this._createFakeSession(scopes);
         this._onDidChangeSessions.fire({ added: [this._session], changed: [], removed: [] });
         return this._session;