@codingame/monaco-vscode-api 16.1.1 → 17.1.0

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

@@ -6,18 +6,19 @@ import { ExtHostMcpShape, MainThreadMcpShape } from "./extHost.protocol.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
 export declare const IExtHostMpcService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostMpcService>;
 export interface IExtHostMpcService extends ExtHostMcpShape {
-    registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpConfigurationProvider): IDisposable;
+    registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpServerDefinitionProvider): IDisposable;
 }
 export declare class ExtHostMcpService extends Disposable implements IExtHostMpcService {
     protected _proxy: MainThreadMcpShape;
     private readonly _initialProviderPromises;
     private readonly _sseEventSources;
-    private readonly _eventSource;
+    private readonly _unresolvedMcpServers;
     constructor(extHostRpc: IExtHostRpcService);
     $startMcp(id: number, launch: McpServerLaunch.Serialized): void;
     protected _startMcp(id: number, launch: McpServerLaunch): void;
     $stopMcp(id: number): void;
     $sendMessage(id: number, message: string): void;
     $waitForInitialCollectionProviders(): Promise<void>;
-    registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpConfigurationProvider): IDisposable;
+    $resolveMcpLaunch(collectionId: string, label: string): Promise<McpServerLaunch.Serialized | undefined>;
+    registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpServerDefinitionProvider): IDisposable;
 }

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

