@codingame/monaco-vscode-extensions-service-override 34.1.3 → 35.0.1

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

@@ -311,7 +311,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 const chatSession = this._chatService.getSession(request.sessionResource);
                 this._pendingProgress.set(request.requestId, {
                     progress,
-                    chatSession
+                    chatSession,
+                    isSubagent: !!request.subAgentInvocationId
                 });
                 try {
                     const chatSessionResource = request.sessionResource;
@@ -421,7 +422,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         }
         const {
             progress,
-            chatSession
+            chatSession,
+            isSubagent
         } = pendingProgress;
         const chatProgressParts = [];
         const response = chatSession?.getRequests().find(req => req.id === requestId)?.response;
@@ -458,14 +460,28 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 continue;
             }
             if (progress.kind === "usage") {
-                if (response) {
+                if (isSubagent) {
+                    chatProgressParts.push({
+                        kind: "usage",
+                        promptTokens: progress.promptTokens,
+                        completionTokens: progress.completionTokens,
+                        outputBuffer: progress.outputBuffer,
+                        copilotCredits: progress.copilotCredits,
+                        promptTokenDetails: progress.promptTokenDetails
+                    });
+                } else if (response) {
                     response.setUsage({
                         kind: "usage",
                         promptTokens: progress.promptTokens,
                         completionTokens: progress.completionTokens,
                         outputBuffer: progress.outputBuffer,
+                        copilotCredits: progress.copilotCredits,
                         promptTokenDetails: progress.promptTokenDetails
                     });
+                } else {
+                    this._logService.warn(
+                        `MainThreadChatAgents2#$handleProgressChunk: No response model for usage of non-subagent request ${requestId}; dropping usage.`
+                    );
                 }
                 continue;
             }
@@ -707,8 +723,19 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     badgeTooltip: item.badgeTooltip,
                     extensionId: item.extensionId,
                     pluginUri: item.pluginUri ? URI.revive(item.pluginUri) : undefined,
+                    pluginLabel: item.pluginLabel,
                     userInvocable: item.userInvocable
                 })));
+            },
+            provideSourceFolders: async (sessionResource, type, token) => {
+                const folders = await this._proxy.$provideSourceFolders(handle, sessionResource, type, token);
+                if (!folders) {
+                    return undefined;
+                }
+                return ( folders.map(folder => ({
+                    uri: URI.revive(folder.uri),
+                    label: folder.label
+                })));
             }
         };
         const typeToSection = {

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

@@ -35,6 +35,18 @@ export declare class ObservableChatSession extends Disposable implements IChatSe
     private _isInitialized;
     private _interruptionWasCanceled;
     private _disposalPending;
+    /**
+     * Number of currently in-flight `requestHandler` invocations. Used to
+     * defer `$disposeChatSessionContent` when the workbench wants to release
+     * this session while a request is mid-flight on a `requestHandler`-style
+     * session (e.g. Copilot CLI). Without this guard, the proxy dispose
+     * synchronously cancels the ext-host `disposeCts` and tears down the
+     * underlying SDK session (which calls `sdkSession.abort()`), so the
+     * in-flight request is lost. The `activeResponseCallback`-style sessions
+     * have their own deferral via {@link interruptActiveResponseCallback};
+     * this counter is the equivalent for `requestHandler`-style sessions.
+     */
+    private _inFlightRequestCount;
     private _initializationPromise?;
     interruptActiveResponseCallback?: () => Promise<boolean>;
     requestHandler?: (request: IChatAgentRequest, progress: (progress: IChatProgress[]) => void, history: any[], token: CancellationToken) => Promise<void>;

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

@@ -70,6 +70,7 @@ class ObservableChatSession extends Disposable {
         this._isInitialized = false;
         this._interruptionWasCanceled = false;
         this._disposalPending = false;
+        this._inFlightRequestCount = 0;
         this.sessionResource = resource;
         this.providerHandle = providerHandle;
         this.history = [];
@@ -136,7 +137,7 @@ class ObservableChatSession extends Disposable {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2662, "Are you sure you want to interrupt the active session?"))
+                        message: ( localize(2738, "Are you sure you want to interrupt the active session?"))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
@@ -162,6 +163,7 @@ class ObservableChatSession extends Disposable {
             }
             if (sessionContent.hasRequestHandler && !this.requestHandler) {
                 this.requestHandler = async (request, progress, history, token) => {
+                    this._inFlightRequestCount++;
                     this._progressObservable.set([], undefined);
                     this._isCompleteObservable.set(false, undefined);
                     let lastProgressLength = 0;
@@ -195,6 +197,11 @@ class ObservableChatSession extends Disposable {
                         throw error;
                     } finally {
                         progressDisposable.dispose();
+                        this._inFlightRequestCount--;
+                        if (this._disposalPending && this._inFlightRequestCount === 0 && !this.interruptActiveResponseCallback) {
+                            this._disposalPending = false;
+                            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionResource);
+                        }
                     }
                 };
             }
