@codingame/monaco-vscode-api 37.6.0 → 38.0.0

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

@@ -21,11 +21,21 @@ import { MainContext } from './extHost.protocol.js';
 import { IExtHostAuthentication } from './extHostAuthentication.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { ChatLocation, LanguageModelChatMessage2 } from './extHostTypeConverters.js';
-import { LanguageModelTextPart, LanguageModelThinkingPart, LanguageModelDataPart, LanguageModelToolCallPart, LanguageModelChatToolMode, LanguageModelError, LanguageModelChatMessageRole } from './extHostTypes.js';
+import { LanguageModelChatApiType, LanguageModelTextPart, LanguageModelThinkingPart, LanguageModelDataPart, LanguageModelToolCallPart, LanguageModelChatToolMode, LanguageModelError, LanguageModelChatMessageRole } from './extHostTypes.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 
 var ExtHostLanguageModels_1;
 const IExtHostLanguageModels = ( createDecorator("IExtHostLanguageModels"));
+const apiTypesFromApi = ( new Map([
+    [LanguageModelChatApiType.ChatCompletions, "chatCompletions"],
+    [LanguageModelChatApiType.Responses, "responses"],
+    [LanguageModelChatApiType.Messages, "messages"]
+]));
+const apiTypesToApi = {
+    chatCompletions: LanguageModelChatApiType.ChatCompletions,
+    responses: LanguageModelChatApiType.Responses,
+    messages: LanguageModelChatApiType.Messages
+};
 class LanguageModelResponse {
     constructor() {
         this._defaultStream = new AsyncIterableSource();
@@ -146,6 +156,9 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             silent: options.silent,
             configuration: options.configuration
         }, token)) ?? [];
