@codingame/monaco-vscode-api 37.6.0 → 38.0.0

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

@@ -733,7 +733,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const chatRequest = ChatAgentRequest.to(
             request,
             undefined,
-            await this.getModelForRequest(request, entry.sessionObj.extension),
+            await this._languageModels.getLanguageModelForRequest(entry.sessionObj.extension, request.userSelectedModelId),
             request.modelConfiguration,
             [],
             ( new Map()),
@@ -877,19 +877,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             };
         });
     }
-    async getModelForRequest(request, extension) {
-        let model;
-        if (request.userSelectedModelId) {
-            model = await this._languageModels.getLanguageModelByIdentifier(extension, request.userSelectedModelId);
-        }
-        if (!model) {
-            model = await this._languageModels.getDefaultLanguageModel(extension);
-            if (!model) {
-                throw ( new Error("Language model unavailable"));
-            }
-        }
-        return model;
-    }
     convertRequestTurn(turn) {
         const variables = turn.references.map(ref => this.convertReferenceToVariable(ref));
         return {

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

@@ -54,9 +54,18 @@ class ExtHostCodeMapper {
         const handle = ExtHostCodeMapper._providerHandlePool++;
         this._proxy.$registerCodeMapperProvider(handle, extension.displayName ?? extension.name);
         this.providers.set(handle, provider);
+        let disposed = false;
         return {
-            dispose: () => {
-                return this._proxy.$unregisterCodeMapperProvider(handle);
+            dispose: async () => {
+                if (disposed) {
+                    return;
+                }
+                disposed = true;
+                try {
+                    await this._proxy.$unregisterCodeMapperProvider(handle);
+                } finally {
+                    this.providers.delete(handle);
+                }
             }
         };
     }

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

@@ -8,7 +8,7 @@ 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 { Range, MarkdownString as MarkdownString$1, pathOrURIToURI } from './extHostTypeConverters.js';
-import { CommentThreadFocus, CommentThreadCollapsibleState as CommentThreadCollapsibleState$1, CommentThreadState, CommentThreadApplicability } from './extHostTypes.js';
+import { Disposable, CommentThreadFocus, CommentThreadCollapsibleState as CommentThreadCollapsibleState$1, CommentThreadState, CommentThreadApplicability } from './extHostTypes.js';
 import { MainContext } from './extHost.protocol.js';
 import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MarkdownString } from './extHostTypes/markdownString.js';
@@ -287,6 +287,7 @@ function createExtHostComments(mainContext, commands, documents) {
             _comments,
             extensionDescription,
             _isTemplate,
+            onDidDispose,
             editorId
         ) {
             this._commentControllerHandle = _commentControllerHandle;
@@ -321,7 +322,7 @@ function createExtHostComments(mainContext, commands, documents) {
                 this._isTemplate,
                 editorId
             );
-            this._localDisposables = [];
+            this._localDisposables = [new Disposable(onDidDispose)];
             this._isDiposed = false;
             this._localDisposables.push(this.onDidUpdateCommentThread(() => {
                 this.eventuallyUpdateCommentThread();
@@ -476,6 +477,9 @@ function createExtHostComments(mainContext, commands, documents) {
             return proxy.$hideCommentThread(this._commentControllerHandle, this.handle);
         }
         dispose() {
+            if (this._isDiposed) {
+                return;
+            }
             this._isDiposed = true;
             this._acceptInputDisposables.dispose();
             this._onDidUpdateCommentThread.dispose();
@@ -586,7 +590,10 @@ function createExtHostComments(mainContext, commands, documents) {
                 range,
                 comments,
                 this._extension,
-                false
+                false,
+                () => {
+                    this._threads.delete(commentThread.handle);
+                }
             ));
             this._threads.set(commentThread.handle, commentThread);
             return commentThread;
@@ -613,6 +620,9 @@ function createExtHostComments(mainContext, commands, documents) {
                 [],
                 this._extension,
                 true,
+                () => {
+                    this._threads.delete(commentThread.handle);
+                },
                 editorId
             ));
             commentThread.collapsibleState = CommentThreadCollapsibleState.Expanded;

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

@@ -1,5 +1,7 @@
 import { VSBuffer } from "../../../base/common/buffer.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
+import { IRange } from "../../../editor/common/core/range.js";
+import { ISelection } from "../../../editor/common/core/selection.js";
 import { UriComponents } from "../../../base/common/uri.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { ExtHostDocuments } from "./extHostDocuments.js";
@@ -17,6 +19,7 @@ export declare class ExtHostCustomEditors implements extHostProtocol.ExtHostCust
     private readonly _proxy;
     private readonly _editorProviders;
     private readonly _documents;
+    private readonly _navigation;
     constructor(mainContext: extHostProtocol.IMainContext, _extHostDocuments: ExtHostDocuments, _extensionStoragePaths: IExtensionStoragePaths | undefined, _extHostWebview: ExtHostWebviews, _extHostWebviewPanels: ExtHostWebviewPanels);
     registerCustomEditorProvider(extension: IExtensionDescription, viewType: string, provider: vscode.CustomReadonlyEditorProvider | vscode.CustomTextEditorProvider, options: {
         webviewOptions?: vscode.WebviewPanelOptions;
@@ -32,6 +35,14 @@ export declare class ExtHostCustomEditors implements extHostProtocol.ExtHostCust
         options: extHostProtocol.IWebviewPanelOptions;
         active: boolean;
     }, position: EditorGroupColumn, cancellation: CancellationToken): Promise<void>;
+    $resolveCustomTextEditorNavigation(handle: extHostProtocol.WebviewHandle, viewType: string, resource: UriComponents, token: CancellationToken): Promise<{
+        selection: ISelection | undefined;
+    } | undefined>;
+    $disposeCustomTextEditorNavigation(handle: extHostProtocol.WebviewHandle): void;
+    $revealCustomTextEditorRange(handle: extHostProtocol.WebviewHandle, range: IRange, selection: ISelection | undefined, preserveFocus: boolean, token: CancellationToken): Promise<void>;
+    $captureCustomTextEditorViewState(handle: extHostProtocol.WebviewHandle, stateId: number): Promise<void>;
+    $restoreCustomTextEditorViewState(handle: extHostProtocol.WebviewHandle, stateId: number, token: CancellationToken): Promise<void>;
+    $releaseCustomTextEditorViewState(handle: extHostProtocol.WebviewHandle, stateId: number): void;
     $resolveCustomEditorInlineDiff(originalResource: UriComponents, modifiedResource: UriComponents, handle: extHostProtocol.WebviewHandle, viewType: string, initData: extHostProtocol.CustomEditorDiffInitData, position: EditorGroupColumn, cancellation: CancellationToken): Promise<void>;
     $resolveCustomEditorSideBySideDiff(originalResource: UriComponents, modifiedResource: UriComponents, webviewHandles: extHostProtocol.CustomEditorSideBySideDiffWebviewHandles, viewType: string, initData: extHostProtocol.CustomEditorSideBySideDiffInitData, position: EditorGroupColumn, cancellation: CancellationToken): Promise<void>;
     private createCustomEditorDiffPanel;

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

@@ -1,16 +1,17 @@
 
-import { CancellationToken } from '../../../base/common/cancellation.js';
+import { CancellationTokenSource, CancellationToken } from '../../../base/common/cancellation.js';
+import { isCancellationError, onUnexpectedError } from '../../../base/common/errors.js';
 import { hash } from '../../../base/common/hash.js';
-import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
 import { Schemas } from '../../../base/common/network.js';
 import { joinPath } from '../../../base/common/resources.js';
 import { URI } from '../../../base/common/uri.js';
-import { ViewColumn } from './extHostTypeConverters.js';
+import { ViewColumn, Selection, Range } from './extHostTypeConverters.js';
 import { toExtensionData, shouldSerializeBuffersForPostMessage } from './extHostWebview.js';
 import { Cache } from './cache.js';
 import { MainContext } from './extHost.protocol.js';
 import { Disposable } from './extHostTypes.js';
-import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 
 class CustomDocumentStoreEntry {
     constructor(document, _storagePath) {
@@ -136,14 +137,19 @@ class ExtHostCustomEditors {
         this._extHostWebviewPanels = _extHostWebviewPanels;
         this._editorProviders = ( new EditorProviderStore());
         this._documents = ( new CustomDocumentStore());
+        this._navigation = ( new Map());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadCustomEditors));
     }
     registerCustomEditorProvider(extension, viewType, provider, options) {
+        if (isCustomTextEditorProvider(provider) && provider.resolveCustomTextEditorNavigation) {
+            checkProposedApiEnabled(extension, "customTextEditorNavigation");
+        }
         const disposables = ( new DisposableStore());
         if (isCustomTextEditorProvider(provider)) {
             disposables.add(this._editorProviders.addTextProvider(viewType, extension, provider));
             this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
                 supportsMove: !!provider.moveCustomTextEditor,
+                supportsNavigation: !!provider.resolveCustomTextEditorNavigation,
                 supportsInlineDiff: isProposedApiEnabled(extension, "customEditorDiffs") && isCustomTextEditorProviderWithInlineDiffCapability(provider),
                 supportsSideBySideDiff: isProposedApiEnabled(extension, "customEditorDiffs") && isCustomTextEditorProviderWithSideBySideDiffCapability(provider)
             }, shouldSerializeBuffersForPostMessage(extension));
@@ -166,6 +172,13 @@ class ExtHostCustomEditors {
                 supportsSideBySideDiff: supportsCustomEditorDiffs && isCustomEditorProviderWithSideBySideDiffCapability(provider)
             }, !!options.supportsMultipleEditorsPerDocument, shouldSerializeBuffersForPostMessage(extension));
         }
+        disposables.add(toDisposable(() => {
+            for (const [handle, entry] of this._navigation) {
+                if (entry.viewType === viewType) {
+                    this.$disposeCustomTextEditorNavigation(handle);
+                }
+            }
+        }));
         return Disposable.from(disposables, new Disposable(() => {
             this._proxy.$unregisterEditorProvider(viewType);
         }));
@@ -193,13 +206,6 @@ class ExtHostCustomEditors {
         };
     }
     async $disposeCustomDocument(resource, viewType) {
-        const entry = this._editorProviders.get(viewType);
-        if (!entry) {
-            throw ( new Error(`No provider found for '${viewType}'`));
-        }
-        if (entry.type !== CustomEditorType.Custom) {
-            throw ( new Error(`Invalid provider type for '${viewType}'`));
-        }
         const revivedResource = URI.revive(resource);
         const {
             document
@@ -244,6 +250,98 @@ class ExtHostCustomEditors {
             }
         }
     }
+    async $resolveCustomTextEditorNavigation(handle, viewType, resource, token) {
+        const provider = this._editorProviders.get(viewType);
+        const panel = this._extHostWebviewPanels.getWebviewPanel(handle);
+        if (provider?.type !== CustomEditorType.Text || !provider.provider.resolveCustomTextEditorNavigation || !panel || token.isCancellationRequested) {
+            return undefined;
+        }
+        checkProposedApiEnabled(provider.extension, "customTextEditorNavigation");
+        this.$disposeCustomTextEditorNavigation(handle);
+        const entry = {
+            viewType,
+            disposables: ( new DisposableStore()),
+            states: ( new Map()),
+            pendingStates: ( new Set())
+        };
+        this._navigation.set(handle, entry);
+        const cancellation = ( new CancellationTokenSource(token));
+        entry.disposables.add(toDisposable(() => cancellation.dispose(true)));
+        entry.disposables.add(panel.onDidDispose(() => this.$disposeCustomTextEditorNavigation(handle)));
+        try {
+            const controller = await provider.provider.resolveCustomTextEditorNavigation(
+                this._extHostDocuments.getDocument(URI.revive(resource)),
+                panel,
+                cancellation.token
+            );
+            if (cancellation.token.isCancellationRequested || this._navigation.get(handle) !== entry) {
+                controller.dispose();
+                this.$disposeCustomTextEditorNavigation(handle);
+                return undefined;
+            }
+            entry.controller = controller;
+            entry.disposables.add(controller);
+            entry.disposables.add(controller.onDidChangeSelection(selection => {
+                this._proxy.$onDidChangeCustomTextEditorSelection(handle, selection && Selection.from(selection));
+            }));
+            return {
+                selection: controller.selection && Selection.from(controller.selection)
+            };
+        } catch (error) {
+            this.$disposeCustomTextEditorNavigation(handle);
+            if (!isCancellationError(error)) {
+                onUnexpectedError(error);
+            }
+            return undefined;
+        }
+    }
+    $disposeCustomTextEditorNavigation(handle) {
+        const entry = this._navigation.get(handle);
+        if (entry) {
+            this._navigation.delete(handle);
+            entry.states.clear();
+            entry.pendingStates.clear();
+            entry.disposables.dispose();
+        }
+    }
+    async $revealCustomTextEditorRange(handle, range, selection, preserveFocus, token) {
+        const controller = this._navigation.get(handle)?.controller;
+        if (controller && !token.isCancellationRequested) {
+            await controller.revealRange(Range.to(range), {
+                selection: selection && Selection.to(selection),
+                preserveFocus
+            }, token);
+        }
+    }
+    async $captureCustomTextEditorViewState(handle, stateId) {
+        const entry = this._navigation.get(handle);
+        if (entry?.controller) {
+            entry.pendingStates.add(stateId);
+            try {
+                const state = await entry.controller.captureViewState();
+                if (this._navigation.get(handle) === entry && entry.pendingStates.delete(stateId)) {
+                    entry.states.set(stateId, state);
+                }
+            } finally {
+                entry.pendingStates.delete(stateId);
+            }
+        }
+    }
+    async $restoreCustomTextEditorViewState(handle, stateId, token) {
+        const entry = this._navigation.get(handle);
+        if (entry?.controller && ( entry.states.has(stateId))) {
+            const state = entry.states.get(stateId);
+            entry.states.delete(stateId);
+            if (!token.isCancellationRequested) {
+                await entry.controller.restoreViewState(state, token);
+            }
+        }
+    }
+    $releaseCustomTextEditorViewState(handle, stateId) {
+        const entry = this._navigation.get(handle);
+        entry?.states.delete(stateId);
+        entry?.pendingStates.delete(stateId);
+    }
     async $resolveCustomEditorInlineDiff(
         originalResource,
         modifiedResource,

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

@@ -3,7 +3,7 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { coalesce } from '../../../base/common/arrays.js';
 import { asPromise } from '../../../base/common/async.js';
 import { Emitter } from '../../../base/common/event.js';
-import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { Disposable, DisposableMap, toDisposable } from '../../../base/common/lifecycle.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
 import { URI } from '../../../base/common/uri.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
@@ -68,7 +68,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
         this._debugVisualizationProviders = ( new Map());
         this._debugVisualizationTrees = ( new Map());
         this._debugVisualizationTreeItemIds = ( new WeakMap());
-        this._debugVisualizationElements = ( new Map());
+        this._debugVisualizationElements = this._register(( new DisposableMap()));
         this._visualizers = ( new Map());
         this._visualizerIdCounter = 0;
         this._configProviderHandleCounter = 0;
@@ -102,7 +102,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
             return undefined;
         }
         const item = await this._debugVisualizationTrees.get(treeId)?.getTreeItem?.(context);
-        return item ? this.convertVisualizerTreeItem(treeId, item) : undefined;
+        return item && ( this._debugSessions.has(context.session.id)) ? this.convertVisualizerTreeItem(treeId, item, [context.session.id]) : undefined;
     }
     registerDebugVisualizationTree(manifest, id, provider) {
         const extensionId = ExtensionIdentifier.toKey(manifest.identifier);
@@ -114,16 +114,19 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
         this._debugServiceProxy.$registerDebugVisualizerTree(key, !!provider.editItem);
         return toDisposable(() => {
             this._debugServiceProxy.$unregisterDebugVisualizerTree(key);
-            this._debugVisualizationTrees.delete(id);
+            this._debugVisualizationTrees.delete(key);
         });
     }
     async $getVisualizerTreeItemChildren(treeId, element) {
-        const item = this._debugVisualizationElements.get(element)?.item;
-        if (!item) {
+        const entry = this._debugVisualizationElements.get(element);
+        if (!entry) {
             return [];
         }
-        const children = await this._debugVisualizationTrees.get(treeId)?.getChildren?.(item);
-        return children?.map(i => this.convertVisualizerTreeItem(treeId, i)) || [];
+        const children = await this._debugVisualizationTrees.get(treeId)?.getChildren?.(entry.item);
+        if (!( this._debugVisualizationElements.has(element))) {
+            return [];
+        }
+        return children?.map(i => this.convertVisualizerTreeItem(treeId, i, entry.sessionIds)) || [];
     }
     async $editVisualizerTreeItem(element, value) {
         const e = this._debugVisualizationElements.get(element);
@@ -131,7 +134,10 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
             return undefined;
         }
         const r = await this._debugVisualizationTrees.get(e.provider)?.editItem?.(e.item, value);
-        return this.convertVisualizerTreeItem(e.provider, r || e.item);
+        if (!( this._debugVisualizationElements.has(element))) {
+            return undefined;
+        }
+        return this.convertVisualizerTreeItem(e.provider, r || e.item, e.sessionIds);
     }
     $disposeVisualizedTree(element) {
         const root = this._debugVisualizationElements.get(element);
@@ -143,21 +149,27 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
             if (children) {
                 for (const child of children) {
                     queue.push(this._debugVisualizationElements.get(child)?.children);
-                    this._debugVisualizationElements.delete(child);
+                    this._debugVisualizationElements.deleteAndDispose(child);
                 }
             }
         }
     }