@@ -276,6 +283,8 @@ class ObservableChatSession extends Disposable {
         this._pendingProgressChunks.clear();
         if (this.interruptActiveResponseCallback && !this._interruptionWasCanceled) {
             this._disposalPending = true;
+        } else if (this._inFlightRequestCount > 0) {
+            this._disposalPending = true;
         } else {
             this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionResource);
         }
@@ -653,7 +662,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             const options = {
                 title: {
                     preferred: originalEditor?.getName() || undefined,
-                    fallback: ( localize(2663, "{0}", contribution?.displayName))
+                    fallback: ( localize(2739, "{0}", contribution?.displayName))
                 }
             };
             const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
@@ -683,7 +692,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 await this._chatWidgetService.openSession(modifiedResource, undefined, {
                     preserveFocus: true
                 });
-            } else {
+            } else if (!chatViewWidget) {
                 const ref = await this._chatService.acquireOrLoadSession(modifiedResource, ChatAgentLocation.Chat, CancellationToken.None);
                 ref?.dispose();
             }

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

@@ -468,7 +468,7 @@ let MainThreadCommentController = class MainThreadCommentController extends Disp
     }
 };
 MainThreadCommentController = ( __decorate([( __param(6, ICommentService)), ( __param(7, IUriIdentityService))], MainThreadCommentController));
-const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2664, "View icon of the comments view.")));
+const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2740, "View icon of the comments view.")));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(
         extHostContext,

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

@@ -532,7 +532,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2665,
+                    2741,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -600,7 +600,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2666, "Edit")),
+            label: label ?? ( localize(2742, "Edit")),
             code: "undoredo.customEditorEdit",
             undo: () => this.undo(),
             redo: () => this.redo()

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

@@ -14,7 +14,7 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(2667, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2743, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         }));
         return raceCancellationError(p, token);

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

@@ -111,7 +111,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2668,
+                    2744,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -119,7 +119,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "reload",
-                        label: ( localize(2669, "Reload Window")),
+                        label: ( localize(2745, "Reload Window")),
                         run: () => this._hostService.reload()
                     })]
                 }
@@ -130,7 +130,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2670,
+                        2746,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -140,7 +140,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2671,
+                        2747,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -148,7 +148,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "manageWorkspaceTrust",
-                            label: ( localize(2672, "Manage Workspace Trust")),
+                            label: ( localize(2748, "Manage Workspace Trust")),
                             run: () => this._commandService.executeCommand("workbench.trust.manage")
                         })]
                     }
