@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/api/common/extHostComments.js

@@ -7,7 +7,6 @@ import { Emitter } from '../../../base/common/event.js';
 import { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { URI } from '../../../base/common/uri.js';
 import { CommentThreadCollapsibleState, CommentThreadState as CommentThreadState$1, CommentThreadApplicability as CommentThreadApplicability$1 } from '../../../editor/common/languages.js';
-import { ExtensionIdentifierMap } from '../../../platform/extensions/common/extensions.js';
 import { Range, MarkdownString as MarkdownString$1, pathOrURIToURI } from './extHostTypeConverters.js';
 import { CommentThreadFocus, CommentThreadCollapsibleState as CommentThreadCollapsibleState$1, CommentThreadState, CommentThreadApplicability } from './extHostTypes.js';
 import { MainContext } from './extHost.protocol.js';
@@ -22,7 +21,6 @@ function createExtHostComments(mainContext, commands, documents) {
         }
         constructor() {
             this._commentControllers = ( new Map());
-            this._commentControllersByExtension = ( new ExtensionIdentifierMap());
             commands.registerArgumentProcessor({
                 processArgument: arg => {
                     if (arg && arg.$mid === MarshalledId.CommentController) {
@@ -101,11 +99,10 @@ function createExtHostComments(mainContext, commands, documents) {
         }
         createCommentController(extension, id, label) {
             const handle = ExtHostCommentsImpl.handlePool++;
-            const commentController = ( new ExtHostCommentController(extension, handle, id, label));
+            const commentController = ( new ExtHostCommentController(extension, handle, id, label, () => {
+                this._commentControllers.delete(handle);
+            }));
             this._commentControllers.set(commentController.handle, commentController);
-            const commentControllers = this._commentControllersByExtension.get(extension.identifier) || [];
-            commentControllers.push(commentController);
-            this._commentControllersByExtension.set(extension.identifier, commentControllers);
             return commentController.value;
         }
         async $createCommentThreadTemplate(commentControllerHandle, uriComponents, range, editorId) {
@@ -531,7 +528,7 @@ function createExtHostComments(mainContext, commands, documents) {
             checkProposedApiEnabled(this._extension, "activeComment");
             return this._activeThread?.value;
         }
-        constructor(_extension, _handle, _id, _label) {
+        constructor(_extension, _handle, _id, _label, onDidDispose) {
             this._extension = _extension;
             this._handle = _handle;
             this._id = _id;
@@ -576,6 +573,9 @@ function createExtHostComments(mainContext, commands, documents) {
                     proxy.$unregisterCommentController(this.handle);
                 }
             });
+            this._localDisposables.push({
+                dispose: onDidDispose
+            });
         }
         createCommentThread(resource, range, comments) {
             const commentThread = ( new ExtHostCommentThread(

package/vscode/src/vs/workbench/api/common/extHostCustomEditors.js

@@ -144,12 +144,12 @@ class ExtHostCustomEditors {
             disposables.add(this._editorProviders.addTextProvider(viewType, extension, provider));
             this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
                 supportsMove: !!provider.moveCustomTextEditor,
-                supportsInlineDiff: isProposedApiEnabled(extension) && isCustomTextEditorProviderWithInlineDiffCapability(provider),
-                supportsSideBySideDiff: isProposedApiEnabled(extension) && isCustomTextEditorProviderWithSideBySideDiffCapability(provider)
+                supportsInlineDiff: isProposedApiEnabled(extension, "customEditorDiffs") && isCustomTextEditorProviderWithInlineDiffCapability(provider),
+                supportsSideBySideDiff: isProposedApiEnabled(extension, "customEditorDiffs") && isCustomTextEditorProviderWithSideBySideDiffCapability(provider)
             }, shouldSerializeBuffersForPostMessage(extension));
         } else {
             disposables.add(this._editorProviders.addCustomProvider(viewType, extension, provider));
-            const supportsCustomEditorDiffs = isProposedApiEnabled(extension);
+            const supportsCustomEditorDiffs = isProposedApiEnabled(extension, "customEditorDiffs");
             if (isCustomEditorProviderWithEditingCapability(provider)) {
                 disposables.add(provider.onDidChangeCustomDocument(e => {
                     const entry = this.getCustomDocumentEntry(viewType, e.document.uri);

package/vscode/src/vs/workbench/api/common/extHostDataChannels.d.ts

@@ -1,15 +1,47 @@
 import type * as vscode from "vscode";
-import { ExtHostDataChannelsShape } from "./extHost.protocol.js";
+import { Event } from "../../../base/common/event.js";
+import { UriComponents } from "../../../base/common/uri.js";
+import { LinkPresentationKind } from "../../../platform/dataChannel/common/dataChannel.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
+import { ExtHostDataChannelsShape } from "./extHost.protocol.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
 export interface IExtHostDataChannels extends ExtHostDataChannelsShape {
     readonly _serviceBrand: undefined;
+    readonly linkPresentationRules: readonly vscode.LinkPresentationRule[];
+    readonly onDidChangeLinkPresentationRules: Event<void>;
     createDataChannel<T>(extension: IExtensionDescription, channelId: string): vscode.DataChannel<T>;
+    createLinkPresentationWatcher(extension: IExtensionDescription, providerId: string, resource: vscode.Uri): vscode.LinkPresentationWatcher;
+    registerLinkPresentationProvider(extension: IExtensionDescription, id: string, provider: vscode.LinkPresentationProvider): vscode.Disposable;
 }
 export declare const IExtHostDataChannels: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostDataChannels>;
 export declare class ExtHostDataChannels implements IExtHostDataChannels {
     readonly _serviceBrand: undefined;
     private readonly _channels;
-    constructor();
+    private readonly _linkPresentationWatchers;
+    private readonly _linkPresentationProviders;
+    private readonly _providedLinkPresentationWatchers;
+    private readonly _linkPresentationCache;
+    private readonly _onDidChangeLinkPresentationRules;
+    readonly onDidChangeLinkPresentationRules: Event<void>;
+    private _linkPresentationRules;
+    private static _linkPresentationWatcherHandlePool;
+    private static _linkPresentationProviderHandlePool;
+    private readonly _proxy;
+    constructor(extHostRpc: IExtHostRpcService);
+    get linkPresentationRules(): readonly vscode.LinkPresentationRule[];
     createDataChannel<T>(extension: IExtensionDescription, channelId: string): vscode.DataChannel<T>;
-    $onDidReceiveData(channelId: string, data: any): void;
+    createLinkPresentationWatcher(extension: IExtensionDescription, providerId: string, resource: vscode.Uri): vscode.LinkPresentationWatcher;
+    registerLinkPresentationProvider(extension: IExtensionDescription, id: string, provider: vscode.LinkPresentationProvider): vscode.Disposable;
+    $onDidReceiveData(channelId: string, data: unknown): void;
+    $acceptLinkPresentationRules(rules: readonly {
+        id: string;
+        source: string;
+        flags: string;
+        kind: LinkPresentationKind;
+    }[]): void;
+    $acceptLinkPresentation(handle: number, data: unknown): void;
+    $createLinkPresentationWatcher(handle: number, providerHandle: number, resource: UriComponents): Promise<unknown>;
+    $disposeLinkPresentationWatcher(handle: number): void;
+    private _getCachedLinkPresentation;
+    private _cacheLinkPresentation;
 }

package/vscode/src/vs/workbench/api/common/extHostDataChannels.js

@@ -1,13 +1,40 @@
 
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
 import { Emitter } from '../../../base/common/event.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { toDisposable, DisposableStore, Disposable } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { parseLinkPresentation } from '../../../platform/dataChannel/common/dataChannel.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { MainContext } from './extHost.protocol.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
 
+var ExtHostDataChannels_1;
 const IExtHostDataChannels = ( createDecorator("IExtHostDataChannels"));
-class ExtHostDataChannels {
-    constructor() {
+let ExtHostDataChannels = class ExtHostDataChannels {
+    static {
+        ExtHostDataChannels_1 = this;
+    }
+    static {
+        this._linkPresentationWatcherHandlePool = 0;
+    }
+    static {
+        this._linkPresentationProviderHandlePool = 0;
+    }
+    constructor(extHostRpc) {
         this._channels = ( new Map());
+        this._linkPresentationWatchers = ( new Map());
+        this._linkPresentationProviders = ( new Map());
+        this._providedLinkPresentationWatchers = ( new Map());
+        this._linkPresentationCache = ( new Map());
+        this._onDidChangeLinkPresentationRules = ( new Emitter());
+        this.onDidChangeLinkPresentationRules = this._onDidChangeLinkPresentationRules.event;
+        this._linkPresentationRules = [];
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadDataChannels));
+    }
+    get linkPresentationRules() {
+        return this._linkPresentationRules;
     }
     createDataChannel(extension, channelId) {
         checkProposedApiEnabled(extension, "dataChannels");
@@ -18,29 +45,161 @@ class ExtHostDataChannels {
         }
         return channel;
     }
+    createLinkPresentationWatcher(extension, providerId, resource) {
+        checkProposedApiEnabled(extension, "linkPresentation");
+        const resourceString = ( resource.toString(true));
+        const rule = this._linkPresentationRules.find(
+            rule => rule.id === providerId && matchesUriPattern(rule.uriPattern, resourceString)
+        );
+        if (!rule) {
+            throw ( new Error(
+                `Link presentation provider '${providerId}' does not accept '${resourceString}'.`
+            ));
+        }
+        const cacheKey = `${providerId}\0${resourceString}`;
+        const cachedPresentation = this._getCachedLinkPresentation(cacheKey, rule.kind);
+        const initialPresentation = {
+            ...(cachedPresentation ?? {
+                kind: rule.kind
+            }),
+            isLoading: true
+        };
+        const handle = ExtHostDataChannels_1._linkPresentationWatcherHandlePool++;
+        const watcher = ( new LinkPresentationWatcherImpl(
+            handle,
+            initialPresentation,
+            this._proxy,
+            disposedHandle => this._linkPresentationWatchers.delete(disposedHandle),
+            presentation => this._cacheLinkPresentation(cacheKey, presentation)
+        ));
+        this._linkPresentationWatchers.set(handle, watcher);
+        this._proxy.$createLinkPresentationWatcher(handle, providerId, rule.kind, resource);
+        return watcher;
+    }
+    registerLinkPresentationProvider(extension, id, provider) {
+        checkProposedApiEnabled(extension, "linkPresentation");
+        if (!id.trim()) {
+            throw ( new Error("Link presentation provider id must not be empty."));
+        }
+        const handle = ExtHostDataChannels_1._linkPresentationProviderHandlePool++;
+        this._linkPresentationProviders.set(handle, provider);
+        this._proxy.$registerLinkPresentationProvider(handle, extension.identifier.value, id);
+        return toDisposable(() => {
+            this._proxy.$unregisterLinkPresentationProvider(handle);
+            this._linkPresentationProviders.delete(handle);
+            for (const [watcherHandle, watcher] of this._providedLinkPresentationWatchers) {
+                if (watcher.providerHandle === handle) {
+                    watcher.store.dispose();
+                    this._providedLinkPresentationWatchers.delete(watcherHandle);
+                }
+            }
+        });
+    }
     $onDidReceiveData(channelId, data) {
-        const channel = this._channels.get(channelId);
-        if (channel) {
-            channel._fireDidReceiveData(data);
+        this._channels.get(channelId)?._fireDidReceiveData(data);
+    }
+    $acceptLinkPresentationRules(rules) {
+        this._linkPresentationRules = ( rules.map(rule => ({
+            id: rule.id,
+            uriPattern: ( new RegExp(rule.source, rule.flags)),
+            kind: rule.kind
+        })));
+        this._onDidChangeLinkPresentationRules.fire();
+    }
+    $acceptLinkPresentation(handle, data) {
+        this._linkPresentationWatchers.get(handle)?.acceptPresentation(data);
+    }
+    async $createLinkPresentationWatcher(handle, providerHandle, resource) {
+        const provider = this._linkPresentationProviders.get(providerHandle);
+        if (!provider) {
+            throw ( new Error(`Link presentation provider handle '${providerHandle}' is not registered.`));
+        }
+        const watcher = provider.provideLinkPresentationWatcher(URI.revive(resource), CancellationToken.None);
+        const store = ( new DisposableStore());
+        store.add(watcher);
+        store.add(watcher.onDidChangePresentation(() => {
+            this._proxy.$acceptLinkPresentationProviderData(handle, watcher.presentation);
+        }));
+        this._providedLinkPresentationWatchers.set(handle, {
+            providerHandle,
+            store
+        });
+        return watcher.presentation;
+    }
+    $disposeLinkPresentationWatcher(handle) {
+        const watcher = this._providedLinkPresentationWatchers.get(handle);
+        if (watcher) {
+            this._providedLinkPresentationWatchers.delete(handle);
+            watcher.store.dispose();
         }
     }
-}
+    _getCachedLinkPresentation(key, kind) {
+        const presentation = this._linkPresentationCache.get(key);
+        if (presentation?.kind !== kind) {
+            this._linkPresentationCache.delete(key);
+            return undefined;
+        }
+        if (presentation) {
+            this._linkPresentationCache.delete(key);
+            this._linkPresentationCache.set(key, presentation);
+        }
+        return presentation;
+    }
+    _cacheLinkPresentation(key, presentation) {
+        this._linkPresentationCache.delete(key);
+        this._linkPresentationCache.set(key, presentation);
+        while (this._linkPresentationCache.size > 100) {
+            const oldest = ( this._linkPresentationCache.keys()).next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            this._linkPresentationCache.delete(oldest);
+        }
+    }
+};
+ExtHostDataChannels = ExtHostDataChannels_1 = ( __decorate([( __param(0, IExtHostRpcService))], ExtHostDataChannels));
 class DataChannelImpl extends Disposable {
     constructor(channelId) {
         super();
         this.channelId = channelId;
-        this._onDidReceiveData = ( new Emitter());
+        this._onDidReceiveData = this._register(( new Emitter()));
         this.onDidReceiveData = this._onDidReceiveData.event;
-        this._register(this._onDidReceiveData);
     }
     _fireDidReceiveData(data) {
         this._onDidReceiveData.fire({
-            data
+            data: data
         });
     }
     toString() {
         return `DataChannel(${this.channelId})`;
     }
 }
+class LinkPresentationWatcherImpl extends Disposable {
+    get presentation() {
+        return this._presentation;
+    }
+    constructor(handle, initialPresentation, proxy, onDispose, _onDidAcceptPresentation) {
+        super();
+        this._onDidAcceptPresentation = _onDidAcceptPresentation;
+        this._onDidChangePresentation = this._register(( new Emitter()));
+        this.onDidChangePresentation = this._onDidChangePresentation.event;
+        this._presentation = initialPresentation;
+        this._register({
+            dispose: () => {
+                proxy.$disposeLinkPresentationWatcher(handle);
+                onDispose(handle);
+            }
+        });
+    }
+    acceptPresentation(data) {
+        this._presentation = parseLinkPresentation(data);
+        this._onDidAcceptPresentation(this._presentation);
+        this._onDidChangePresentation.fire();
+    }
+}
+function matchesUriPattern(pattern, value) {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+}
 
 export { ExtHostDataChannels, IExtHostDataChannels };

package/vscode/src/vs/workbench/api/common/extHostDiagnostics.js

@@ -125,7 +125,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2940,
+                            3183,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),
@@ -349,7 +349,11 @@ let ExtHostDiagnostics = class ExtHostDiagnostics {
             this._mirrorCollection = collection;
         }
         for (const [uri, markers] of data) {
-            this._mirrorCollection.set(URI.revive(uri), ( markers.map(Diagnostic.to)));
+            if (markers.length === 0) {
+                this._mirrorCollection.delete(URI.revive(uri));
+            } else {
+                this._mirrorCollection.set(URI.revive(uri), ( markers.map(Diagnostic.to)));
+            }
         }
     }
 };

package/vscode/src/vs/workbench/api/common/extHostEmbedding.d.ts

@@ -7,6 +7,7 @@ import type * as vscode from "vscode";
 export declare class ExtHostEmbeddings implements ExtHostEmbeddingsShape {
     private readonly _proxy;
     private readonly _provider;
+    private readonly _registeredModels;
     private readonly _onDidChange;
     readonly onDidChange: Event<void>;
     private _allKnownModels;

package/vscode/src/vs/workbench/api/common/extHostEmbedding.js

@@ -7,6 +7,7 @@ import { MainContext } from './extHost.protocol.js';
 class ExtHostEmbeddings {
     constructor(mainContext) {
         this._provider = ( new Map());
+        this._registeredModels = ( new Set());
         this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
         this._allKnownModels = ( new Set());
@@ -14,8 +15,10 @@ class ExtHostEmbeddings {
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadEmbeddings));
     }
     registerEmbeddingsProvider(_extension, embeddingsModel, provider) {
-        if (( this._allKnownModels.has(embeddingsModel))) {
-            throw ( new Error("An embeddings provider for this model is already registered"));
+        if (( this._registeredModels.has(embeddingsModel))) {
+            throw ( new Error(
+                `An embeddings provider for model '${embeddingsModel}' is already registered`
+            ));
         }
         const handle = this._handlePool++;
         this._proxy.$registerEmbeddingProvider(handle, embeddingsModel);
@@ -23,8 +26,9 @@ class ExtHostEmbeddings {
             id: embeddingsModel,
             provider
         });
+        this._registeredModels.add(embeddingsModel);
         return toDisposable(() => {
-            this._allKnownModels.delete(embeddingsModel);
+            this._registeredModels.delete(embeddingsModel);
             this._proxy.$unregisterEmbeddingProvider(handle);
             this._provider.delete(handle);
         });

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -377,7 +377,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             const that = this;
             let extension;
             let messagePassingProtocol;
-            const messagePort = isProposedApiEnabled(extensionDescription) ? this._initData.messagePorts?.get(ExtensionIdentifier.toKey(extensionDescription.identifier)) : undefined;
+            const messagePort = isProposedApiEnabled(extensionDescription, "ipc") ? this._initData.messagePorts?.get(ExtensionIdentifier.toKey(extensionDescription.identifier)) : undefined;
             return ( Object.freeze({
                 globalState,
                 workspaceState,
@@ -614,14 +614,14 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             extensionTestsLocationURI
         } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2941, "Cannot load test runner."))));
+            throw ( new Error(( localize(3184, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
         const testRunner = await (isESM ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))) : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== "function") {
             throw ( new Error(( localize(
-                2942,
+                3185,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));

package/vscode/src/vs/workbench/api/common/extHostFileSystemConsumer.d.ts

@@ -17,7 +17,7 @@ export declare class ExtHostConsumerFileSystem {
         isCaseSensitive?: boolean;
         isReadonly?: boolean | IMarkdownString;
     }): IDisposable;
-    getFileSystemProviderExtUri(scheme: string): IExtUri | import("../../../base/common/resources.js").ExtUri;
+    getFileSystemProviderExtUri(scheme: string): import("../../../base/common/resources.js").ExtUri | IExtUri;
 }
 export interface IExtHostConsumerFileSystem extends ExtHostConsumerFileSystem {
 }

package/vscode/src/vs/workbench/api/common/extHostLanguageFeatures.js

@@ -466,8 +466,8 @@ class CodeActionAdapter {
                     edit: toConvert.edit && WorkspaceEdit.from(toConvert.edit, undefined),
                     kind: toConvert.kind && toConvert.kind.value,
                     isPreferred: toConvert.isPreferred,
-                    isAI: isProposedApiEnabled(this._extension) ? toConvert.isAI : false,
-                    ranges: isProposedApiEnabled(this._extension) ? coalesce(( range.map(Range.from))) : undefined,
+                    isAI: isProposedApiEnabled(this._extension, "codeActionAI") ? toConvert.isAI : false,
+                    ranges: isProposedApiEnabled(this._extension, "codeActionRanges") ? coalesce(( range.map(Range.from))) : undefined,
                     disabled: toConvert.disabled?.reason
                 });
             }
@@ -574,7 +574,7 @@ class DocumentPasteEditProvider {
         return (edits.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2943,
+                3186,
                 "Paste using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -1147,16 +1147,16 @@ class InlineCompletionAdapter {
             [InlineCompletionTriggerKind$1.Automatic]: InlineCompletionTriggerKind.Automatic,
             [InlineCompletionTriggerKind$1.Explicit]: InlineCompletionTriggerKind.Invoke
         };
-        this._isAdditionsProposedApiEnabled = isProposedApiEnabled(this._extension);
+        this._isAdditionsProposedApiEnabled = isProposedApiEnabled(this._extension, "inlineCompletionsAdditions");
     }
     get supportsHandleEvents() {
-        return isProposedApiEnabled(this._extension) && (typeof this._provider.handleDidShowCompletionItem === "function" || typeof this._provider.handleDidPartiallyAcceptCompletionItem === "function" || typeof this._provider.handleDidRejectCompletionItem === "function" || typeof this._provider.handleEndOfLifetime === "function");
+        return isProposedApiEnabled(this._extension, "inlineCompletionsAdditions") && (typeof this._provider.handleDidShowCompletionItem === "function" || typeof this._provider.handleDidPartiallyAcceptCompletionItem === "function" || typeof this._provider.handleDidRejectCompletionItem === "function" || typeof this._provider.handleEndOfLifetime === "function");
     }
     get supportsSetModelId() {
-        return isProposedApiEnabled(this._extension) && typeof this._provider.setCurrentModelId === "function";
+        return isProposedApiEnabled(this._extension, "inlineCompletionsAdditions") && typeof this._provider.setCurrentModelId === "function";
     }
     get supportsSetProviderOption() {
-        return isProposedApiEnabled(this._extension) && typeof this._provider.setProviderOptionValue === "function";
+        return isProposedApiEnabled(this._extension, "inlineCompletionsAdditions") && typeof this._provider.setProviderOptionValue === "function";
     }
     get modelInfo() {
         if (!this._isAdditionsProposedApiEnabled) {
@@ -1833,7 +1833,7 @@ class DocumentDropEditAdapter {
         return (editsArray.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2944,
+                3187,
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -2504,21 +2504,21 @@ class ExtHostLanguageFeatures extends Disposable {
         const adapter = ( new InlineCompletionAdapter(extension, this._documents, provider, this._commands.converter));
         const handle = this._addNewAdapter(adapter, extension);
         let result = this._createDisposable(handle);
-        const supportsOnDidChange = isProposedApiEnabled(extension) && typeof provider.onDidChange === "function";
+        const supportsOnDidChange = isProposedApiEnabled(extension, "inlineCompletionsAdditions") && typeof provider.onDidChange === "function";
         if (supportsOnDidChange) {
             const subscription = provider.onDidChange(e => this._proxy.$emitInlineCompletionsChange(handle, e ? {
                 data: e.data
             } : undefined));
             result = Disposable$1.from(result, subscription);
         }
-        const supportsOnDidChangeModelInfo = isProposedApiEnabled(extension) && typeof provider.onDidChangeModelInfo === "function";
+        const supportsOnDidChangeModelInfo = isProposedApiEnabled(extension, "inlineCompletionsAdditions") && typeof provider.onDidChangeModelInfo === "function";
         if (supportsOnDidChangeModelInfo) {
             const subscription = provider.onDidChangeModelInfo(
                 _ => this._proxy.$emitInlineCompletionModelInfoChange(handle, adapter.modelInfo)
             );
             result = Disposable$1.from(result, subscription);
         }
-        const supportsOnDidChangeProviderOptions = isProposedApiEnabled(extension) && typeof provider.onDidChangeProviderOptions === "function";
+        const supportsOnDidChangeProviderOptions = isProposedApiEnabled(extension, "inlineCompletionsAdditions") && typeof provider.onDidChangeProviderOptions === "function";
         if (supportsOnDidChangeProviderOptions) {
             const subscription = provider.onDidChangeProviderOptions(
                 _ => this._proxy.$emitInlineCompletionProviderOptionsChange(handle, adapter.providerOptions)

package/vscode/src/vs/workbench/api/common/extHostLanguageModelTools.js

@@ -124,7 +124,7 @@ class ExtHostLanguageModelTools {
         }
     }
     getTools(extension) {
-        const hasParticipantAdditions = isProposedApiEnabled(extension);
+        const hasParticipantAdditions = isProposedApiEnabled(extension, "chatParticipantPrivate");
         return ( Array.from(( this._allTools.values())).map(
             tool => hasParticipantAdditions ? tool.apiObjectWithChatParticipantAdditions : tool.apiObject
         )).filter(tool => {
@@ -133,7 +133,7 @@ class ExtHostLanguageModelTools {
             case ExtensionEditToolId:
             case InternalFetchWebPageToolId:
             case SearchExtensionsToolId:
-                return isProposedApiEnabled(extension);
+                return isProposedApiEnabled(extension, "chatParticipantPrivate");
             default:
                 return true;
             }
@@ -148,7 +148,7 @@ class ExtHostLanguageModelTools {
             input: dto.parameters,
             toolInvocationToken: revive(dto.context)
         };
-        if (isProposedApiEnabled(item.extension)) {
+        if (isProposedApiEnabled(item.extension, "chatParticipantPrivate")) {
             options.chatRequestId = dto.chatRequestId;
             options.chatInteractionId = dto.chatInteractionId;
             options.chatSessionResource = URI.revive(dto.context?.sessionResource);
@@ -157,10 +157,10 @@ class ExtHostLanguageModelTools {
             options.traceparent = dto.traceparent;
             options.tracestate = dto.tracestate;
         }
-        if (isProposedApiEnabled(item.extension) && dto.modelId) {
+        if (isProposedApiEnabled(item.extension, "chatParticipantAdditions") && dto.modelId) {
             options.model = await this.getModel(dto.modelId, item.extension);
         }
-        if (isProposedApiEnabled(item.extension) && dto.chatStreamToolCallId) {
+        if (isProposedApiEnabled(item.extension, "chatParticipantAdditions") && dto.chatStreamToolCallId) {
             options.chatStreamToolCallId = dto.chatStreamToolCallId;
         }
         if (dto.tokenBudget !== undefined) {
@@ -170,7 +170,7 @@ class ExtHostLanguageModelTools {
             };
         }
         let progress;
-        if (isProposedApiEnabled(item.extension)) {
+        if (isProposedApiEnabled(item.extension, "toolProgress")) {
             let lastProgress;
             progress = {
                 report: value => {

package/vscode/src/vs/workbench/api/common/extHostLanguageModels.js

@@ -148,7 +148,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }, token)) ?? [];
         const modelMetadataAndIdentifier = ( modelInformation.map(m => {
             let auth;
-            if (m.requiresAuthorization && isProposedApiEnabled(data.extension)) {
+            if (m.requiresAuthorization && isProposedApiEnabled(data.extension, "chatProvider")) {
                 auth = {
                     providerLabel: data.extension.displayName || data.extension.name,
                     accountLabel: typeof m.requiresAuthorization === "object" ? m.requiresAuthorization.label : undefined
@@ -158,7 +158,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                 checkProposedApiEnabled(data.extension, "chatProvider");
             }
             const isDefaultForLocation = {};
-            if (isProposedApiEnabled(data.extension)) {
+            if (isProposedApiEnabled(data.extension, "chatProvider")) {
                 if (m.isDefault === true) {
                     for (const key of ( Object.values(ChatAgentLocation))) {
                         if (typeof key === "string") {
@@ -204,6 +204,8 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                     targetChatSessionType: m.targetChatSessionType,
                     configurationSchema: m.configurationSchema,
                     warningText: m.warningText,
+                    infoText: m.infoText,
+                    promo: m.promo,
                     capabilities: m.capabilities ? {
                         vision: m.capabilities.imageInput,
                         editTools: m.capabilities.editTools,
@@ -309,7 +311,8 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                 modelOptions: options.modelOptions ?? {},
                 modelConfiguration: options.configuration,
                 requestInitiator: from ? ExtensionIdentifier.toKey(from) : "core",
-                toolMode: options.toolMode ?? LanguageModelChatToolMode.Auto
+                toolMode: options.toolMode ?? LanguageModelChatToolMode.Auto,
+                includeEncryptedThinking: options.includeEncryptedThinking
             }, progress, providerToken);
         } catch (err) {
             this._pendingCancelCTS.deleteAndDispose(requestId);
@@ -531,7 +534,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             return false;
         }
         try {
-            const detail = justification ? ( localize(2945, "Justification: {1}", to.displayName, justification)) : undefined;
+            const detail = justification ? ( localize(3188, "Justification: {1}", to.displayName, justification)) : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], {
                 forceNewSession: {
                     detail

package/vscode/src/vs/workbench/api/common/extHostLogService.js

@@ -8,7 +8,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 let ExtHostLogService = class ExtHostLogService extends LogService {
     constructor(isWorker, loggerService, initData) {
         const id = initData.remote.isRemote ? "remoteexthost" : isWorker ? "workerexthost" : "exthost";
-        const name = initData.remote.isRemote ? ( localize(2946, "Extension Host (Remote)")) : isWorker ? ( localize(2947, "Extension Host (Worker)")) : ( localize(2948, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(3189, "Extension Host (Remote)")) : isWorker ? ( localize(3190, "Extension Host (Worker)")) : ( localize(3191, "Extension Host"));
         super(loggerService.createLogger(id, {
             name
         }));