@codingame/monaco-vscode-extensions-service-override 26.2.2 → 28.0.0

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

@@ -405,7 +405,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2504,
+                    2549,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -473,7 +473,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2505, "Edit")),
+            label: label ?? ( localize(2550, "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(2506, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2551, "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/mainThreadEditor.js

@@ -142,6 +142,7 @@ class MainThreadTextEditor {
     }
     dispose() {
         this._modelListeners.dispose();
+        this._onPropertiesChanged.dispose();
         this._codeEditor = null;
         this._codeEditorListeners.dispose();
     }

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(
-                    2507,
+                    2552,
                     "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(2508, "Reload Window")),
+                        label: ( localize(2553, "Reload Window")),
                         run: () => this._hostService.reload()
                     })]
                 }
@@ -130,7 +130,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2509,
+                        2554,
                         "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(
-                        2510,
+                        2555,
                         "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(2511, "Manage Workspace Trust")),
+                            label: ( localize(2556, "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(
-                        2512,
+                        2557,
                         "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(2513, "Enable and Reload")),
+                            label: ( localize(2558, "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(
-                        2514,
+                        2559,
                         "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(
-                    2515,
+                    2560,
                     "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(2516, "Install and Reload")),
+                        label: ( localize(2561, "Install and Reload")),
                         run: () => this._extensionsWorkbenchService.install(dependencyExtension).then(() => this._hostService.reload(), e => this._notificationService.error(e))
                     })]
                 }
             });
         } else {
             this._notificationService.error(( localize(
-                2517,
+                2562,
                 "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(
-                                2518,
+                                2563,
                                 "Extension '{0}' wants to make refactoring changes with this file creation",
                                 data.extensionNames[0]
                             ));
                         } else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                2519,
+                                2564,
                                 "Extension '{0}' wants to make refactoring changes with this file copy",
                                 data.extensionNames[0]
                             ));
                         } else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                2520,
+                                2565,
                                 "Extension '{0}' wants to make refactoring changes with this file move",
                                 data.extensionNames[0]
                             ));
                         } else  {
                             message = ( localize(
-                                2521,
+                                2566,
                                 "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(
-                                2522,
+                                2567,
                                 "{0} extensions want to make refactoring changes with this file creation",
                                 data.extensionNames.length
                             ));
                         } else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                2523,
+                                2568,
                                 "{0} extensions want to make refactoring changes with this file copy",
                                 data.extensionNames.length
                             ));
                         } else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                2524,
