@codingame/monaco-vscode-api 21.5.1 → 22.0.0

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

@@ -129,7 +129,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }
         this._clearModelCache(vendor);
         const modelInformation = (data.provider.provideLanguageModelChatInformation ? await data.provider.provideLanguageModelChatInformation(options, token) : await data.provider.prepareLanguageModelChatInformation(options, token)) ?? [];
-        const modelMetadataAndIdentifier = ( modelInformation.map(m => {
+        const modelMetadataAndIdentifier = ( modelInformation.map((m) => {
             let auth;
             if (m.requiresAuthorization && isProposedApiEnabled(data.extension, 'chatProvider')) {
                 auth = {
@@ -137,6 +137,9 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                     accountLabel: typeof m.requiresAuthorization === 'object' ? m.requiresAuthorization.label : undefined
                 };
             }
+            if (m.capabilities.editTools) {
+                checkProposedApiEnabled(data.extension, 'chatProvider');
+            }
             return {
                 metadata: {
                     extension: data.extension.identifier,
@@ -156,6 +159,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                     modelPickerCategory: m.category ?? DEFAULT_MODEL_PICKER_CATEGORY,
                     capabilities: m.capabilities ? {
                         vision: m.capabilities.imageInput,
+                        editTools: m.capabilities.editTools,
                         toolCalling: !!m.capabilities.toolCalling,
                         agentMode: !!m.capabilities.toolCalling
                     } : undefined,
@@ -284,6 +288,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                 capabilities: {
                     supportsImageToText: model.metadata.capabilities?.vision ?? false,
                     supportsToolCalling: !!model.metadata.capabilities?.toolCalling,
+                    editToolsHint: model.metadata.capabilities?.editTools,
                 },
                 maxInputTokens: model.metadata.maxInputTokens,
                 countTokens(text, token) {
@@ -380,7 +385,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }
         try {
             const detail = justification
-                ? ( localize(2632, "Justification: {1}", to.displayName, justification))
+                ? ( localize(2638, "Justification: {1}", to.displayName, justification))
                 : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], { forceNewSession: { detail } });
             this.$updateModelAccesslist([{ from: from.identifier, to: to.identifier, enabled: true }]);

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(2633, "Extension Host (Remote)")) : isWorker ? ( localize(2634, "Extension Host (Worker)")) : ( localize(2635, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(2639, "Extension Host (Remote)")) : isWorker ? ( localize(2640, "Extension Host (Worker)")) : ( localize(2641, "Extension Host"));
         super(loggerService.createLogger(id, { name }));
     }
 };

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

@@ -1,25 +1,31 @@
 import * as vscode from "vscode";
-import { Disposable, IDisposable } from "../../../base/common/lifecycle.js";
+import { Disposable, DisposableMap, IDisposable } from "../../../base/common/lifecycle.js";
+import { URI, UriComponents } from "../../../base/common/uri.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
-import { McpServerLaunch } from "../../contrib/mcp/common/mcpTypes.js";
-import { ExtHostMcpShape, MainThreadMcpShape } from "./extHost.protocol.js";
-import { IExtHostRpcService } from "./extHostRpcService.js";
+import { McpServerLaunch, McpServerTransportHTTP } from "../../contrib/mcp/common/mcpTypes.js";
+import { ExtHostMcpShape, IStartMcpOptions, MainThreadMcpShape } from "./extHost.protocol.js";
 import { IExtHostInitDataService } from "./extHostInitDataService.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+import { IExtHostVariableResolverProvider } from "./extHostVariableResolverService.js";
+import { IExtHostWorkspace } from "./extHostWorkspace.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.McpServerDefinitionProvider): IDisposable;
 }
 export declare class ExtHostMcpService extends Disposable implements IExtHostMpcService {
-    private readonly _logService;
+    protected readonly _logService: ILogService;
     private readonly _extHostInitData;
+    protected readonly _workspaceService: IExtHostWorkspace;
+    private readonly _variableResolver;
     protected _proxy: MainThreadMcpShape;
     private readonly _initialProviderPromises;
-    private readonly _sseEventSources;
+    protected readonly _sseEventSources: DisposableMap<number, McpHTTPHandle>;
     private readonly _unresolvedMcpServers;
-    constructor(extHostRpc: IExtHostRpcService, _logService: ILogService, _extHostInitData: IExtHostInitDataService);
-    $startMcp(id: number, launch: McpServerLaunch.Serialized): void;
-    protected _startMcp(id: number, launch: McpServerLaunch): void;
+    constructor(extHostRpc: IExtHostRpcService, _logService: ILogService, _extHostInitData: IExtHostInitDataService, _workspaceService: IExtHostWorkspace, _variableResolver: IExtHostVariableResolverProvider);
+    $startMcp(id: number, opts: IStartMcpOptions): void;
+    protected _startMcp(id: number, launch: McpServerLaunch, _defaultCwd?: URI, errorOnUserInteraction?: boolean): void;
+    $substituteVariables<T>(_workspaceFolder: UriComponents | undefined, value: T): Promise<T>;
     $stopMcp(id: number): void;
     $sendMessage(id: number, message: string): void;
     $waitForInitialCollectionProviders(): Promise<void>;
@@ -27,3 +33,85 @@ export declare class ExtHostMcpService extends Disposable implements IExtHostMpc
     /** {@link vscode.lm.registerMcpServerDefinitionProvider} */
     registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpServerDefinitionProvider): IDisposable;
 }
+/**
+ * Implementation of both MCP HTTP Streaming as well as legacy SSE.
+ *
+ * The first request will POST to the endpoint, assuming HTTP streaming. If the
+ * server is legacy SSE, it should return some 4xx status in that case,
+ * and we'll automatically fall back to SSE and res
+ */
+export declare class McpHTTPHandle extends Disposable {
+    private readonly _id;
+    private readonly _launch;
+    private readonly _proxy;
+    private readonly _logService;
+    private readonly _errorOnUserInteraction?;
+    private readonly _requestSequencer;
+    private readonly _postEndpoint;
+    private _mode;
+    private readonly _cts;
+    private readonly _abortCtrl;
+    private _authMetadata?;
+    constructor(_id: number, _launch: McpServerTransportHTTP, _proxy: MainThreadMcpShape, _logService: ILogService, _errorOnUserInteraction?: boolean | undefined);
+    send(message: string): Promise<void>;
+    _send(message: string): Promise<void>;
+    /**
+     * Sends a streamable-HTTP request.
+     * 1. Posts to the endpoint
+     * 2. Updates internal state as needed. Falls back to SSE if appropriate.
+     * 3. If the response body is empty, JSON, or a JSON stream, handle it appropriately.
+     */
+    private _sendStreamableHttp;
+    private _sseFallbackWithMessage;
+    private _populateAuthMetadata;
+    private _getAuthorizationServerMetadata;
+    private _handleSuccessfulStreamableHttp;
+    /**
+     * Attaches the SSE backchannel that streamable HTTP servers can use
+     * for async notifications. This is a "MAY" support, so if the server gives
+     * us a 4xx code, we'll stop trying to connect..
+     */
+    private _attachStreamableBackchannel;
+    /**
+     * Starts a legacy SSE attachment, where the SSE response is the session lifetime.
+     * Unlike `_attachStreamableBackchannel`, this fails the server if it disconnects.
+     */
+    private _attachSSE;
+    /**
+     * Sends a legacy SSE message to the server. The response is always empty and
+     * is otherwise received in {@link _attachSSE}'s loop.
+     */
+    private _sendLegacySSE;
+    /** Generic handle to pipe a response into an SSE parser. */
+    private _doSSE;
+    private _addAuthHeader;
+    private _log;
+    private _getErrText;
+    /**
+     * Helper method to perform fetch with 401 authentication retry logic.
+     * If the initial request returns 401 and we don't have auth metadata,
+     * it will populate the auth metadata and retry once.
+     */
+    private _fetchWithAuthRetry;
+    private _fetch;
+    protected _fetchInternal(url: string, init?: CommonRequestInit): Promise<CommonResponse>;
+}
+interface MinimalRequestInit {
+    method: string;
+    headers: Record<string, string>;
+    body?: Uint8Array<ArrayBuffer>;
+}
+export interface CommonRequestInit extends MinimalRequestInit {
+    signal?: AbortSignal;
+    redirect?: RequestRedirect;
+}
+export interface CommonResponse {
+    status: number;
+    statusText: string;
+    headers: Headers;
+    body?: ReadableStream | null;
+    url: string;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+export {};

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

@@ -2,45 +2,59 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Sequencer, DeferredPromise, timeout, raceCancellationError } from '../../../base/common/async.js';
 import { CancellationToken, CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { CancellationError } from '../../../base/common/errors.js';
 import { Disposable, DisposableMap, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
+import { parseWWWAuthenticateHeader, fetchResourceMetadata, getDefaultMetadataForUrl, AUTH_SERVER_METADATA_DISCOVERY_PATH, OPENID_CONNECT_DISCOVERY_PATH, isAuthorizationServerMetadata } from '../../../base/common/oauth.js';
 import { SSEParser } from '../../../base/common/sseParser.js';
+import { URI } from '../../../base/common/uri.js';
+import { ConfigurationTarget } from '../../../platform/configuration/common/configuration.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { LogLevel, canLog } from '../../../platform/log/common/log.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { StorageScope } from '../../../platform/storage/common/storage.js';
-import { McpServerLaunch, McpServerTransportType, McpConnectionState, extensionPrefixedIdentifier } from '../../contrib/mcp/common/mcpTypes.js';
+import { McpServerLaunch, McpServerTransportType, McpConnectionState, extensionPrefixedIdentifier, UserInteractionRequiredError } from '../../contrib/mcp/common/mcpTypes.js';
+import { MCP } from '../../contrib/mcp/common/modelContextProtocol.js';
 import { MainContext } from './extHost.protocol.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { McpServerDefinition } from './extHostTypeConverters.js';
-import { parseWWWAuthenticateHeader, getDefaultMetadataForUrl, isAuthorizationProtectedResourceMetadata, AUTH_SERVER_METADATA_DISCOVERY_PATH, OPENID_CONNECT_DISCOVERY_PATH, isAuthorizationServerMetadata } from '../../../base/common/oauth.js';
-import { URI } from '../../../base/common/uri.js';
-import { MCP } from '../../contrib/mcp/common/modelContextProtocol.js';
-import { CancellationError } from '../../../base/common/errors.js';
-import { ConfigurationTarget } from '../../../platform/configuration/common/configuration.js';
-import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostVariableResolverProvider } from './extHostVariableResolverService.js';
+import { IExtHostWorkspace } from './extHostWorkspace.js';
 
 const IExtHostMpcService = ( createDecorator('IExtHostMpcService'));
 let ExtHostMcpService = class ExtHostMcpService extends Disposable {
-    constructor(extHostRpc, _logService, _extHostInitData) {
+    constructor(extHostRpc, _logService, _extHostInitData, _workspaceService, _variableResolver) {
         super();
         this._logService = _logService;
         this._extHostInitData = _extHostInitData;
+        this._workspaceService = _workspaceService;
+        this._variableResolver = _variableResolver;
         this._initialProviderPromises = ( new Set());
         this._sseEventSources = this._register(( new DisposableMap()));
         this._unresolvedMcpServers = ( new Map());
         this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadMcp));
     }
-    $startMcp(id, launch) {
-        this._startMcp(id, McpServerLaunch.fromSerialized(launch));
+    $startMcp(id, opts) {
+        this._startMcp(id, McpServerLaunch.fromSerialized(opts.launch), opts.defaultCwd && URI.revive(opts.defaultCwd), opts.errorOnUserInteraction);
     }
-    _startMcp(id, launch) {
+    _startMcp(id, launch, _defaultCwd, errorOnUserInteraction) {
         if (launch.type === McpServerTransportType.HTTP) {
-            this._sseEventSources.set(id, ( new McpHTTPHandle(id, launch, this._proxy, this._logService)));
+            this._sseEventSources.set(id, ( new McpHTTPHandle(id, launch, this._proxy, this._logService, errorOnUserInteraction)));
             return;
         }
         throw ( new Error('not implemented'));
     }
+    async $substituteVariables(_workspaceFolder, value) {
+        const folderURI = URI.revive(_workspaceFolder);
+        const folder = folderURI && (await this._workspaceService.resolveWorkspaceFolder(folderURI));
+        const variableResolver = await this._variableResolver.getResolver();
+        return variableResolver.resolveAsync(folder && {
+            uri: folder.uri,
+            name: folder.name,
+            index: folder.index,
+        }, value);
+    }
     $stopMcp(id) {
         if (( this._sseEventSources.has(id))) {
             this._sseEventSources.deleteAndDispose(id);
@@ -133,7 +147,9 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
 ExtHostMcpService = ( __decorate([
     ( __param(0, IExtHostRpcService)),
     ( __param(1, ILogService)),
-    ( __param(2, IExtHostInitDataService))
+    ( __param(2, IExtHostInitDataService)),
+    ( __param(3, IExtHostWorkspace)),
+    ( __param(4, IExtHostVariableResolverProvider))
 ], ExtHostMcpService));
 var HttpMode;
 (function (HttpMode) {
@@ -144,12 +160,13 @@ var HttpMode;
 const MAX_FOLLOW_REDIRECTS = 5;
 const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
 class McpHTTPHandle extends Disposable {
-    constructor(_id, _launch, _proxy, _logService) {
+    constructor(_id, _launch, _proxy, _logService, _errorOnUserInteraction) {
         super();
         this._id = _id;
         this._launch = _launch;
         this._proxy = _proxy;
         this._logService = _logService;
+        this._errorOnUserInteraction = _errorOnUserInteraction;
         this._requestSequencer = ( new Sequencer());
         this._postEndpoint = ( new DeferredPromise());
         this._mode = { value: HttpMode.Unknown };
@@ -236,13 +253,14 @@ class McpHTTPHandle extends Disposable {
             await this._sendLegacySSE(endpoint, message);
         }
     }
-    async _populateAuthMetadata(url, originalResponse) {
+    async _populateAuthMetadata(mcpUrl, originalResponse) {
         let resourceMetadataChallenge;
         if (( originalResponse.headers.has('WWW-Authenticate'))) {
             const authHeader = originalResponse.headers.get('WWW-Authenticate');
             const challenges = parseWWWAuthenticateHeader(authHeader);
             for (const challenge of challenges) {
                 if (challenge.scheme === 'Bearer' && challenge.params['resource_metadata']) {
+                    this._log(LogLevel.Debug, `Found resource_metadata challenge in WWW-Authenticate header: ${challenge.params['resource_metadata']}`);
                     resourceMetadataChallenge = challenge.params['resource_metadata'];
                     break;
                 }
@@ -251,17 +269,22 @@ class McpHTTPHandle extends Disposable {
         let serverMetadataUrl;
         let scopesSupported;
         let resource;
-        if (resourceMetadataChallenge) {
-            const resourceMetadata = await this._getResourceMetadata(resourceMetadataChallenge);
-            if (( ( new URL(resourceMetadata.resource)).toString()) !== ( ( new URL(url)).toString())) {
-                throw ( new Error(
-                    `Protected Resource Metadata resource "${resourceMetadata.resource}" does not match MCP server resolved resource "${url}". The MCP server must follow OAuth spec https://datatracker.ietf.org/doc/html/rfc9728#PRConfigurationValidation`
-                ));
-            }
+        try {
+            const resourceMetadata = await fetchResourceMetadata(mcpUrl, resourceMetadataChallenge, {
+                sameOriginHeaders: {
+                    ...Object.fromEntries(this._launch.headers),
+                    'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION
+                },
+                fetch: (url, init) => this._fetch(url, init)
+            });
             serverMetadataUrl = resourceMetadata.authorization_servers?.[0];
+            this._log(LogLevel.Debug, `Using auth server metadata url: ${serverMetadataUrl}`);
             scopesSupported = resourceMetadata.scopes_supported;
             resource = resourceMetadata;
         }
+        catch (e) {
+            this._log(LogLevel.Debug, `Could not fetch resource metadata: ${String(e)}`);
+        }
         const baseUrl = ( new URL(originalResponse.url)).origin;
         let addtionalHeaders = {};
         if (!serverMetadataUrl) {
@@ -272,6 +295,7 @@ class McpHTTPHandle extends Disposable {
         }
         try {
             const serverMetadataResponse = await this._getAuthorizationServerMetadata(serverMetadataUrl, addtionalHeaders);
+            this._log(LogLevel.Info, 'Populated auth metadata');
             this._authMetadata = {
                 authorizationServer: ( URI.parse(serverMetadataUrl)),
                 serverMetadata: serverMetadataResponse,
@@ -280,7 +304,7 @@ class McpHTTPHandle extends Disposable {
             return;
         }
         catch (e) {
-            this._log(LogLevel.Warning, `Error populating auth metadata: ${String(e)}`);
+            this._log(LogLevel.Warning, `Error populating auth server metadata for ${serverMetadataUrl}: ${String(e)}`);
         }
         const defaultMetadata = getDefaultMetadataForUrl(( new URL(baseUrl)));
         defaultMetadata.scopes_supported = scopesSupported ?? defaultMetadata.scopes_supported ?? [];
@@ -289,43 +313,13 @@ class McpHTTPHandle extends Disposable {
             serverMetadata: defaultMetadata,
             resourceMetadata: resource
         };
-    }
-    async _getResourceMetadata(resourceMetadata) {
-        const resourceMetadataUrl = ( new URL(resourceMetadata));
-        const mcpServerUrl = ( new URL(( this._launch.uri.toString(true))));
-        let additionalHeaders = {};
-        if (resourceMetadataUrl.origin === mcpServerUrl.origin) {
-            additionalHeaders = {
-                ...Object.fromEntries(this._launch.headers)
-            };
-        }
-        const resourceMetadataResponse = await this._fetch(resourceMetadata, {
-            method: 'GET',
-            headers: {
-                ...additionalHeaders,
-                'Accept': 'application/json',
-                'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION
-            }
-        });
-        if (resourceMetadataResponse.status !== 200) {
-            throw ( new Error(
-                `Failed to fetch resource metadata: ${resourceMetadataResponse.status} ${await this._getErrText(resourceMetadataResponse)}`
-            ));
-        }
-        const body = await resourceMetadataResponse.json();
-        if (isAuthorizationProtectedResourceMetadata(body)) {
-            return body;
-        }
-        else {
-            throw ( new Error(
-                `Invalid resource metadata. Expected to follow shape of https://datatracker.ietf.org/doc/html/rfc9728#name-protected-resource-metadata (Hints: is scopes_supported an array? Is resource a string?). Current payload: ${JSON.stringify(body)}`
-            ));
-        }
+        this._log(LogLevel.Info, 'Using default auth metadata');
     }
     async _getAuthorizationServerMetadata(authorizationServer, addtionalHeaders) {
         const authorizationServerUrl = ( new URL(authorizationServer));
         const extraPath = authorizationServerUrl.pathname === '/' ? '' : authorizationServerUrl.pathname;
         const pathToFetch = ( ( new URL(AUTH_SERVER_METADATA_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
+        this._log(LogLevel.Debug, `Fetching auth server metadata url with path insertion: ${pathToFetch} ...`);
         let authServerMetadataResponse = await this._fetch(pathToFetch, {
             method: 'GET',
             headers: {
@@ -336,6 +330,7 @@ class McpHTTPHandle extends Disposable {
         });
         if (authServerMetadataResponse.status !== 200) {
             const openidPathInsertionUrl = ( ( new URL(OPENID_CONNECT_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
+            this._log(LogLevel.Debug, `Fetching fallback openid connect discovery url with path insertion: ${openidPathInsertionUrl} ...`);
             authServerMetadataResponse = await this._fetch(openidPathInsertionUrl, {
                 method: 'GET',
                 headers: {
@@ -345,7 +340,9 @@ class McpHTTPHandle extends Disposable {
                 }
             });
             if (authServerMetadataResponse.status !== 200) {
-                authServerMetadataResponse = await this._fetch(( URI.joinPath(( URI.parse(authorizationServer)), OPENID_CONNECT_DISCOVERY_PATH).toString(true)), {
+                const openidPathAdditionUrl = ( URI.joinPath(( URI.parse(authorizationServer)), OPENID_CONNECT_DISCOVERY_PATH).toString(true));
+                this._log(LogLevel.Debug, `Fetching fallback openid connect discovery url with path addition: ${openidPathAdditionUrl} ...`);
+                authServerMetadataResponse = await this._fetch(openidPathAdditionUrl, {
                     method: 'GET',
                     headers: {
                         ...addtionalHeaders,
@@ -531,12 +528,16 @@ class McpHTTPHandle extends Disposable {
     async _addAuthHeader(headers) {
         if (this._authMetadata) {
             try {
-                const token = await this._proxy.$getTokenFromServerMetadata(this._id, this._authMetadata.authorizationServer, this._authMetadata.serverMetadata, this._authMetadata.resourceMetadata);
+                const token = await this._proxy.$getTokenFromServerMetadata(this._id, this._authMetadata.authorizationServer, this._authMetadata.serverMetadata, this._authMetadata.resourceMetadata, this._errorOnUserInteraction);
                 if (token) {
                     headers['Authorization'] = `Bearer ${token}`;
                 }
             }
             catch (e) {
+                if (UserInteractionRequiredError.is(e)) {
+                    this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Stopped, reason: 'needs-user-interaction' });
+                    throw ( new CancellationError());
+                }
                 this._log(LogLevel.Warning, `Error getting token from server metadata: ${String(e)}`);
             }
         }
@@ -555,12 +556,12 @@ class McpHTTPHandle extends Disposable {
             return res.statusText;
         }
     }
-    async _fetchWithAuthRetry(url, init, headers) {
-        const doFetch = () => this._fetch(url, init);
+    async _fetchWithAuthRetry(mcpUrl, init, headers) {
+        const doFetch = () => this._fetch(mcpUrl, init);
         let res = await doFetch();
         if (res.status === 401) {
             if (!this._authMetadata) {
-                await this._populateAuthMetadata(url, res);
+                await this._populateAuthMetadata(mcpUrl, res);
                 await this._addAuthHeader(headers);
                 if (headers['Authorization']) {
                     init.headers = headers;
@@ -584,7 +585,7 @@ class McpHTTPHandle extends Disposable {
         let currentUrl = url;
         let response;
         for (let redirectCount = 0; redirectCount < MAX_FOLLOW_REDIRECTS; redirectCount++) {
-            response = await fetch(currentUrl, {
+            response = await this._fetchInternal(currentUrl, {
                 ...init,
                 signal: this._abortCtrl.signal,
                 redirect: 'manual'
@@ -614,6 +615,9 @@ class McpHTTPHandle extends Disposable {
         }
         return response;
     }
+    _fetchInternal(url, init) {
+        return fetch(url, init);
+    }
 }
 function isJSON(str) {
     try {
@@ -625,4 +629,4 @@ function isJSON(str) {
     }
 }
 
-export { ExtHostMcpService, IExtHostMpcService };
+export { ExtHostMcpService, IExtHostMpcService, McpHTTPHandle };

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

@@ -17,7 +17,7 @@ import { IExtHostConsumerFileSystem } from "./extHostFileSystemConsumer.js";
 import { ITextQuery } from "../../services/search/common/search.js";
 import { IExtHostSearch } from "./extHostSearch.js";
 import { IRawClosedNotebookFileMatch } from "../../contrib/search/common/searchNotebookHelpers.js";
-import { NotebookPriorityInfo } from "@codingame/monaco-vscode-4dda7789-5a25-5e8b-b2de-c2f11b1b96e5-common/vscode/vs/workbench/contrib/search/common/search";
+import { NotebookPriorityInfo } from "@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/search/common/search";
 import { ILogService } from "../../../platform/log/common/log.service.js";
 export declare class ExtHostNotebookController implements ExtHostNotebookShape {
     private _textDocumentsAndEditors;

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

@@ -265,7 +265,7 @@ class ExtHostNotebookController {
                 ));
             }
             if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-                throw new FileOperationError(( localize(2636, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+                throw new FileOperationError(( localize(2642, "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]),
@@ -444,7 +444,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(2637, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(2643, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

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

@@ -62,7 +62,9 @@ export declare class ExtHostSCM implements ExtHostSCMShape {
         number
     ] | undefined>;
     $setSelectedSourceControl(selectedSourceControlHandle: number | undefined): Promise<void>;
+    $resolveHistoryItem(sourceControlHandle: number, historyItemId: string, token: CancellationToken): Promise<SCMHistoryItemDto | undefined>;
     $resolveHistoryItemChatContext(sourceControlHandle: number, historyItemId: string, token: CancellationToken): Promise<string | undefined>;
+    $resolveHistoryItemChangeRangeChatContext(sourceControlHandle: number, historyItemId: string, historyItemParentId: string, path: string, token: CancellationToken): Promise<string | undefined>;
     $resolveHistoryItemRefsCommonAncestor(sourceControlHandle: number, historyItemRefs: string[], token: CancellationToken): Promise<string | undefined>;
     $provideHistoryItemRefs(sourceControlHandle: number, historyItemRefs: string[] | undefined, token: CancellationToken): Promise<SCMHistoryItemRefDto[] | undefined>;
     $provideHistoryItems(sourceControlHandle: number, options: vscode.SourceControlHistoryOptions, token: CancellationToken): Promise<SCMHistoryItemDto[] | undefined>;

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

@@ -851,6 +851,17 @@ let ExtHostSCM = class ExtHostSCM {
         this._selectedSourceControlHandle = selectedSourceControlHandle;
         return Promise.resolve(undefined);
     }
+    async $resolveHistoryItem(sourceControlHandle, historyItemId, token) {
+        try {
+            const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;
+            const historyItem = await historyProvider?.resolveHistoryItem(historyItemId, token);
+            return historyItem ? toSCMHistoryItemDto(historyItem) : undefined;
+        }
+        catch (err) {
+            this.logService.error('ExtHostSCM#$resolveHistoryItem', err);
+            return undefined;
+        }
+    }
     async $resolveHistoryItemChatContext(sourceControlHandle, historyItemId, token) {
         try {
             const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;
@@ -862,6 +873,17 @@ let ExtHostSCM = class ExtHostSCM {
             return undefined;
         }
     }
+    async $resolveHistoryItemChangeRangeChatContext(sourceControlHandle, historyItemId, historyItemParentId, path, token) {
+        try {
+            const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;
+            const chatContext = await historyProvider?.resolveHistoryItemChangeRangeChatContext?.(historyItemId, historyItemParentId, path, token);
+            return chatContext ?? undefined;
+        }
+        catch (err) {
+            this.logService.error('ExtHostSCM#$resolveHistoryItemChangeRangeChatContext', err);
+            return undefined;
+        }
+    }
     async $resolveHistoryItemRefsCommonAncestor(sourceControlHandle, historyItemRefs, token) {
         try {
             const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;

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

@@ -5,7 +5,6 @@ import { Event } from "../../../base/common/event.js";
 import { DisposableStore } from "../../../base/common/lifecycle.js";
 export declare class ExtensionSecrets implements vscode.SecretStorage {
     #private;
-    private readonly _extensionDescription;
     protected readonly _id: string;
     readonly onDidChange: Event<vscode.SecretStorageChangeEvent>;
     readonly disposables: DisposableStore;

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

@@ -2,13 +2,11 @@
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { Event } from '../../../base/common/event.js';
 import { DisposableStore } from '../../../base/common/lifecycle.js';
-import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 
 class ExtensionSecrets {
     #secretState;
     constructor(extensionDescription, secretState) {
         this.disposables = ( new DisposableStore());
-        this._extensionDescription = extensionDescription;
         this._id = ExtensionIdentifier.toKey(extensionDescription.identifier);
         this.#secretState = secretState;
         this.onDidChange = ( Event.map(
@@ -30,7 +28,6 @@ class ExtensionSecrets {
         return this.#secretState.delete(this._id, key);
     }
     keys() {
-        checkProposedApiEnabled(this._extensionDescription, 'secretStorageKeys');
         return ( this.#secretState.keys(this._id)) || [];
     }
 }

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

@@ -188,7 +188,7 @@ class ExtHostStatusBarEntry {
             }
             else {
                 name = ( localize(
-                    2638,
+                    2644,
                     "{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(2639, "Extension Status"));
+        this._item.name = ( localize(2645, "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(
-                2640,
+                2646,
                 "Extension Telemetry{0}",
                 this._inLoggingOnlyMode ? ' (Not Sent)' : ''
             )),

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

@@ -34,7 +34,7 @@ export interface IExtHostTerminalService extends ExtHostTerminalServiceShape, ID
     getEnvironmentVariableCollection(extension: IExtensionDescription): IEnvironmentVariableCollection;
     getTerminalById(id: number): ExtHostTerminal | null;
     getTerminalIdByApiObject(apiTerminal: vscode.Terminal): number | null;
-    registerTerminalCompletionProvider(extension: IExtensionDescription, provider: vscode.TerminalCompletionProvider<vscode.TerminalCompletionItem>, ...triggerCharacters: string[]): vscode.Disposable;
+    registerTerminalCompletionProvider(extension: IExtensionDescription, id: string, provider: vscode.TerminalCompletionProvider<vscode.TerminalCompletionItem>, ...triggerCharacters: string[]): vscode.Disposable;
 }
 interface IEnvironmentVariableCollection extends vscode.EnvironmentVariableCollection {
     getScoped(scope: vscode.EnvironmentVariableScope): vscode.EnvironmentVariableCollection;
@@ -165,7 +165,7 @@ export declare abstract class BaseExtHostTerminalService extends Disposable impl
     $acceptProcessRequestCwd(id: number): void;
     $acceptProcessRequestLatency(id: number): Promise<number>;
     registerProfileProvider(extension: IExtensionDescription, id: string, provider: vscode.TerminalProfileProvider): vscode.Disposable;
-    registerTerminalCompletionProvider(extension: IExtensionDescription, provider: vscode.TerminalCompletionProvider<TerminalCompletionItem>, ...triggerCharacters: string[]): vscode.Disposable;
+    registerTerminalCompletionProvider(extension: IExtensionDescription, id: string, provider: vscode.TerminalCompletionProvider<TerminalCompletionItem>, ...triggerCharacters: string[]): vscode.Disposable;
     $provideTerminalCompletions(id: string, options: ITerminalCompletionContextDto): Promise<TerminalCompletionListDto | undefined>;
     $acceptTerminalShellType(id: number, shellType: TerminalShellType | undefined): void;
     registerTerminalQuickFixProvider(id: string, extensionId: string, provider: vscode.TerminalQuickFixProvider): vscode.Disposable;