@@ -157,7 +157,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2673,
+                        2749,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -165,7 +165,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "enable",
-                            label: ( localize(2674, "Enable and Reload")),
+                            label: ( localize(2750, "Enable and Reload")),
                             enabled: true,
                             run: () => this._extensionEnablementService.setEnablement(
                                 [missingInstalledDependency],
@@ -178,7 +178,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2675,
+                        2751,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -199,7 +199,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2676,
+                    2752,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
@@ -208,14 +208,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "install",
-                        label: ( localize(2677, "Install and Reload")),
+                        label: ( localize(2753, "Install and Reload")),
                         run: () => this._extensionsWorkbenchService.install(dependencyExtension).then(() => this._hostService.reload(), e => this._notificationService.error(e))
                     })]
                 }
             });
         } else {
             this._notificationService.error(( localize(
-                2678,
+                2754,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency

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

@@ -94,25 +94,25 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     if (data.extensionNames.length === 1) {
                         if (operation === FileOperation.CREATE) {
                             message = ( localize(
-                                2679,
+                                2755,
                                 "Extension '{0}' wants to make refactoring changes with this file creation",
                                 data.extensionNames[0]
                             ));
                         } else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                2680,
+                                2756,
                                 "Extension '{0}' wants to make refactoring changes with this file copy",
                                 data.extensionNames[0]
                             ));
                         } else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                2681,
+                                2757,
                                 "Extension '{0}' wants to make refactoring changes with this file move",
                                 data.extensionNames[0]
                             ));
                         } else  {
                             message = ( localize(
-                                2682,
+                                2758,
                                 "Extension '{0}' wants to make refactoring changes with this file deletion",
                                 data.extensionNames[0]
                             ));
@@ -120,25 +120,25 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     } else {
                         if (operation === FileOperation.CREATE) {
                             message = ( localize(
-                                2683,
+                                2759,
                                 "{0} extensions want to make refactoring changes with this file creation",
                                 data.extensionNames.length
                             ));
                         } else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                2684,
+                                2760,
                                 "{0} extensions want to make refactoring changes with this file copy",
                                 data.extensionNames.length
                             ));
                         } else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                2685,
+                                2761,
                                 "{0} extensions want to make refactoring changes with this file move",
                                 data.extensionNames.length
                             ));
                         } else  {
                             message = ( localize(
-                                2686,
+                                2762,
                                 "{0} extensions want to make refactoring changes with this file deletion",
                                 data.extensionNames.length
                             ));
@@ -150,8 +150,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                         } = await dialogService.confirm({
                             type: Severity.Info,
                             message,
-                            primaryButton: ( localize(2687, "Show &&Preview")),
-                            cancelButton: ( localize(2688, "Skip Changes"))
+                            primaryButton: ( localize(2763, "Show &&Preview")),
+                            cancelButton: ( localize(2764, "Skip Changes"))
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -171,18 +171,18 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                             type: Severity.Info,
                             message,
                             buttons: [{
-                                label: ( localize(2689, "&&OK")),
+                                label: ( localize(2765, "&&OK")),
                                 run: () => Choice.OK
                             }, {
-                                label: ( localize(2687, "Show &&Preview")),
+                                label: ( localize(2763, "Show &&Preview")),
                                 run: () => Choice.Preview
                             }],
                             cancelButton: {
-                                label: ( localize(2688, "Skip Changes")),
+                                label: ( localize(2764, "Skip Changes")),
                                 run: () => Choice.Cancel
                             },
                             checkbox: {
-                                label: ( localize(2690, "Do not ask me again"))
+                                label: ( localize(2766, "Do not ask me again"))
                             }
                         });
                         if (result === Choice.Cancel) {
@@ -211,15 +211,15 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             _progressLabel(operation) {
                 switch (operation) {
                 case FileOperation.CREATE:
-                    return localize(2691, "Running 'File Create' participants...");
+                    return localize(2767, "Running 'File Create' participants...");
                 case FileOperation.MOVE:
-                    return localize(2692, "Running 'File Rename' participants...");
+                    return localize(2768, "Running 'File Rename' participants...");
                 case FileOperation.COPY:
-                    return localize(2693, "Running 'File Copy' participants...");
+                    return localize(2769, "Running 'File Copy' participants...");
                 case FileOperation.DELETE:
-                    return localize(2694, "Running 'File Delete' participants...");
+                    return localize(2770, "Running 'File Delete' participants...");
                 case FileOperation.WRITE:
-                    return localize(2695, "Running 'File Write' participants...");
+                    return localize(2771, "Running 'File Write' participants...");
                 }
             }
         })();