+                                2569,
                                 "{0} extensions want to make refactoring changes with this file move",
                                 data.extensionNames.length
                             ));
                         } else  {
                             message = ( localize(
-                                2525,
+                                2570,
                                 "{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(2526, "Show &&Preview")),
-                            cancelButton: ( localize(2527, "Skip Changes"))
+                            primaryButton: ( localize(2571, "Show &&Preview")),
+                            cancelButton: ( localize(2572, "Skip Changes"))
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -171,18 +171,18 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                             type: Severity.Info,
                             message,
                             buttons: [{
-                                label: ( localize(2528, "&&OK")),
+                                label: ( localize(2573, "&&OK")),
                                 run: () => Choice.OK
                             }, {
-                                label: ( localize(2526, "Show &&Preview")),
+                                label: ( localize(2571, "Show &&Preview")),
                                 run: () => Choice.Preview
                             }],
                             cancelButton: {
-                                label: ( localize(2527, "Skip Changes")),
+                                label: ( localize(2572, "Skip Changes")),
                                 run: () => Choice.Cancel
                             },
                             checkbox: {
-                                label: ( localize(2529, "Do not ask me again"))
+                                label: ( localize(2574, "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(2530, "Running 'File Create' participants...");
+                    return localize(2575, "Running 'File Create' participants...");
                 case FileOperation.MOVE:
-                    return localize(2531, "Running 'File Rename' participants...");
+                    return localize(2576, "Running 'File Rename' participants...");
                 case FileOperation.COPY:
-                    return localize(2532, "Running 'File Copy' participants...");
+                    return localize(2577, "Running 'File Copy' participants...");
                 case FileOperation.DELETE:
-                    return localize(2533, "Running 'File Delete' participants...");
+                    return localize(2578, "Running 'File Delete' participants...");
                 case FileOperation.WRITE:
-                    return localize(2534, "Running 'File Write' participants...");
+                    return localize(2579, "Running 'File Write' participants...");
                 }
             }
         })();
@@ -307,7 +307,7 @@ registerAction2(class ResetMemento extends Action2 {
         super({
             id: "files.participants.resetChoice",
             title: {
-                value: ( localize(2535, "Reset choice for 'File operation needs preview'")),
+                value: ( localize(2580, "Reset choice for 'File operation needs preview'")),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true

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

@@ -0,0 +1,21 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IGitExtensionDelegate, GitRef, GitRefQuery, IGitRepository } from "../../contrib/git/common/gitService.js";
+import { IGitService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/gitService.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { MainThreadGitExtensionShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadGitExtensionService extends Disposable implements MainThreadGitExtensionShape, IGitExtensionDelegate {
+    private readonly gitService;
+    private readonly _proxy;
+    private readonly _openRepositorySequencer;
+    private _repositoryHandles;
+    private _repositories;
+    get repositories(): Iterable<IGitRepository>;
+    constructor(extHostContext: IExtHostContext, gitService: IGitService);
+    private _initializeDelegate;
+    private _getRepositoryByUri;
+    openRepository(uri: URI): Promise<IGitRepository | undefined>;
+    getRefs(root: URI, query: GitRefQuery, token?: CancellationToken): Promise<GitRef[]>;
+    $onDidChangeRepository(handle: number): Promise<void>;
+}

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

@@ -0,0 +1,111 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { GitRepository } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/browser/gitService';
+import { GitRefType } from '../../contrib/git/common/gitService.js';
+import { IGitService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/gitService.service';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { GitRefTypeDto, ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+function toGitRefType(type) {
+    switch (type) {
+    case GitRefTypeDto.Head:
+        return GitRefType.Head;
+    case GitRefTypeDto.RemoteHead:
+        return GitRefType.RemoteHead;
+    case GitRefTypeDto.Tag:
+        return GitRefType.Tag;
+    default:
+        throw ( new Error(`Unknown GitRefType: ${type}`));
+    }
+}
+function toGitRepositoryState(dto) {
+    return {
+        HEAD: dto?.HEAD ? {
+            type: toGitRefType(dto.HEAD.type),
+            name: dto.HEAD.name,
+            commit: dto.HEAD.commit,
+            remote: dto.HEAD.remote,
+            upstream: dto.HEAD.upstream,
+            ahead: dto.HEAD.ahead,
+            behind: dto.HEAD.behind
+        } : undefined
+    };
+}
+let MainThreadGitExtensionService = class MainThreadGitExtensionService extends Disposable {
+    get repositories() {
+        return ( this._repositories.values());
+    }
+    constructor(extHostContext, gitService) {
+        super();
+        this.gitService = gitService;
+        this._openRepositorySequencer = ( new Sequencer());
+        this._repositoryHandles = ( new ResourceMap());
+        this._repositories = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostGitExtension));
+        this._initializeDelegate();
+    }
+    async _initializeDelegate() {
+        const isExtensionAvailable = await this._proxy.$isGitExtensionAvailable();
+        if (isExtensionAvailable && !this._store.isDisposed) {
+            this._register(this.gitService.setDelegate(this));
+        }
+    }
+    _getRepositoryByUri(uri) {
+        const handle = this._repositoryHandles.get(uri);
+        return handle !== undefined ? this._repositories.get(handle) : undefined;
+    }
+    async openRepository(uri) {
+        return this._openRepositorySequencer.queue(async () => {
+            const existingRepository = this._getRepositoryByUri(uri);
+            if (existingRepository) {
+                return existingRepository;
+            }
+            const result = await this._proxy.$openRepository(uri);
+            if (!result) {
+                return undefined;
+            }
+            const repositoryRootUri = URI.revive(result.rootUri);
+            const existingRepositoryForRoot = this._getRepositoryByUri(repositoryRootUri);
+            if (existingRepositoryForRoot) {
+                return existingRepositoryForRoot;
+            }
+            const state = toGitRepositoryState(result.state);
+            const repository = ( new GitRepository(repositoryRootUri, state, this));
+            this._repositories.set(result.handle, repository);
+            this._repositoryHandles.set(repositoryRootUri, result.handle);
+            return repository;
+        });
+    }
+    async getRefs(root, query, token) {
+        const handle = this._repositoryHandles.get(root);
+        if (handle === undefined) {
+            return [];
+        }
+        const result = await this._proxy.$getRefs(handle, query, token);
+        if (token?.isCancellationRequested) {
+            return [];
+        }
+        return ( result.map(ref => ({
+            ...ref,
+            type: toGitRefType(ref.type)
+        })));
+    }
+    async $onDidChangeRepository(handle) {
+        const repository = this._repositories.get(handle);
+        if (!repository) {
+            return;
+        }
+        const state = await this._proxy.$getRepositoryState(handle);
+        if (!state) {
+            return;
+        }
+        repository.updateState(toGitRepositoryState(state));
+    }
+};
+MainThreadGitExtensionService = __decorate([extHostNamedCustomer(MainContext.MainThreadGitExtension), ( __param(1, IGitService))], MainThreadGitExtensionService);
+
+export { MainThreadGitExtensionService };

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

@@ -11,7 +11,7 @@ import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs
 import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
-import { ExtHostLanguageFeaturesShape, ICodeActionProviderMetadataDto, IDocumentDropEditProviderMetadata, IDocumentFilterDto, IInlineCompletionChangeHintDto, IInlineCompletionModelInfoDto, ILanguageConfigurationDto, IPasteEditProviderMetadataDto, ISignatureHelpProviderMetadataDto, MainThreadLanguageFeaturesShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { ExtHostLanguageFeaturesShape, ICodeActionProviderMetadataDto, IDocumentDropEditProviderMetadata, IDocumentFilterDto, IInlineCompletionChangeHintDto, IInlineCompletionModelInfoDto, IInlineCompletionProviderOptionDto, ILanguageConfigurationDto, IPasteEditProviderMetadataDto, ISignatureHelpProviderMetadataDto, MainThreadLanguageFeaturesShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IInlineCompletionsUnificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/inlineCompletions/common/inlineCompletionsUnification.service";
 export declare class MainThreadLanguageFeatures extends Disposable implements MainThreadLanguageFeaturesShape {
@@ -63,9 +63,10 @@ export declare class MainThreadLanguageFeatures extends Disposable implements Ma
     $registerDocumentRangeSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: languages.SemanticTokensLegend, eventHandle: number | undefined): void;
     private static _inflateSuggestDto;
     $registerCompletionsProvider(handle: number, selector: IDocumentFilterDto[], triggerCharacters: string[], supportsResolveDetails: boolean, extensionId: ExtensionIdentifier): void;
-    $registerInlineCompletionsSupport(handle: number, selector: IDocumentFilterDto[], supportsHandleEvents: boolean, extensionId: string, extensionVersion: string, groupId: string | undefined, yieldsToExtensionIds: string[], displayName: string | undefined, debounceDelayMs: number | undefined, excludesExtensionIds: string[], supportsOnDidChange: boolean, supportsSetModelId: boolean, initialModelInfo: IInlineCompletionModelInfoDto | undefined, supportsOnDidChangeModelInfo: boolean): void;
+    $registerInlineCompletionsSupport(handle: number, selector: IDocumentFilterDto[], supportsHandleEvents: boolean, extensionId: string, extensionVersion: string, groupId: string | undefined, yieldsToExtensionIds: string[], displayName: string | undefined, debounceDelayMs: number | undefined, excludesExtensionIds: string[], supportsOnDidChange: boolean, supportsSetModelId: boolean, initialModelInfo: IInlineCompletionModelInfoDto | undefined, supportsOnDidChangeModelInfo: boolean, supportsSetProviderOption: boolean, initialProviderOptions: readonly IInlineCompletionProviderOptionDto[] | undefined, supportsOnDidChangeProviderOptions: boolean): void;
     $emitInlineCompletionsChange(handle: number, changeHint: IInlineCompletionChangeHintDto | undefined): void;
     $emitInlineCompletionModelInfoChange(handle: number, data: IInlineCompletionModelInfoDto | undefined): void;
+    $emitInlineCompletionProviderOptionsChange(handle: number, data: readonly IInlineCompletionProviderOptionDto[] | undefined): void;
     $registerSignatureHelpProvider(handle: number, selector: IDocumentFilterDto[], metadata: ISignatureHelpProviderMetadataDto): void;
     $registerInlayHintsProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean, eventHandle: number | undefined, displayName: string | undefined): void;
     $emitInlayHintsEvent(eventHandle: number): void;

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

@@ -598,7 +598,10 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         supportsOnDidChange,
         supportsSetModelId,
         initialModelInfo,
-        supportsOnDidChangeModelInfo
+        supportsOnDidChangeModelInfo,
+        supportsSetProviderOption,
+        initialProviderOptions,
+        supportsOnDidChangeProviderOptions
     ) {
         const providerId = new ProviderId(extensionId, extensionVersion, groupId);
         const provider = this._instantiationService.createInstance(
@@ -615,6 +618,9 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             supportsSetModelId,
             supportsOnDidChange,
             supportsOnDidChangeModelInfo,
+            initialProviderOptions,
+            supportsSetProviderOption,
+            supportsOnDidChangeProviderOptions,
             selector,
             this._proxy
         );
@@ -632,6 +638,12 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             obj._setModelInfo(data);
         }
     }
+    $emitInlineCompletionProviderOptionsChange(handle, data) {
+        const obj = this._registrations.get(handle);
+        if (obj instanceof ExtensionBackedInlineCompletionsProvider) {
+            obj._setProviderOptions(data);
+        }
+    }
     $registerSignatureHelpProvider(handle, selector, metadata) {
         this._registrations.set(
             handle,
@@ -1175,6 +1187,9 @@ let ExtensionBackedInlineCompletionsProvider = class ExtensionBackedInlineComple
         _supportsSetModelId,
         _supportsOnDidChange,
         _supportsOnDidChangeModelInfo,
+        providerOptions,
+        _supportsSetProviderOption,
+        _supportsOnDidChangeProviderOptions,
         _selector,
         _proxy,
         _languageFeaturesService,
@@ -1194,18 +1209,26 @@ let ExtensionBackedInlineCompletionsProvider = class ExtensionBackedInlineComple
         this._supportsSetModelId = _supportsSetModelId;
         this._supportsOnDidChange = _supportsOnDidChange;
         this._supportsOnDidChangeModelInfo = _supportsOnDidChangeModelInfo;
+        this.providerOptions = providerOptions;
+        this._supportsSetProviderOption = _supportsSetProviderOption;
+        this._supportsOnDidChangeProviderOptions = _supportsOnDidChangeProviderOptions;
         this._selector = _selector;
         this._proxy = _proxy;
         this._languageFeaturesService = _languageFeaturesService;
         this._aiEditTelemetryService = _aiEditTelemetryService;
         this._instantiationService = _instantiationService;
-        this._onDidChangeEmitter = ( new Emitter());
-        this._onDidChangeModelInfoEmitter = ( new Emitter());
+        this._onDidChangeEmitter = this._register(( new Emitter()));
+        this._onDidChangeModelInfoEmitter = this._register(( new Emitter()));
+        this._onDidProviderOptionsChangeEmitter = this._register(( new Emitter()));
         this.setModelId = this._supportsSetModelId ? async modelId => {
             await this._proxy.$handleInlineCompletionSetCurrentModelId(this.handle, modelId);
         } : undefined;
+        this.setProviderOption = this._supportsSetProviderOption ? async (optionId, valueId) => {
+            await this._proxy.$handleInlineCompletionSetProviderOption(this.handle, optionId, valueId);
+        } : undefined;
         this.onDidChangeInlineCompletions = this._supportsOnDidChange ? this._onDidChangeEmitter.event : undefined;
         this.onDidChangeModelInfo = this._supportsOnDidChangeModelInfo ? this._onDidChangeModelInfoEmitter.event : undefined;
+        this.onDidProviderOptionsChange = this._supportsOnDidChangeProviderOptions ? this._onDidProviderOptionsChangeEmitter.event : undefined;
         this._register(
             this._languageFeaturesService.inlineCompletionsProvider.register(this._selector, this)
         );
@@ -1216,6 +1239,12 @@ let ExtensionBackedInlineCompletionsProvider = class ExtensionBackedInlineComple
             this._onDidChangeModelInfoEmitter.fire();
         }
     }
+    _setProviderOptions(newProviderOptions) {
+        this.providerOptions = newProviderOptions;
+        if (this._supportsOnDidChangeProviderOptions) {
+            this._onDidProviderOptionsChangeEmitter.fire();
+        }
+    }
     _emitDidChange(changeHint) {
         if (this._supportsOnDidChange) {
             this._onDidChangeEmitter.fire(changeHint);
@@ -1350,7 +1379,7 @@ let ExtensionBackedInlineCompletionsProvider = class ExtensionBackedInlineComple
         return `InlineCompletionsProvider(${( this.providerId.toString())})`;
     }
 };
-ExtensionBackedInlineCompletionsProvider = ( __decorate([( __param(14, ILanguageFeaturesService)), ( __param(15, IAiEditTelemetryService)), ( __param(16, IInstantiationService))], ExtensionBackedInlineCompletionsProvider));
+ExtensionBackedInlineCompletionsProvider = ( __decorate([( __param(17, ILanguageFeaturesService)), ( __param(18, IAiEditTelemetryService)), ( __param(19, IInstantiationService))], ExtensionBackedInlineCompletionsProvider));
 function extractEngineFromCorrelationId(correlationId) {
     if (!correlationId) {
         return undefined;

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

@@ -49,7 +49,8 @@ let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Di
         );
         const out = {
             content: result.content,
-            toolMetadata: result.toolMetadata
+            toolMetadata: result.toolMetadata,
+            toolResultError: result.toolResultError
         };
         return toolResultHasBuffers(result) ? ( new SerializableObjectWithBuffers(out)) : out;
     }

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

@@ -178,11 +178,13 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         if (this._authenticationService.getProviderIds().includes(authProviderId)) {
             return Disposable.None;
         }
-        const accountLabel = auth.accountLabel ?? ( localize(2536, "Language Models"));
+        const accountLabel = auth.accountLabel ?? ( localize(2581, "Language Models"));
         const disposables = ( new DisposableStore());
-        this._authenticationService.registerAuthenticationProvider(authProviderId, ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel)));
+        const provider = ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel));
+        this._authenticationService.registerAuthenticationProvider(authProviderId, provider);
         disposables.add(toDisposable(() => {
             this._authenticationService.unregisterAuthenticationProvider(authProviderId);
+            provider.dispose();
         }));
         disposables.add(
             this._authenticationAccessService.onDidChangeExtensionSessionAccess(async e => {
@@ -259,7 +261,7 @@ class LanguageModelAccessAuthProvider {
     }
     confirmation(extensionName, _recreatingSession) {
         return localize(
-            2537,
+            2582,
             "The extension '{0}' wants to access the language models provided by {1}.",
             extensionName,
             this.label
@@ -276,6 +278,9 @@ class LanguageModelAccessAuthProvider {
             scopes
         };
     }
+    dispose() {
+        this._onDidChangeSessions.dispose();
+    }
 }
 
 export { MainThreadLanguageModels };

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

@@ -2,8 +2,8 @@ import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buf
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ManagedSocket, RemoteSocketHalf } from "../../../platform/remote/common/managedSocket.js";
 import { IRemoteSocketFactoryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteSocketFactoryService.service";
-import { ExtHostManagedSocketsShape, MainThreadManagedSocketsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { ExtHostManagedSocketsShape, MainThreadManagedSocketsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class MainThreadManagedSockets extends Disposable implements MainThreadManagedSocketsShape {
     private readonly _remoteSocketFactoryService;
     private readonly _proxy;

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

@@ -1,24 +1,25 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { SocketCloseEventType } from '@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc.net';
 import { ManagedSocket, connectManagedSocket } from '../../../platform/remote/common/managedSocket.js';
 import { RemoteConnectionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteAuthorityResolver';
 import { IRemoteSocketFactoryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteSocketFactoryService.service';
-import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 
 let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable {
     constructor(extHostContext, _remoteSocketFactoryService) {
         super();
         this._remoteSocketFactoryService = _remoteSocketFactoryService;
-        this._registrations = ( new Map());
+        this._registrations = this._register(( new DisposableMap()));
         this._remoteSockets = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostManagedSockets));
     }
     async $registerSocketFactory(socketFactoryId) {
         const that = this;
+        const store = ( new DisposableStore());
         const socketFactory = new (class {
             supports(connectTo) {
                 return (connectTo.id === socketFactoryId);
@@ -37,7 +38,9 @@ let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable
                         };
                         that._remoteSockets.set(socketId, half);
                         MainThreadManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half).then(socket => {
-                            socket.onDidDispose(() => that._remoteSockets.delete(socketId));
+                            store.add(
+                                Event.once(socket.onDidDispose)(() => that._remoteSockets.delete(socketId))
+                            );
                             resolve(socket);
                         }, err => {
                             that._remoteSockets.delete(socketId);
@@ -47,13 +50,13 @@ let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable
                 }));
             }
         })();
-        this._registrations.set(
-            socketFactoryId,
+        store.add(
             this._remoteSocketFactoryService.register(RemoteConnectionType.Managed, socketFactory)
         );
+        this._registrations.set(socketFactoryId, store);
     }
     async $unregisterSocketFactory(socketFactoryId) {
-        this._registrations.get(socketFactoryId)?.dispose();
+        this._registrations.deleteAndDispose(socketFactoryId);
     }
     $onDidManagedSocketHaveData(socketId, data) {
         this._remoteSockets.get(socketId)?.onData.fire(data);