@@ -1,16 +1,17 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Sequencer, DeferredPromise } from '../../../base/common/async.js';
-import { CancellationToken } from '../../../base/common/cancellation.js';
-import { Lazy } from '../../../base/common/lazy.js';
+import { Sequencer, DeferredPromise, timeout, raceCancellationError } from '../../../base/common/async.js';
+import { CancellationToken, CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { Disposable, DisposableMap, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
+import { SSEParser } from '../../../base/common/sseParser.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { LogLevel } from '../../../platform/log/common/log.js';
 import { StorageScope } from '../../../platform/storage/common/storage.js';
 import { McpServerLaunch, McpServerTransportType, McpConnectionState, extensionPrefixedIdentifier } from '../../contrib/mcp/common/mcpTypes.js';
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { LogLevel } from '../../../platform/log/common/log.js';
+import { McpServerDefinition } from './extHostTypeConverters.js';
 
 const IExtHostMpcService = ( createDecorator('IExtHostMpcService'));
 let ExtHostMcpService = class ExtHostMcpService extends Disposable {
@@ -18,18 +19,15 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
         super();
         this._initialProviderPromises = ( new Set());
         this._sseEventSources = this._register(( new DisposableMap()));
-        this._eventSource = ( new Lazy(async () => {
-            const es = await import('@c4312/eventsource-umd').then(module => module.default ?? module);
-            return es.EventSource;
-        }));
+        this._unresolvedMcpServers = ( new Map());
         this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadMcp));
     }
     $startMcp(id, launch) {
         this._startMcp(id, McpServerLaunch.fromSerialized(launch));
     }
     _startMcp(id, launch) {
-        if (launch.type === McpServerTransportType.SSE) {
-            this._sseEventSources.set(id, ( new McpSSEHandle(this._eventSource.value, id, launch, this._proxy)));
+        if (launch.type === McpServerTransportType.HTTP) {
+            this._sseEventSources.set(id, ( new McpHTTPHandle(id, launch, this._proxy)));
             return;
         }
         throw ( new Error('not implemented'));
@@ -46,6 +44,21 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
     async $waitForInitialCollectionProviders() {
         await Promise.all(this._initialProviderPromises);
     }
+    async $resolveMcpLaunch(collectionId, label) {
+        const rec = this._unresolvedMcpServers.get(collectionId);
+        if (!rec) {
+            return;
+        }
+        const server = rec.servers.find(s => s.label === label);
+        if (!server) {
+            return;
+        }
+        if (!rec.provider.resolveMcpServerDefinition) {
+            return McpServerDefinition.from(server);
+        }
+        const resolved = await rec.provider.resolveMcpServerDefinition(server, CancellationToken.None);
+        return resolved ? McpServerDefinition.from(resolved) : undefined;
+    }
     registerMcpConfigurationProvider(extension, id, provider) {
         const store = ( new DisposableStore());
         const metadata = extension.contributes?.modelContextServerCollections?.find(m => m.id === id);
@@ -58,39 +71,39 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
             id: extensionPrefixedIdentifier(extension.identifier, id),
             isTrustedByDefault: true,
             label: metadata?.label ?? extension.displayName ?? extension.name,
-            scope: StorageScope.WORKSPACE
+            scope: StorageScope.WORKSPACE,
+            canResolveLaunch: typeof provider.resolveMcpServerDefinition === 'function',
+            extensionId: extension.identifier.value,
         };
         const update = async () => {
             const list = await provider.provideMcpServerDefinitions(CancellationToken.None);
-            function isSSEConfig(candidate) {
-                return !!candidate.uri;
-            }
+            this._unresolvedMcpServers.set(mcp.id, { servers: list ?? [], provider });
             const servers = [];
             for (const item of list ?? []) {
+                let id = ExtensionIdentifier.toKey(extension.identifier) + '/' + item.label;
+                if (( servers.some(s => s.id === id))) {
+                    let i = 2;
+                    while (( servers.some(s => s.id === id + i))) {
+                        i++;
+                    }
+                    id = id + i;
+                }
                 servers.push({
-                    id: ExtensionIdentifier.toKey(extension.identifier),
+                    id,
                     label: item.label,
-                    launch: isSSEConfig(item)
-                        ? {
-                            type: McpServerTransportType.SSE,
-                            uri: item.uri,
-                            headers: item.headers,
-                        }
-                        : {
-                            type: McpServerTransportType.Stdio,
-                            cwd: item.cwd,
-                            args: item.args,
-                            command: item.command,
-                            env: item.env,
-                            envFile: undefined,
-                        }
+                    cacheNonce: item.version,
+                    launch: McpServerDefinition.from(item)
                 });
             }
             this._proxy.$upsertMcpCollection(mcp, servers);
         };
         store.add(toDisposable(() => {
+            this._unresolvedMcpServers.delete(mcp.id);
             this._proxy.$deleteMcpCollection(mcp.id);
         }));
+        if (provider.onDidChangeServerDefinitions) {
+            store.add(provider.onDidChangeServerDefinitions(update));
+        }
         if (provider.onDidChange) {
             store.add(provider.onDidChange(update));
         }
@@ -107,76 +120,251 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
 ExtHostMcpService = ( __decorate([
     ( __param(0, IExtHostRpcService))
 ], ExtHostMcpService));
-class McpSSEHandle extends Disposable {
-    constructor(eventSourceCtor, _id, launch, _proxy) {
+var HttpMode;
+(function (HttpMode) {
+    HttpMode[HttpMode["Unknown"] = 0] = "Unknown";
+    HttpMode[HttpMode["Http"] = 1] = "Http";
+    HttpMode[HttpMode["SSE"] = 2] = "SSE";
+})(HttpMode || (HttpMode = {}));
+class McpHTTPHandle extends Disposable {
+    constructor(_id, _launch, _proxy) {
         super();
         this._id = _id;
+        this._launch = _launch;
         this._proxy = _proxy;
         this._requestSequencer = ( new Sequencer());
         this._postEndpoint = ( new DeferredPromise());
-        eventSourceCtor.then(EventSourceCtor => this._attach(EventSourceCtor, launch));
+        this._mode = { value: HttpMode.Unknown };
+        this._cts = ( new CancellationTokenSource());
+        this._abortCtrl = ( new AbortController());
+        this._register(toDisposable(() => {
+            this._abortCtrl.abort();
+            this._cts.dispose(true);
+        }));
+        this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Running });
     }
-    _attach(EventSourceCtor, launch) {
-        if (this._store.isDisposed) {
-            return;
-        }
-        const eventSource = ( new EventSourceCtor(( launch.uri.toString()), {
-            fetch: (input, init) => fetch(input, {
-                ...init,
-                headers: {
-                    ...Object.fromEntries(launch.headers),
-                    ...init?.headers,
-                },
-            }).then(async (res) => {
-                if (res.status >= 300) {
-                    this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `${res.status} status connecting to ${launch.uri}: ${await this._getErrText(res)}` });
-                    eventSource.close();
+    async send(message) {
+        try {
+            await this._requestSequencer.queue(() => {
+                if (this._mode.value === HttpMode.SSE) {
+                    return this._sendLegacySSE(this._mode.endpoint, message);
                 }
-                return res;
-            }, err => {
-                this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `Error connecting to ${launch.uri}: ${String(err)}` });
-                eventSource.close();
-                return Promise.reject(err);
-            })
-        }));
-        this._register(toDisposable(() => eventSource.close()));
-        eventSource.addEventListener('endpoint', e => {
-            this._postEndpoint.complete(( ( new URL(e.data, ( launch.uri.toString()))).toString()));
-        });
-        eventSource.addEventListener('message', e => {
-            this._proxy.$onDidReceiveMessage(this._id, e.data);
-        });
-        eventSource.addEventListener('open', () => {
-            this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Running });
+                else {
+                    return this._sendStreamableHttp(message, this._mode.value === HttpMode.Http ? this._mode.sessionId : undefined);
+                }
+            });
+        }
+        catch (err) {
+            const msg = `Error sending message to ${this._launch.uri}: ${String(err)}`;
+            this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: msg });
+        }
+    }
+    async _sendStreamableHttp(message, sessionId) {
+        const asBytes = ( new TextEncoder()).encode(message);
+        const headers = {
+            ...Object.fromEntries(this._launch.headers),
+            'Content-Type': 'application/json',
+            'Content-Length': String(asBytes.length),
+            Accept: 'text/event-stream, application/json',
+        };
+        if (sessionId) {
+            headers['Mcp-Session-Id'] = sessionId;
+        }
+        const res = await fetch(( this._launch.uri.toString(true)), {
+            method: 'POST',
+            signal: this._abortCtrl.signal,
+            headers,
+            body: asBytes,
         });
-        eventSource.addEventListener('error', (err) => {
-            this._postEndpoint.cancel();
+        const wasUnknown = this._mode.value === HttpMode.Unknown;
+        const nextSessionId = res.headers.get('Mcp-Session-Id');
+        if (nextSessionId) {
+            this._mode = { value: HttpMode.Http, sessionId: nextSessionId };
+        }
+        if (this._mode.value === HttpMode.Unknown && res.status >= 400 && res.status < 500) {
+            this._log(LogLevel.Info, `${res.status} status sending message to ${this._launch.uri}, will attempt to fall back to legacy SSE`);
+            const endpoint = await this._attachSSE();
+            if (endpoint) {
+                this._mode = { value: HttpMode.SSE, endpoint };
+                await this._sendLegacySSE(endpoint, message);
+            }
+            return;
+        }
+        if (res.status >= 300) {
+            const retryWithSessionId = this._mode.value === HttpMode.Http && !!this._mode.sessionId;
             this._proxy.$onDidChangeState(this._id, {
                 state: McpConnectionState.Kind.Error,
-                message: `Error connecting to ${launch.uri}: ${err.code || 0} ${err.message || JSON.stringify(err)}`,
+                message: `${res.status} status sending message to ${this._launch.uri}: ${await this._getErrText(res)}` + retryWithSessionId ? `; will retry with new session ID` : '',
+                shouldRetry: retryWithSessionId,
             });
-            eventSource.close();
-        });
+            return;
+        }
+        if (this._mode.value === HttpMode.Unknown) {
+            this._mode = { value: HttpMode.Http, sessionId: undefined };
+        }
+        if (wasUnknown) {
+            this._attachStreamableBackchannel();
+        }
+        this._handleSuccessfulStreamableHttp(res);
     }