@@ -307,7 +307,7 @@ registerAction2(class ResetMemento extends Action2 {
         super({
             id: "files.participants.resetChoice",
             title: {
-                value: ( localize(2696, "Reset choice for 'File operation needs preview'")),
+                value: ( localize(2772, "Reset choice for 'File operation needs preview'")),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true

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

@@ -1289,7 +1289,7 @@ let ExtensionBackedInlineCompletionsProvider = class ExtensionBackedInlineComple
         }
         if (this._supportsHandleEvents) {
             await this._proxy.$handleInlineCompletionEndOfLifetime(this.handle, completions.pid, item.idx, mapReason(reason, i => ({
-                pid: completions.pid,
+                pid: i.pid,
                 idx: i.idx
             })));
         }

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

@@ -29,12 +29,13 @@ let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Di
         );
     }
     getToolDtos() {
+        const fullReferenceNameMap = this._languageModelToolsService.getFullReferenceNameMap();
         return ( Array.from(this._languageModelToolsService.getAllToolsIncludingDisabled()).map(tool => ({
             id: tool.id,
             displayName: tool.displayName,
             toolReferenceName: tool.toolReferenceName,
             legacyToolReferenceFullNames: tool.legacyToolReferenceFullNames,
-            fullReferenceName: tool.source.type === "mcp" ? this._languageModelToolsService.getFullReferenceName(tool) : undefined,
+            fullReferenceName: fullReferenceNameMap.get(tool) ?? undefined,
             tags: tool.tags,
             userDescription: tool.userDescription,
             modelDescription: tool.modelDescription,

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

@@ -3,6 +3,7 @@ import { SerializedError } from "@codingame/monaco-vscode-api/vscode/vs/base/com
 import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
 import { ILanguageModelIgnoredFilesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/ignoredFiles.service";
 import { IChatMessage, IChatResponsePart, ILanguageModelChatSelector } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
 import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
@@ -15,6 +16,7 @@ import { MainThreadLanguageModelsShape } from "@codingame/monaco-vscode-api/vsco
 export declare class MainThreadLanguageModels implements MainThreadLanguageModelsShape {
     private readonly _chatProviderService;
     private readonly _logService;
+    private readonly _productService;
     private readonly _authenticationService;
     private readonly _authenticationAccessService;
     private readonly _extensionService;
@@ -24,14 +26,16 @@ export declare class MainThreadLanguageModels implements MainThreadLanguageModel
     private readonly _providerRegistrations;
     private readonly _lmProviderChange;
     private readonly _pendingProgress;
+    private readonly _pendingCancelCTS;
     private readonly _ignoredFileProviderRegistrations;
-    constructor(extHostContext: IExtHostContext, _chatProviderService: ILanguageModelsService, _logService: ILogService, _authenticationService: IAuthenticationService, _authenticationAccessService: IAuthenticationAccessService, _extensionService: IExtensionService, _ignoredFilesService: ILanguageModelIgnoredFilesService);
+    constructor(extHostContext: IExtHostContext, _chatProviderService: ILanguageModelsService, _logService: ILogService, _productService: IProductService, _authenticationService: IAuthenticationService, _authenticationAccessService: IAuthenticationAccessService, _extensionService: IExtensionService, _ignoredFilesService: ILanguageModelIgnoredFilesService);
     dispose(): void;
     $registerLanguageModelProvider(vendor: string): void;
     $onLMProviderChange(vendor: string): void;
     $reportResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
     $reportResponseDone(requestId: number, err: SerializedError | undefined): Promise<void>;
     $unregisterProvider(vendor: string): void;
+    $cancelLanguageModelChatRequest(requestId: number): void;
     $selectChatModels(selector: ILanguageModelChatSelector): Promise<string[]>;
     $tryStartChatRequest(extension: ExtensionIdentifier, modelIdentifier: string, requestId: number, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: {}, token: CancellationToken): Promise<void>;
     $countTokens(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;