+        if (this._languageModelProviders.get(vendor) !== data) {
+            return [];
+        }
         const modelMetadataAndIdentifier = modelInformation.map(m => {
             let auth;
             if (m.requiresAuthorization && isProposedApiEnabled(data.extension, "chatProvider")) {
@@ -157,6 +170,9 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             if (m.capabilities.editTools) {
                 checkProposedApiEnabled(data.extension, "chatProvider");
             }
+            if (m.capabilities.apiType !== undefined || m.capabilities.adaptiveThinking !== undefined) {
+                checkProposedApiEnabled(data.extension, "languageModelCapabilities");
+            }
             const isDefaultForLocation = {};
             if (isProposedApiEnabled(data.extension, "chatProvider")) {
                 if (m.isDefault === true) {
@@ -197,6 +213,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                     category: m.category,
                     maxInputTokens: m.maxInputTokens,
                     maxOutputTokens: m.maxOutputTokens,
+                    maxContextWindowTokens: m.maxContextWindowTokens,
                     auth,
                     isDefaultForLocation,
                     isUserSelectable: m.isUserSelectable,
@@ -209,6 +226,8 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                     capabilities: m.capabilities ? {
                         vision: m.capabilities.imageInput,
                         editTools: m.capabilities.editTools,
+                        apiType: m.capabilities.apiType === undefined ? undefined : apiTypesFromApi.get(m.capabilities.apiType),
+                        adaptiveThinking: m.capabilities.adaptiveThinking,
                         toolCalling: !!m.capabilities.toolCalling,
                         agentMode: !!m.capabilities.toolCalling
                     } : undefined
@@ -391,6 +410,24 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }
         return this._createLanguageModelChatApi(extension, modelId);
     }
+    async getLanguageModelForRequest(extension, userSelectedModelId) {
+        if (userSelectedModelId) {
+            const model = await this.getLanguageModelByIdentifier(extension, userSelectedModelId);
+            if (!model) {
+                throw LanguageModelError.NotFound(( localize(
+                    6602,
+                    "The selected model '{0}' is not available. Select a different model and try again.",
+                    userSelectedModelId
+                )));
+            }
+            return model;
+        }
+        const model = await this.getDefaultLanguageModel(extension);
+        if (!model) {
+            throw ( new Error("Language model unavailable"));
+        }
+        return model;
+    }
     async _createLanguageModelChatApi(extension, modelId) {
         const model = this._localModels.get(modelId);
         if (!model) {
@@ -420,7 +457,9 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             capabilities: {
                 supportsImageToText: model.metadata.capabilities?.vision ?? false,
                 supportsToolCalling: !!model.metadata.capabilities?.toolCalling,
-                editToolsHint: model.metadata.capabilities?.editTools
+                editToolsHint: model.metadata.capabilities?.editTools,
+                apiType: model.metadata.capabilities?.apiType === undefined ? undefined : apiTypesToApi[model.metadata.capabilities.apiType],
+                supportsAdaptiveThinking: model.metadata.capabilities?.adaptiveThinking
             },
             maxInputTokens: model.metadata.maxInputTokens,
             countTokens(text, token) {
@@ -541,7 +580,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             return false;
         }
         try {
-            const detail = justification ? ( localize(5281, "Justification: {1}", to.displayName, justification)) : undefined;
+            const detail = justification ? ( localize(6603, "Justification: {1}", to.displayName, justification)) : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], {
                 forceNewSession: {
                     detail

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

@@ -8,7 +8,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 let ExtHostLogService = class ExtHostLogService extends LogService {
     constructor(isWorker, loggerService, initData) {
         const id = initData.remote.isRemote ? "remoteexthost" : isWorker ? "workerexthost" : "exthost";
-        const name = initData.remote.isRemote ? ( localize(5282, "Extension Host (Remote)")) : isWorker ? ( localize(5283, "Extension Host (Worker)")) : ( localize(5284, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(6604, "Extension Host (Remote)")) : isWorker ? ( localize(6605, "Extension Host (Worker)")) : ( localize(6606, "Extension Host"));
         super(loggerService.createLogger(id, {
             name
         }));

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

@@ -6,7 +6,7 @@ import { URI, UriComponents } from "../../../base/common/uri.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { LogLevel } from "../../../platform/log/common/log.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
-import { McpServerDefinition, McpServerLaunch, McpServerTransportHTTP } from "../../contrib/mcp/common/mcpTypes.js";
+import { McpServerDefinition, McpServerEnvironmentVariableExpansion, McpServerLaunch, McpServerTransportHTTP } from "../../contrib/mcp/common/mcpTypes.js";
 import { ExtHostMcpShape, IAuthMetadataSource, IStartMcpOptions, MainThreadMcpShape } from "./extHost.protocol.js";
 import { IExtHostInitDataService } from "./extHostInitDataService.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
@@ -43,6 +43,11 @@ export declare class ExtHostMcpService extends Disposable implements IExtHostMpc
     $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>;
+    /**
+     * Hosts without a process environment, such as the web worker extension host,
+     * leave references verbatim, as the Copilot runtime does without an environment.
+     */
+    $expandEnvironmentVariables(launch: McpServerLaunch.Serialized, _expansion: McpServerEnvironmentVariableExpansion): Promise<McpServerLaunch.Serialized>;
     $stopMcp(id: number): void;
     private _didClose;
     $sendMessage(id: number, message: string): void;
@@ -80,6 +85,7 @@ export declare class McpHTTPHandle extends Disposable {
     private _didSendClose;
     constructor(_id: number, _launch: McpServerTransportHTTP, _proxy: MainThreadMcpShape, _logService: ILogService, _errorOnUserInteraction?: boolean | undefined);
     send(message: string): Promise<void>;
+    private _handleSendError;
     close(): Promise<void>;
     private _closeSession;
     private _send;
@@ -121,6 +127,7 @@ export declare class McpHTTPHandle extends Disposable {
      */
     private _fetchWithAuthRetry;
     private _fetch;
+    private _stripCrossOriginHeaders;
     protected _fetchInternal(url: string, init?: CommonRequestInit): Promise<CommonResponse>;
 }
 interface MinimalRequestInit {

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

@@ -9,6 +9,7 @@ import { scopesMatch, parseWWWAuthenticateHeader, AUTH_SCOPE_SEPARATOR, fetchRes
 import { SSEParser } from '../../../base/common/sseParser.js';
 import { URI } from '../../../base/common/uri.js';
 import { vObj, vOptionalProp, vArray, vString, vObjAny, vNumber } from '../../../base/common/validation.js';
+import { localize } from '../../../nls.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';
@@ -98,6 +99,9 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
             index: folder.index
         }, value);
     }
+    async $expandEnvironmentVariables(launch, _expansion) {
+        return launch;
+    }
     $stopMcp(id) {
         this._sseEventSources.get(id)?.close().then(() => this._didClose(id));
     }
@@ -269,7 +273,7 @@ var HttpMode;
 })(HttpMode || (HttpMode = {}));
 const MAX_FOLLOW_REDIRECTS = 5;
 const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
-const ALLOWED_REDIRECT_PROTOCOLS = ( new Set(["http:", "https:"]));
+const HTTP_PROTOCOLS = ( new Set(["http:", "https:"]));
 const CROSS_ORIGIN_STRIPPED_HEADERS = ( new Set(["authorization", "cookie", "proxy-authorization", "mcp-session-id"]));
 function setHostHeader(headers, name, value) {
     for (const configuredName of ( Object.keys(headers))) {
@@ -279,6 +283,11 @@ function setHostHeader(headers, name, value) {
     }
     headers[name] = value;
 }
+function isSameSocketEndpoint(url, configuredUrl) {
+    const destination = ( URI.parse(url));
+    const configured = ( URI.parse(configuredUrl));
+    return (configured.scheme === "unix" || configured.scheme === "pipe") && destination.scheme === configured.scheme && destination.path === configured.path;
+}
 class McpHTTPHandle extends Disposable {
     constructor(_id, _launch, _proxy, _logService, _errorOnUserInteraction) {
         super();
@@ -311,13 +320,20 @@ class McpHTTPHandle extends Disposable {
                 await this._send(message);
             }
         } catch (err) {
-            const msg = `Error sending message to ${this._launch.uri}: ${stringifyError(err)}`;
-            this._proxy.$onDidChangeState(this._id, {
-                state: McpConnectionState.Kind.Error,
-                message: msg
-            });
+            this._handleSendError(err);
         }
     }
+    _handleSendError(err) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const message = `Error sending message to ${this._launch.uri}: ${stringifyError(err)}`;
+        this.dispose();
+        this._proxy.$onDidChangeState(this._id, {
+            state: McpConnectionState.Kind.Error,
+            message
+        });
+    }
     async close() {
         if (this._mode.value === HttpMode.Http && this._mode.sessionId && !this._didSendClose) {
             this._didSendClose = true;
@@ -362,11 +378,14 @@ class McpHTTPHandle extends Disposable {
     }
     async _sendStreamableHttp(message, sessionId) {
         const asBytes = ( new TextEncoder()).encode(message);
-        const headers = {
-            ...Object.fromEntries(this._launch.headers),
+        const transportHeaders = {
             "Content-Type": "application/json",
             Accept: "text/event-stream, application/json"
         };
+        const headers = {
+            ...Object.fromEntries(this._launch.headers),
+            ...transportHeaders
+        };
         if (sessionId) {
             headers["Mcp-Session-Id"] = sessionId;
         }
@@ -375,7 +394,7 @@ class McpHTTPHandle extends Disposable {
             method: "POST",
             headers,
             body: asBytes
-        }, headers);
+        }, headers, transportHeaders);
         const wasUnknown = this._mode.value === HttpMode.Unknown;
         const nextSessionId = res.headers.get("Mcp-Session-Id");
         if (nextSessionId) {
@@ -415,13 +434,17 @@ class McpHTTPHandle extends Disposable {
         await this._handleSuccessfulStreamableHttp(res, message);
     }
     async _sseFallbackWithMessage(message) {
-        const endpoint = await this._attachSSE();
-        if (endpoint) {
-            this._mode = {
-                value: HttpMode.SSE,
-                endpoint
-            };
-            await this._sendLegacySSE(endpoint, message);
+        try {
+            const endpoint = await this._attachSSE();
+            if (endpoint) {
+                this._mode = {
+                    value: HttpMode.SSE,
+                    endpoint
+                };
+                await this._sendLegacySSE(endpoint, message);
+            }
+        } catch (err) {
+            this._handleSendError(err);
         }
     }
     async _handleSuccessfulStreamableHttp(res, message) {
@@ -473,21 +496,24 @@ class McpHTTPHandle extends Disposable {
             }
             let res;
             try {
+                const transportHeaders = {
+                    "Accept": "text/event-stream"
+                };
+                if (lastEventId) {
+                    transportHeaders["Last-Event-ID"] = lastEventId;
+                }
                 const headers = {
                     ...Object.fromEntries(this._launch.headers),
-                    "Accept": "text/event-stream"
+                    ...transportHeaders
                 };
                 await this._addAuthHeader(headers);
                 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 this._fetchWithAuthRetry(( this._launch.uri.toString(true)), {
                     method: "GET",
                     headers
-                }, headers);
+                }, headers, transportHeaders);
             } catch (e) {
                 this._log(
                     LogLevel.Info,
@@ -525,9 +551,12 @@ class McpHTTPHandle extends Disposable {
     }
     async _attachSSE() {
         const postEndpoint = ( new DeferredPromise());
+        const transportHeaders = {
+            "Accept": "text/event-stream"
+        };
         const headers = {
             ...Object.fromEntries(this._launch.headers),
-            "Accept": "text/event-stream"
+            ...transportHeaders
         };
         await this._addAuthHeader(headers);
         let res;
@@ -535,7 +564,7 @@ class McpHTTPHandle extends Disposable {
             res = await this._fetchWithAuthRetry(( this._launch.uri.toString(true)), {
                 method: "GET",
                 headers
-            }, headers);
+            }, headers, transportHeaders);
             if (res.status >= 300) {
                 this._proxy.$onDidChangeState(this._id, {
                     state: McpConnectionState.Kind.Error,
@@ -568,15 +597,20 @@ class McpHTTPHandle extends Disposable {
     }
     async _sendLegacySSE(url, message) {
         const asBytes = ( new TextEncoder()).encode(message);
+        const transportHeaders = {
+            "Content-Type": "application/json"
+        };
         const headers = {
             ...Object.fromEntries(this._launch.headers),
-            "Content-Type": "application/json"
+            ...transportHeaders
         };
         await this._addAuthHeader(headers);
         const res = await this._fetch(url, {
             method: "POST",
             headers,
             body: asBytes
+        }, {
+            transportHeaders
         });
         if (res.status >= 300) {
             this._log(
@@ -595,12 +629,11 @@ class McpHTTPHandle extends Disposable {
             try {
                 chunk = await raceCancellationError(reader.read(), this._cts.token);
             } catch (err) {
-                reader.cancel();
                 if (this._store.isDisposed) {
                     return;
-                } else {
-                    throw err;
                 }
+                await reader.cancel();
+                throw err;
             }
             if (chunk.value) {
                 parser.feed(chunk.value);
@@ -688,17 +721,25 @@ class McpHTTPHandle extends Disposable {
             return res.statusText;
         }
     }
-    async _fetchWithAuthRetry(mcpUrl, init, headers) {
-        const doFetch = () => this._fetch(mcpUrl, init);
+    async _fetchWithAuthRetry(mcpUrl, init, headers, transportHeaders) {
+        const doFetch = () => this._fetch(mcpUrl, init, {
+            transportHeaders
+        });
         let res = await doFetch();
         if (isAuthStatusCode(res.status)) {
             if (!this._authMetadata) {
+                const protocolHeaders = {
+                    "MCP-Protocol-Version": MCP.LATEST_PROTOCOL_VERSION
+                };
                 this._authMetadata = await createAuthMetadata(mcpUrl, res.headers, {
                     sameOriginHeaders: {
                         ...Object.fromEntries(this._launch.headers),
-                        "MCP-Protocol-Version": MCP.LATEST_PROTOCOL_VERSION
+                        ...protocolHeaders
                     },
-                    fetch: (url, init) => this._fetch(url, init),
+                    fetch: (url, init) => this._fetch(url, init, {
+                        isAuthMetadata: true,
+                        transportHeaders: init.headers["MCP-Protocol-Version"] === MCP.LATEST_PROTOCOL_VERSION ? protocolHeaders : undefined
+                    }),
                     log: (level, message) => this._log(level, message)
                 });
                 this._proxy.$logMcpAuthSetup(this._authMetadata.telemetry);
@@ -730,8 +771,34 @@ class McpHTTPHandle extends Disposable {
         }
         return res;
     }
-    async _fetch(url, init) {
-        setHostHeader(init.headers, "user-agent", `${product.nameLong}/${product.version}`);
+    async _fetch(url, init, options = {}) {
+        const destination = ( new URL(url));
+        const configuredUrl = ( this._launch.uri.toString(true));
+        const isHttp = ( HTTP_PROTOCOLS.has(destination.protocol));
+        const isSameOrigin = isHttp ? destination.origin === ( new URL(configuredUrl)).origin : isSameSocketEndpoint(url, configuredUrl);
+        if (!isHttp && !isSameOrigin) {
+            throw ( new Error(( localize(
+                6607,
+                "MCP server selected a non-http(s) destination ({0}), which is not allowed",
+                destination.protocol
+            ))));
+        }
+        const transportHeaders = {
+            ...options.transportHeaders,
+            "user-agent": `${product.nameLong}/${product.version}`
+        };
+        init = {
+            ...init,
+            headers: {
+                ...init.headers
+            }
+        };
+        for (const [name, value] of Object.entries(transportHeaders)) {
+            setHostHeader(init.headers, name, value);
+        }
+        if (!isSameOrigin) {
+            init.headers = this._stripCrossOriginHeaders(init.headers, transportHeaders);
+        }
         if (canLog(this._logService.getLevel(), LogLevel.Trace)) {
             const traceObj = {
                 ...init,
@@ -753,6 +820,23 @@ class McpHTTPHandle extends Disposable {
         let currentUrl = url;
         let response;
         for (let redirectCount = 0; redirectCount < MAX_FOLLOW_REDIRECTS; redirectCount++) {
+            if (this._cts.token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            if (!options.isAuthMetadata) {
+                const denied = await raceCancellationError(this._proxy.$checkMcpServerAllowed(this._id, currentUrl), this._cts.token);
+                if (denied !== undefined) {
+                    this.dispose();
+                    this._proxy.$onDidChangeState(this._id, {
+                        state: McpConnectionState.Kind.Error,
+                        message: denied
+                    });
+                    throw ( new Error(denied));
+                }
+            }
+            if (this._cts.token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
             response = await this._fetchInternal(currentUrl, {
                 ...init,
                 signal: this._abortCtrl.signal,
@@ -767,17 +851,13 @@ class McpHTTPHandle extends Disposable {
             }
             const currentUrlParsed = ( new URL(currentUrl));
             const nextUrlParsed = ( new URL(location, currentUrl));
-            if (!( ALLOWED_REDIRECT_PROTOCOLS.has(nextUrlParsed.protocol))) {
+            if (!( HTTP_PROTOCOLS.has(nextUrlParsed.protocol))) {
                 throw ( new Error(
                     `MCP server redirected to a non-http(s) target (${nextUrlParsed.protocol}), which is not allowed`
                 ));
             }
             if (currentUrlParsed.origin !== nextUrlParsed.origin) {
-                for (const name of ( Object.keys(init.headers))) {
-                    if (( CROSS_ORIGIN_STRIPPED_HEADERS.has(name.toLowerCase()))) {
-                        delete init.headers[name];
-                    }
-                }
+                init.headers = this._stripCrossOriginHeaders(init.headers, transportHeaders);
             }
             const nextUrl = ( nextUrlParsed.toString());
             this._log(
@@ -802,6 +882,14 @@ class McpHTTPHandle extends Disposable {
         }
         return response;
     }
+    _stripCrossOriginHeaders(headers, transportHeaders) {
+        const configuredNames = ( new Set(this._launch.headers.map(([name]) => name.toLowerCase())));
+        const filtered = Object.fromEntries(Object.entries(headers).filter(([name]) => !( CROSS_ORIGIN_STRIPPED_HEADERS.has(name.toLowerCase())) && !( configuredNames.has(name.toLowerCase()))));
+        for (const [name, value] of Object.entries(transportHeaders)) {
+            setHostHeader(filtered, name, value);
+        }
+        return filtered;
+    }
     _fetchInternal(url, init) {
         return fetch(url, init);
     }

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

@@ -222,6 +222,7 @@ class ExtHostNotebookController {
         };
     }
     $releaseNotebookCellStatusBarItems(cacheId) {
+        this._statusBarCache.get(cacheId, 0)?.dispose();
         this._statusBarCache.delete(cacheId);
     }
     registerNotebookSerializer(extension, viewType, serializer, options, registration) {
@@ -239,6 +240,7 @@ class ExtHostNotebookController {
             location: extension.extensionLocation
         }, viewType, NotebookDocumentContentOptions.from(options), ExtHostNotebookController._convertNotebookRegistrationData(extension, registration));
         return toDisposable(() => {
+            this._notebookSerializer.delete(handle);
             this._notebookProxy.$unregisterNotebookSerializer(handle);
         });
     }
@@ -276,7 +278,7 @@ class ExtHostNotebookController {
                 ));
             }
             if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-                throw new FileOperationError(( localize(5285, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+                throw new FileOperationError(( localize(6608, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
             }
             const data = {
                 metadata: filter(
@@ -474,7 +476,7 @@ class ExtHostNotebookController {
             mtime: options.mtime ,
             size: stat.size
         })) {
-            throw new FileOperationError(( localize(5286, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(6609, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

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

@@ -1,10 +1,11 @@
 import { ProgressOptions } from "vscode";
-import { ExtHostProgressShape } from "./extHost.protocol.js";
-import { Progress, IProgressStep } from "../../../platform/progress/common/progress.js";
+import { ExtHostProgressShape, IProgressStepDto } from "./extHost.protocol.js";
+import { Progress } from "../../../platform/progress/common/progress.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { INotificationSource } from "../../../platform/notification/common/notification.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
+import { NotificationTelemetryId } from "../../../platform/notification/common/notificationTelemetry.js";
 export interface IExtHostProgress extends ExtHostProgress {
 }
 export declare const IExtHostProgress: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostProgress>;
@@ -14,8 +15,8 @@ export declare class ExtHostProgress implements ExtHostProgressShape {
     private _handles;
     private _mapHandleToCancellationSource;
     constructor(extHostRpc: IExtHostRpcService);
-    withProgress<R>(extension: IExtensionDescription, options: ProgressOptions, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Promise<R>;
-    withProgressFromSource<R>(source: string | INotificationSource, options: ProgressOptions, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Promise<R>;
+    withProgress<R>(extension: IExtensionDescription, options: ProgressOptions, task: (progress: Progress<IProgressStepDto>, token: CancellationToken) => Thenable<R>): Promise<R>;
+    withProgressFromSource<R>(source: string | INotificationSource, options: ProgressOptions, task: (progress: Progress<IProgressStepDto>, token: CancellationToken) => Thenable<R>, telemetryId?: NotificationTelemetryId): Promise<R>;
     private _withProgress;
     $acceptProgressCanceled(handle: number): void;
 }

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

@@ -35,7 +35,7 @@ let ExtHostProgress = class ExtHostProgress {
         }, !extension.isUnderDevelopment ? extension.identifier.value : undefined).catch(onUnexpectedExternalError);
         return this._withProgress(handle, task, !!cancellable);
     }
-    async withProgressFromSource(source, options, task) {
+    async withProgressFromSource(source, options, task, telemetryId) {
         const handle = this._handles++;
         const {
             title,
@@ -46,7 +46,8 @@ let ExtHostProgress = class ExtHostProgress {
             location: ProgressLocation.from(location),
             title,
             source,
-            cancellable
+            cancellable,
+            telemetryId
         }, undefined).catch(onUnexpectedExternalError);
         return this._withProgress(handle, task, !!cancellable);
     }

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

@@ -501,6 +501,20 @@ class ExtHostSourceControl {
     get rootUri() {
         return this._rootUri;
     }
+    get activeRepositoryName() {
+        checkProposedApiEnabled(this._extension, "scmProviderOptions");
+        return this._activeRepositoryName;
+    }
+    set activeRepositoryName(activeRepositoryName) {
+        checkProposedApiEnabled(this._extension, "scmProviderOptions");
+        if (this._activeRepositoryName === activeRepositoryName) {
+            return;
+        }
+        this._activeRepositoryName = activeRepositoryName;
+        this.#proxy.$updateSourceControl(this.handle, {
+            activeRepositoryName: activeRepositoryName ?? null
+        });
+    }
     get contextValue() {
         checkProposedApiEnabled(this._extension, "scmProviderOptions");
         return this._contextValue;
@@ -821,8 +835,12 @@ class ExtHostSourceControl {
         this._onDidChangeSelection.fire(selected);
     }
     async provideArtifacts(group, token) {
-        const commandsDisposables = ( new DisposableStore());
+        const providerDisposables = this._artifactProviderDisposable.value;
         const artifacts = await this.artifactProvider?.provideArtifacts(group, token);
+        if (!providerDisposables || providerDisposables.isDisposed || token.isCancellationRequested) {
+            return undefined;
+        }
+        const commandsDisposables = ( new DisposableStore());
         const artifactsDto = artifacts?.map(artifact => ({
             ...artifact,
             icon: getHistoryItemIconDto(artifact.icon),

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

@@ -44,16 +44,16 @@ class ExtHostSpeech {
         if (!provider) {
             return;
         }
-        const disposables = ( new DisposableStore());
         const cts = ( new CancellationTokenSource());
         this.sessions.set(session, cts);
         const textToSpeech = await provider.provideTextToSpeechSession(cts.token, language ? {
             language
         } : undefined);
-        if (!textToSpeech) {
+        if (!textToSpeech || cts.token.isCancellationRequested) {
             return;
         }
         this.synthesizers.set(session, textToSpeech);
+        const disposables = ( new DisposableStore());
         disposables.add(textToSpeech.onDidChange(e => {
             if (cts.token.isCancellationRequested) {
                 return;

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

@@ -23,6 +23,7 @@ export declare class ExtHostStatusBarEntry implements vscode.StatusBarItem {
     private _color?;
     private _backgroundColor?;
     private _latestCommandRegistration?;
+    private _latestCommandRegistrationWasPublished;
     private readonly _staleCommandRegistrations;
     private _command?;
     private _timeoutHandle;