-    async send(message) {
-        try {
-            const res = await this._requestSequencer.queue(async () => {
-                const endpoint = await this._postEndpoint.p;
-                const asBytes = ( new TextEncoder()).encode(message);
-                return fetch(endpoint, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Content-Length': String(asBytes.length),
-                    },
-                    body: asBytes,
+    async _handleSuccessfulStreamableHttp(res) {
+        if (res.status === 202) {
+            return;
+        }
+        switch (res.headers.get('Content-Type')?.toLowerCase()) {
+            case 'text/event-stream': {
+                const parser = ( new SSEParser(event => {
+                    if (event.type === 'message') {
+                        this._proxy.$onDidReceiveMessage(this._id, event.data);
+                    }
+                }));
+                try {
+                    await this._doSSE(parser, res);
+                }
+                catch (err) {
+                    this._log(LogLevel.Warning, `Error reading SSE stream: ${String(err)}`);
+                }
+                break;
+            }
+            case 'application/json':
+                this._proxy.$onDidReceiveMessage(this._id, await res.text());
+                break;
+            default: {
+                const responseBody = await res.text();
+                if (isJSON(responseBody)) {
+                    this._proxy.$onDidReceiveMessage(this._id, responseBody);
+                }
+                else {
+                    this._log(LogLevel.Warning, `Unexpected ${res.status} response for request: ${responseBody}`);
+                }
+            }
+        }
+    }
+    async _attachStreamableBackchannel() {
+        let lastEventId;
+        for (let retry = 0; !this._store.isDisposed; retry++) {
+            await timeout(Math.min(retry * 1000, 30_000), this._cts.token);
+            let res;
+            try {
+                const headers = {
+                    ...Object.fromEntries(this._launch.headers),
+                    'Accept': 'text/event-stream',
+                };
+                if (this._mode.value === HttpMode.Http && this._mode.sessionId !== undefined) {
+                    headers['Mcp-Session-Id'] = this._mode.sessionId;
+                }
+                if (lastEventId) {
+                    headers['Last-Event-ID'] = lastEventId;
+                }
+                res = await fetch(( this._launch.uri.toString(true)), {
+                    method: 'GET',
+                    signal: this._abortCtrl.signal,
+                    headers,
                 });
+            }
+            catch (e) {
+                this._log(LogLevel.Info, `Error connecting to ${this._launch.uri} for async notifications, will retry`);
+                continue;
+            }
+            if (res.status >= 400) {
+                this._log(LogLevel.Debug, `${res.status} status connecting to ${this._launch.uri} for async notifications; they will be disabled: ${await this._getErrText(res)}`);
+                return;
+            }
+            retry = 0;
+            const parser = ( new SSEParser(event => {
+                if (event.type === 'message') {
+                    this._proxy.$onDidReceiveMessage(this._id, event.data);
+                }
+                if (event.id) {
+                    lastEventId = event.id;
+                }
+            }));
+            try {
+                await this._doSSE(parser, res);
+            }
+            catch (e) {
+                this._log(LogLevel.Info, `Error reading from async stream, we will reconnect: ${e}`);
+            }
+        }
+    }
+    async _attachSSE() {
+        const postEndpoint = ( new DeferredPromise());
+        let res;
+        try {
+            res = await fetch(( this._launch.uri.toString(true)), {
+                method: 'GET',
+                signal: this._abortCtrl.signal,
+                headers: {
+                    ...Object.fromEntries(this._launch.headers),
+                    'Accept': 'text/event-stream',
+                },
             });
             if (res.status >= 300) {
-                this._proxy.$onDidPublishLog(this._id, LogLevel.Warning, `${res.status} status sending message to ${this._postEndpoint}: ${await this._getErrText(res)}`);
+                this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `${res.status} status connecting to ${this._launch.uri} as SSE: ${await this._getErrText(res)}` });
+                return;
             }
         }
-        catch (err) {
+        catch (e) {
+            this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `Error connecting to ${this._launch.uri} as SSE: ${e}` });
+            return;
+        }
+        const parser = ( new SSEParser(event => {
+            if (event.type === 'message') {
+                this._proxy.$onDidReceiveMessage(this._id, event.data);
+            }
+            else if (event.type === 'endpoint') {
+                postEndpoint.complete(( ( new URL(event.data, ( this._launch.uri.toString(true)))).toString()));
+            }
+        }));
+        this._register(toDisposable(() => postEndpoint.cancel()));
+        this._doSSE(parser, res).catch(err => {
+            this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `Error reading SSE stream: ${String(err)}` });
+        });
+        return postEndpoint.p;
+    }
+    async _sendLegacySSE(url, message) {
+        const asBytes = ( new TextEncoder()).encode(message);
+        const res = await fetch(url, {
+            method: 'POST',
+            signal: this._abortCtrl.signal,
+            headers: {
+                ...Object.fromEntries(this._launch.headers),
+                'Content-Type': 'application/json',
+                'Content-Length': String(asBytes.length),
+            },
+            body: asBytes,
+        });
+        if (res.status >= 300) {
+            this._log(LogLevel.Warning, `${res.status} status sending message to ${this._postEndpoint}: ${await this._getErrText(res)}`);
+        }
+    }
+    async _doSSE(parser, res) {
+        if (!res.body) {
+            return;
+        }
+        const reader = res.body.getReader();
+        let chunk;
+        do {
+            try {
+                chunk = await raceCancellationError(reader.read(), this._cts.token);
+            }
+            catch (err) {
+                reader.cancel();
+                if (this._store.isDisposed) {
+                    return;
+                }
+                else {
+                    throw err;
+                }
+            }
+            if (chunk.value) {
+                parser.feed(chunk.value);
+            }
+        } while (!chunk.done);
+    }
+    _log(level, message) {
+        if (!this._store.isDisposed) {
+            this._proxy.$onDidPublishLog(this._id, level, message);
         }
     }
     async _getErrText(res) {
@@ -188,5 +376,14 @@ class McpSSEHandle extends Disposable {
         }
     }
 }