-    convertVisualizerTreeItem(treeId, item) {
+    convertVisualizerTreeItem(treeId, item, sessionIds) {
         let id = this._debugVisualizationTreeItemIds.get(item);
-        if (!id) {
+        if (id === undefined) {
             id = this._debugVisualizationTreeItemIdsCounter++;
             this._debugVisualizationTreeItemIds.set(item, id);
             this._debugVisualizationElements.set(id, {
                 provider: treeId,
-                item
+                item,
+                sessionIds: ( new Set()),
+                dispose: () => this._debugVisualizationTreeItemIds.delete(item)
             });
         }
+        const entry = this._debugVisualizationElements.get(id);
+        for (const sessionId of sessionIds) {
+            entry.sessionIds.add(sessionId);
+        }
         return DebugTreeItem.from(item, id);
     }
     asDebugSourceUri(src, session) {
@@ -298,7 +310,7 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
         this._debugServiceProxy.$registerDebugVisualizer(extensionId, id);
         return toDisposable(() => {
             this._debugServiceProxy.$unregisterDebugVisualizer(extensionId, id);
-            this._debugVisualizationProviders.delete(id);
+            this._debugVisualizationProviders.delete(key);
         });
     }
     addBreakpoints(breakpoints0) {
@@ -731,6 +743,12 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase extends Disposable {
         if (session) {
             this._onDidTerminateDebugSession.fire(session.api);
             this._debugSessions.delete(session.id);
+            for (const [id, entry] of this._debugVisualizationElements) {
+                entry.sessionIds.delete(session.id);
+                if (entry.sessionIds.size === 0) {
+                    this._debugVisualizationElements.deleteAndDispose(id);
+                }
+            }
         }
     }
     async $acceptDebugSessionActiveChanged(sessionDto) {
@@ -1050,10 +1068,14 @@ class DirectDebugAdapter extends AbstractDebugAdapter {
     constructor(implementation) {
         super();
         this.implementation = implementation;
-        implementation.onDidSendMessage(message => {
+        this._messageListener = implementation.onDidSendMessage(message => {
             this.acceptMessage(message);
         });
     }
+    dispose() {
+        this._messageListener.dispose();
+        super.dispose();
+    }
     startSession() {
         return Promise.resolve(undefined);
     }
@@ -1061,6 +1083,7 @@ class DirectDebugAdapter extends AbstractDebugAdapter {
         this.implementation.handleMessage(message);
     }
     stopSession() {
+        this.dispose();
         this.implementation.dispose();
         return Promise.resolve(undefined);
     }

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

@@ -125,7 +125,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            5276,
+                            6597,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

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

@@ -110,6 +110,7 @@ export declare abstract class AbstractExtHostExtensionService extends Disposable
     $extensionTestsExecute(): Promise<number>;
     private _doHandleExtensionTests;
     private _startExtensionHost;
+    protected _onEagerExtensionsActivated(): void;
     registerRemoteAuthorityResolver(authorityPrefix: string, resolver: vscode.RemoteAuthorityResolver): vscode.Disposable;
     getRemoteExecServer(remoteAuthority: string): Promise<vscode.ExecServer | undefined>;
     private _activateAndGetResolver;

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

@@ -614,14 +614,14 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             extensionTestsLocationURI
         } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(5277, "Cannot load test runner."))));
+            throw ( new Error(( localize(6598, "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(
-                5278,
+                6599,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));
@@ -673,8 +673,10 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         }).then(() => this._handleEagerExtensions()).then(() => {
             this._eagerExtensionsActivated.open();
             this._logService.info(`Eager extensions activated`);
+            this._onEagerExtensionsActivated();
         });
     }
+    _onEagerExtensionsActivated() {}
     registerRemoteAuthorityResolver(authorityPrefix, resolver) {
         this._resolvers[authorityPrefix] = resolver;
         return toDisposable(() => {

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

@@ -567,14 +567,14 @@ class DocumentPasteEditProvider {
             only: context.only ? ( new DocumentDropOrPasteEditKind(context.only)) : undefined,
             triggerKind: context.triggerKind
         }, token);
-        if (!edits || token.isCancellationRequested) {
+        if (!edits?.length || token.isCancellationRequested) {
             return [];
         }
         const cacheId = this._editsCache.add(edits);
         return edits.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                5279,
+                6600,
                 "Paste using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -668,7 +668,7 @@ class NavigateTypeAdapter {
     }
     async provideWorkspaceSymbols(search, token) {
         const value = await this._provider.provideWorkspaceSymbols(search, token);
-        if (!isNonEmptyArray(value)) {
+        if (!isNonEmptyArray(value) || token.isCancellationRequested) {
             return {
                 symbols: []
             };
@@ -861,7 +861,7 @@ class DocumentSemanticTokensAdapter {
         if (previousResult) {
             this._previousResults.delete(previousResultId);
         }
-        if (!value) {
+        if (!value || token.isCancellationRequested) {
             return null;
         }
         value = DocumentSemanticTokensAdapter._fixProvidedSemanticTokens(value);
@@ -1390,7 +1390,7 @@ class SignatureHelpAdapter {
         const pos = Position.to(position);
         const vscodeContext = this.reviveContext(context);
         const value = await this._provider.provideSignatureHelp(doc, pos, token, vscodeContext);
-        if (value) {
+        if (value && !token.isCancellationRequested) {
             const id = this._cache.add([value]);
             return {
                 ...SignatureHelp.from(value),
@@ -1690,7 +1690,7 @@ class CallHierarchyAdapter {
         const doc = this._documents.getDocument(uri);
         const pos = Position.to(position);
         const items = await this._provider.prepareCallHierarchy(doc, pos, token);
-        if (!items) {
+        if (!items || token.isCancellationRequested) {
             return undefined;
         }
         const sessionId = this._idPool.nextId();
@@ -1758,7 +1758,7 @@ class TypeHierarchyAdapter {
         const doc = this._documents.getDocument(uri);
         const pos = Position.to(position);
         const items = await this._provider.prepareTypeHierarchy(doc, pos, token);
-        if (!items) {
+        if (!items || token.isCancellationRequested) {
             return undefined;
         }
         const sessionId = this._idPool.nextId();
@@ -1829,11 +1829,14 @@ class DocumentDropEditAdapter {
             return undefined;
         }
         const editsArray = asArray(edits);
+        if (editsArray.length === 0) {
+            return undefined;
+        }
         const cacheId = this._cache.add(editsArray);
         return editsArray.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                5280,
+                6601,
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),

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

@@ -20,7 +20,6 @@ export declare class ExtHostLanguageModelTools implements ExtHostLanguageModelTo
     $onDidChangeTools(tools: IToolDataDto[]): void;
     getTools(extension: IExtensionDescription): vscode.LanguageModelToolInformation[];
     $invokeTool(dto: Dto<IToolInvocation>, token: CancellationToken): Promise<Dto<IToolResult> | SerializableObjectWithBuffers<Dto<IToolResult>>>;
-    private getModel;
     $handleToolStream(toolId: string, context: IToolInvocationStreamContext, token: CancellationToken): Promise<IStreamedToolInvocation | undefined>;
     $prepareToolInvocation(toolId: string, context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     registerTool(extension: IExtensionDescription, id: string, tool: vscode.LanguageModelTool<any>): IDisposable;

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

@@ -12,6 +12,7 @@ import { SearchExtensionsToolId } from '../../contrib/extensions/common/searchEx
 import { isProposedApiEnabled, checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
 import { MainContext } from './extHost.protocol.js';
+import { LanguageModelError } from './extHostTypes.js';
 import { LanguageModelToolSource, LanguageModelToolResult, MarkdownString, IconPath } from './extHostTypeConverters.js';
 import { URI } from '../../../base/common/uri.js';
 
@@ -157,7 +158,19 @@ class ExtHostLanguageModelTools {
             options.tracestate = dto.tracestate;
         }
         if (isProposedApiEnabled(item.extension, "chatParticipantAdditions") && dto.modelId) {
-            options.model = await this.getModel(dto.modelId, item.extension);
+            try {
+                options.model = await this._languageModels.getLanguageModelForRequest(item.extension, dto.modelId);
+            } catch (error) {
+                if (!(error instanceof LanguageModelError) || error.code !== LanguageModelError.NotFound.name) {
+                    throw error;
+                }
+                Object.defineProperty(options, "model", {
+                    enumerable: true,
+                    get: () => {
+                        throw error;
+                    }
+                });
+            }
         }
         if (isProposedApiEnabled(item.extension, "chatParticipantAdditions") && dto.chatStreamToolCallId) {
             options.chatStreamToolCallId = dto.chatStreamToolCallId;
@@ -189,19 +202,6 @@ class ExtHostLanguageModelTools {
         }
         return LanguageModelToolResult.from(extensionResult, item.extension);
     }
-    async getModel(modelId, extension) {
-        let model;
-        if (modelId) {
-            model = await this._languageModels.getLanguageModelByIdentifier(extension, modelId);
-        }
-        if (!model) {
-            model = await this._languageModels.getDefaultLanguageModel(extension);
-            if (!model) {
-                throw ( new Error("Language model unavailable"));
-            }
-        }
-        return model;
-    }
     async $handleToolStream(toolId, context, token) {
         const item = this._registeredTools.get(toolId);
         if (!item) {

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

@@ -43,6 +43,11 @@ export declare class ExtHostLanguageModels implements ExtHostLanguageModelsShape
     $provideTokenLength(modelId: string, value: string, token: CancellationToken): Promise<number>;
     getDefaultLanguageModel(extension: IExtensionDescription, forceResolveModels?: boolean): Promise<vscode.LanguageModelChat | undefined>;
     getLanguageModelByIdentifier(extension: IExtensionDescription, modelId: string | undefined): Promise<vscode.LanguageModelChat | undefined>;
+    /**
+     * Resolves the model a chat request or tool invocation runs on. An explicit selection that cannot be resolved
+     * fails rather than silently running on (and billing) the default model.
+     */
+    getLanguageModelForRequest(extension: IExtensionDescription, userSelectedModelId: string | undefined): Promise<vscode.LanguageModelChat>;
     private _createLanguageModelChatApi;
     selectLanguageModels(extension: IExtensionDescription, selector: vscode.LanguageModelChatSelector): Promise<vscode.LanguageModelChat[]>;
     private _sendChatRequest;