+function isJSON(str) {
+    try {
+        JSON.parse(str);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
 
 export { ExtHostMcpService, IExtHostMpcService };

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

@@ -260,7 +260,7 @@ class ExtHostNotebookController {
             throw ( new Error('Document version mismatch'));
         }
         if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-            throw new FileOperationError(( localize(2546, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+            throw new FileOperationError(( localize(2564, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
         }
         const data = {
             metadata: filter(document.apiNotebook.metadata, key => !(serializer.options?.transientDocumentMetadata ?? {})[key]),
@@ -432,7 +432,7 @@ class ExtHostNotebookController {
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(( localize(2547, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(2565, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

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

@@ -57,6 +57,9 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
                                 `Cannot invoke 'notebook.selectKernel' for unrecognized notebook editor ${( v.notebookEditor.notebook.uri.toString())}`
                             ));
                         }
+                        if ('skipIfAlreadySelected' in v) {
+                            return { notebookEditorId, skipIfAlreadySelected: v.skipIfAlreadySelected };
+                        }
                         return { notebookEditorId };
                     }
                     return v;

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

@@ -3,6 +3,7 @@ import { CancellationToken } from "../../../base/common/cancellation.js";
 import { UriComponents } from "../../../base/common/uri.js";
 import { ExtHostQuickDiffShape, IMainContext } from "./extHost.protocol.js";
 import { IURITransformer } from "../../../base/common/uriIpc.js";
+import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 export declare class ExtHostQuickDiff implements ExtHostQuickDiffShape {
     private readonly uriTransformer;
     private static handlePool;
@@ -10,5 +11,5 @@ export declare class ExtHostQuickDiff implements ExtHostQuickDiffShape {
     private providers;
     constructor(mainContext: IMainContext, uriTransformer: IURITransformer | undefined);
     $provideOriginalResource(handle: number, uriComponents: UriComponents, token: CancellationToken): Promise<UriComponents | null>;
-    registerQuickDiffProvider(selector: vscode.DocumentSelector, quickDiffProvider: vscode.QuickDiffProvider, label: string, rootUri?: vscode.Uri): vscode.Disposable;
+    registerQuickDiffProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, quickDiffProvider: vscode.QuickDiffProvider, id: string, label: string, rootUri?: vscode.Uri): vscode.Disposable;
 }

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

@@ -3,6 +3,7 @@ import { URI } from '../../../base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
 import { asPromise } from '../../../base/common/async.js';
 import { DocumentSelector } from './extHostTypeConverters.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 
 class ExtHostQuickDiff {
     static { this.handlePool = 0; }
@@ -20,10 +21,11 @@ class ExtHostQuickDiff {
         return asPromise(() => provider.provideOriginalResource(uri, token))
             .then(r => r || null);
     }
-    registerQuickDiffProvider(selector, quickDiffProvider, label, rootUri) {
+    registerQuickDiffProvider(extension, selector, quickDiffProvider, id, label, rootUri) {
         const handle = ExtHostQuickDiff.handlePool++;
         this.providers.set(handle, quickDiffProvider);
-        this.proxy.$registerQuickDiffProvider(handle, DocumentSelector.from(selector, this.uriTransformer), label, rootUri, quickDiffProvider.visible ?? true);
+        const extensionId = ExtensionIdentifier.toKey(extension.identifier);
+        this.proxy.$registerQuickDiffProvider(handle, DocumentSelector.from(selector, this.uriTransformer), `${extensionId}.${id}`, label, rootUri);
         return {
             dispose: () => {
                 this.proxy.$unregisterQuickDiffProvider(handle);

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

@@ -11,7 +11,7 @@ interface LoadFunction {
 interface IAlternativeModuleProvider {
     alternativeModuleName(name: string): string | undefined;
 }
-interface INodeModuleFactory extends Partial<IAlternativeModuleProvider> {
+export interface INodeModuleFactory extends Partial<IAlternativeModuleProvider> {
     readonly nodeModuleName: string | string[];
     load(request: string, parent: URI, original: LoadFunction): any;
 }

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

@@ -55,6 +55,7 @@ export declare class ExtHostSCM implements ExtHostSCMShape {
     createSourceControl(extension: IExtensionDescription, id: string, label: string, rootUri: vscode.Uri | undefined): vscode.SourceControl;
     getLastInputBox(extension: IExtensionDescription): ExtHostSCMInputBox | undefined;
     $provideOriginalResource(sourceControlHandle: number, uriComponents: UriComponents, token: CancellationToken): Promise<UriComponents | null>;
+    $provideSecondaryOriginalResource(sourceControlHandle: number, uriComponents: UriComponents, token: CancellationToken): Promise<UriComponents | null>;
     $onInputBoxValueChange(sourceControlHandle: number, value: string): Promise<void>;
     $executeResourceCommand(sourceControlHandle: number, groupHandle: number, handle: number, preserveFocus: boolean): Promise<void>;
     $validateInput(sourceControlHandle: number, value: string, cursorPosition: number): Promise<[

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

@@ -475,6 +475,16 @@ class ExtHostSourceControl {
         }
         this.#proxy.$updateSourceControl(this.handle, { hasQuickDiffProvider: !!quickDiffProvider, quickDiffLabel });
     }
+    get secondaryQuickDiffProvider() {
+        checkProposedApiEnabled(this._extension, 'quickDiffProvider');
+        return this._secondaryQuickDiffProvider;
+    }
+    set secondaryQuickDiffProvider(secondaryQuickDiffProvider) {
+        checkProposedApiEnabled(this._extension, 'quickDiffProvider');
+        this._secondaryQuickDiffProvider = secondaryQuickDiffProvider;
+        const secondaryQuickDiffLabel = secondaryQuickDiffProvider?.label;
+        this.#proxy.$updateSourceControl(this.handle, { hasSecondaryQuickDiffProvider: !!secondaryQuickDiffProvider, secondaryQuickDiffLabel });
+    }
     get historyProvider() {
         checkProposedApiEnabled(this._extension, 'scmHistoryProvider');
         return this._historyProvider;
@@ -573,6 +583,7 @@ class ExtHostSourceControl {
         this._groups = ( new Map());
         this._count = undefined;
         this._quickDiffProvider = undefined;
+        this._secondaryQuickDiffProvider = undefined;
         this._historyProviderDisposable = ( new MutableDisposable());
         this._commitTemplate = undefined;
         this._acceptInputDisposables = ( new MutableDisposable());
@@ -758,6 +769,16 @@ let ExtHostSCM = class ExtHostSCM {
         return asPromise(() => sourceControl.quickDiffProvider.provideOriginalResource(uri, token))
             .then(r => r || null);
     }
+    $provideSecondaryOriginalResource(sourceControlHandle, uriComponents, token) {
+        const uri = URI.revive(uriComponents);
+        this.logService.trace('ExtHostSCM#$provideSecondaryOriginalResource', sourceControlHandle, ( uri.toString()));
+        const sourceControl = this._sourceControls.get(sourceControlHandle);
+        if (!sourceControl || !sourceControl.secondaryQuickDiffProvider || !sourceControl.secondaryQuickDiffProvider.provideOriginalResource) {
+            return Promise.resolve(null);
+        }
+        return asPromise(() => sourceControl.secondaryQuickDiffProvider.provideOriginalResource(uri, token))
+            .then(r => r || null);
+    }
     $onInputBoxValueChange(sourceControlHandle, value) {
         this.logService.trace('ExtHostSCM#$onInputBoxValueChange', sourceControlHandle);
         const sourceControl = this._sourceControls.get(sourceControlHandle);

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

@@ -138,7 +138,7 @@ let ExtHostSearch = class ExtHostSearch {
         }
         const query = reviveQuery(rawQuery);
         const engine = this.createAITextSearchManager(query, provider);
-        return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token);
+        return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token, result => this._proxy.$handleKeywordResult(handle, session, result));
     }
     $enableExtensionHostSearch() { }
     async $getAIName(handle) {

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

@@ -188,7 +188,7 @@ class ExtHostStatusBarEntry {
             }
             else {
                 name = ( localize(
-                    2548,
+                    2566,
                     "{0} (Extension)",
                     this._extension.displayName || this._extension.name
                 ));
@@ -221,7 +221,7 @@ class StatusBarMessage {
     constructor(statusBar) {
         this._messages = [];
         this._item = statusBar.createStatusBarEntry(undefined, 'status.extensionMessage', StatusBarAlignment.Left, Number.MIN_VALUE);
-        this._item.name = ( localize(2549, "Extension Status"));
+        this._item.name = ( localize(2567, "Extension Status"));
     }
     dispose() {
         this._messages.length = 0;

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

@@ -28,7 +28,7 @@ let ExtHostTelemetry = class ExtHostTelemetry extends Disposable {
         const id = initData.remote.isRemote ? 'remoteExtHostTelemetry' : isWorker ? 'workerExtHostTelemetry' : 'extHostTelemetry';
         this._outputLogger = this._register(loggerService.createLogger(id, {
             name: ( localize(
-                2550,
+                2568,
                 "Extension Telemetry{0}",
                 this._inLoggingOnlyMode ? ' (Not Sent)' : ''
             )),

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

@@ -482,7 +482,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
     async $startExtensionTerminal(id, initialDimensions) {
         const terminal = this.getTerminalById(id);
         if (!terminal) {
-            return { message: ( localize(2551, "Could not find the terminal with id {0} on the extension host", id)) };
+            return { message: ( localize(2569, "Could not find the terminal with id {0} on the extension host", id)) };
         }
         if (!terminal.isOpen) {
             await ( new Promise(r => {