@codingame/monaco-vscode-extensions-service-override 29.1.1 → 30.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "29.1.1",
+  "version": "30.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - extensions service-override",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "29.1.1",
-    "@codingame/monaco-vscode-files-service-override": "29.1.1"
+    "@codingame/monaco-vscode-api": "30.0.1",
+    "@codingame/monaco-vscode-files-service-override": "30.0.1"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.d.ts

@@ -18,7 +18,9 @@ import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
 import { Dto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
-import { IChatProgressDto, IDynamicChatAgentProps, IExtensionChatAgentMetadata, MainThreadChatAgentsShape2 } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IChatSessionCustomizationProviderMetadataDto, IChatProgressDto, IDynamicChatAgentProps, IExtensionChatAgentMetadata, MainThreadChatAgentsShape2 } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { ICustomizationHarnessService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 export declare class MainThreadChatTask implements IChatTask {
     content: IMarkdownString;
     readonly kind = "progressTask";
@@ -45,6 +47,8 @@ export declare class MainThreadChatAgents2 extends Disposable implements MainThr
     private readonly _uriIdentityService;
     private readonly _promptsService;
     private readonly _languageModelToolsService;
+    private readonly _customizationHarnessService;
+    private readonly _configurationService;
     private readonly _agents;
     private readonly _agentCompletionProviders;
     private readonly _agentIdsToCompletionProviders;
@@ -52,11 +56,13 @@ export declare class MainThreadChatAgents2 extends Disposable implements MainThr
     private readonly _promptFileProviders;
     private readonly _promptFileProviderEmitters;
     private readonly _promptFileContentRegistrations;
+    private readonly _customizationProviders;
+    private readonly _customizationProviderEmitters;
     private readonly _pendingProgress;
     private readonly _proxy;
     private readonly _activeTasks;
     private readonly _unresolvedAnchors;
-    constructor(extHostContext: IExtHostContext, _chatAgentService: IChatAgentService, _chatSessionService: IChatSessionsService, _chatService: IChatService, _languageFeaturesService: ILanguageFeaturesService, _chatWidgetService: IChatWidgetService, _instantiationService: IInstantiationService, _logService: ILogService, _extensionService: IExtensionService, _uriIdentityService: IUriIdentityService, _promptsService: IPromptsService, _languageModelToolsService: ILanguageModelToolsService);
+    constructor(extHostContext: IExtHostContext, _chatAgentService: IChatAgentService, _chatSessionService: IChatSessionsService, _chatService: IChatService, _languageFeaturesService: ILanguageFeaturesService, _chatWidgetService: IChatWidgetService, _instantiationService: IInstantiationService, _logService: ILogService, _extensionService: IExtensionService, _uriIdentityService: IUriIdentityService, _promptsService: IPromptsService, _languageModelToolsService: ILanguageModelToolsService, _customizationHarnessService: ICustomizationHarnessService, _configurationService: IConfigurationService);
     private _acceptActiveChatSession;
     private _pushCustomAgents;
     private _pushInstructions;
@@ -77,4 +83,7 @@ export declare class MainThreadChatAgents2 extends Disposable implements MainThr
     $registerPromptFileProvider(handle: number, type: string, extensionId: ExtensionIdentifier): Promise<void>;
     $unregisterPromptFileProvider(handle: number): void;
     $onDidChangePromptFiles(handle: number): void;
+    $registerChatSessionCustomizationProvider(handle: number, chatSessionType: string, metadata: IChatSessionCustomizationProviderMetadataDto, extensionId: ExtensionIdentifier): Promise<void>;
+    $unregisterChatSessionCustomizationProvider(handle: number): void;
+    $onDidChangeCustomizations(handle: number): void;
 }

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -9,6 +9,7 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { getWordAtText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/wordHelper';
 import { CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
@@ -19,6 +20,7 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
 import { isValidPromptType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
@@ -34,6 +36,9 @@ import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { NotebookDto } from './mainThreadNotebookDto.js';
 import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
+import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
 import { getAgentSessionProvider, AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
 
@@ -82,7 +87,9 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         _extensionService,
         _uriIdentityService,
         _promptsService,
-        _languageModelToolsService
+        _languageModelToolsService,
+        _customizationHarnessService,
+        _configurationService
     ) {
         super();
         this._chatAgentService = _chatAgentService;
@@ -96,6 +103,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._uriIdentityService = _uriIdentityService;
         this._promptsService = _promptsService;
         this._languageModelToolsService = _languageModelToolsService;
+        this._customizationHarnessService = _customizationHarnessService;
+        this._configurationService = _configurationService;
         this._agents = this._register(( new DisposableMap()));
         this._agentCompletionProviders = this._register(( new DisposableMap()));
         this._agentIdsToCompletionProviders = this._register(( new DisposableMap()));
@@ -103,12 +112,22 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._promptFileProviders = this._register(( new DisposableMap()));
         this._promptFileProviderEmitters = this._register(( new DisposableMap()));
         this._promptFileContentRegistrations = this._register(( new DisposableMap()));
+        this._customizationProviders = this._register(( new DisposableMap()));
+        this._customizationProviderEmitters = this._register(( new DisposableMap()));
         this._pendingProgress = ( new Map());
         this._activeTasks = ( new Map());
         this._unresolvedAnchors = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("chat.customizations.providerApi.enabled")) {
+                if (!this._configurationService.getValue("chat.customizations.providerApi.enabled")) {
+                    this._customizationProviders.clearAndDisposeAll();
+                    this._customizationProviderEmitters.clearAndDisposeAll();
+                }
+            }
+        }));
         this._register(this._chatService.onDidDisposeSession(e => {
-            for (const resource of e.sessionResource) {
+            for (const resource of e.sessionResources) {
                 this._proxy.$releaseSession(resource);
             }
         }));
@@ -547,8 +566,86 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             emitter.fire();
         }
     }
+    async $registerChatSessionCustomizationProvider(handle, chatSessionType, metadata, extensionId) {
+        if (!this._configurationService.getValue("chat.customizations.providerApi.enabled")) {
+            this._logService.trace(
+                `[MainThreadChatAgents2] Customization provider API is disabled, ignoring registration from ${extensionId.value}`
+            );
+            return;
+        }
+        const extension = await this._extensionService.getExtension(extensionId.value);
+        if (!extension) {
+            this._logService.error(
+                `[MainThreadChatAgents2] Could not find extension for customization provider: ${extensionId.value}`
+            );
+            return;
+        }
+        const emitter = ( new Emitter());
+        this._customizationProviderEmitters.set(handle, emitter);
+        const itemProvider = {
+            onDidChange: emitter.event,
+            provideChatSessionCustomizations: async token => {
+                const items = await this._proxy.$provideChatSessionCustomizations(handle, token);
+                if (!items) {
+                    return undefined;
+                }
+                return ( items.map(item => ({
+                    uri: URI.revive(item.uri),
+                    type: item.type,
+                    name: item.name,
+                    description: item.description,
+                    groupKey: item.groupKey,
+                    badge: item.badge,
+                    badgeTooltip: item.badgeTooltip
+                })));
+            }
+        };
+        const hiddenSections = metadata.unsupportedTypes?.map(type => {
+            switch (type) {
+            case "agent":
+                return AICustomizationManagementSection.Agents;
+            case "skill":
+                return AICustomizationManagementSection.Skills;
+            case "instructions":
+                return AICustomizationManagementSection.Instructions;
+            case "prompt":
+                return AICustomizationManagementSection.Prompts;
+            case "hook":
+                return AICustomizationManagementSection.Hooks;
+            default:
+                return type;
+            }
+        });
+        const descriptor = {
+            id: chatSessionType,
+            label: metadata.label,
+            icon: metadata.iconId ? ThemeIcon.fromId(metadata.iconId) : ThemeIcon.fromId(Codicon.extensions.id),
+            hiddenSections,
+            getStorageSourceFilter: () => ({
+                sources: [
+                    PromptsStorage.local,
+                    PromptsStorage.user,
+                    PromptsStorage.plugin,
+                    PromptsStorage.extension
+                ]
+            }),
+            itemProvider
+        };
+        const registration = this._customizationHarnessService.registerExternalHarness(descriptor);
+        this._customizationProviders.set(handle, registration);
+    }
+    $unregisterChatSessionCustomizationProvider(handle) {
+        this._customizationProviders.deleteAndDispose(handle);
+        this._customizationProviderEmitters.deleteAndDispose(handle);
+    }
+    $onDidChangeCustomizations(handle) {
+        const emitter = this._customizationProviderEmitters.get(handle);
+        if (emitter) {
+            emitter.fire();
+        }
+    }
 };
-MainThreadChatAgents2 = __decorate([extHostNamedCustomer(MainContext.MainThreadChatAgents2), ( __param(1, IChatAgentService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, ILanguageFeaturesService)), ( __param(5, IChatWidgetService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IExtensionService)), ( __param(9, IUriIdentityService)), ( __param(10, IPromptsService)), ( __param(11, ILanguageModelToolsService))], MainThreadChatAgents2);
+MainThreadChatAgents2 = __decorate([extHostNamedCustomer(MainContext.MainThreadChatAgents2), ( __param(1, IChatAgentService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, ILanguageFeaturesService)), ( __param(5, IChatWidgetService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IExtensionService)), ( __param(9, IUriIdentityService)), ( __param(10, IPromptsService)), ( __param(11, ILanguageModelToolsService)), ( __param(12, ICustomizationHarnessService)), ( __param(13, IConfigurationService))], MainThreadChatAgents2);
 function computeCompletionRanges(model, position, reg) {
     const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
     if (!varWord && model.getWordUntilPosition(position).word) {

package/vscode/src/vs/workbench/api/browser/mainThreadChatSessions.d.ts

@@ -7,12 +7,12 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 import { IChatContentInlineReference, IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { IChatSession, IChatSessionHistoryItem, IChatSessionItem, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, ReadonlyChatSessionOptionsMap } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 import { IChatAgentRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
-import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 import { IChatArtifactsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service";
 import { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
@@ -86,7 +86,6 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     private _getHandleForSessionType;
     $registerChatSessionItemController(handle: number, chatSessionType: string): void;
     private getController;
-    private _resolveSessionItem;
     $updateChatSessionItems(controllerHandle: number, change: IChatSessionItemsChange): Promise<void>;
     $addOrUpdateChatSessionItem(controllerHandle: number, item: Dto<IChatSessionItem>): Promise<void>;
     $onDidChangeChatSessionOptions(handle: number, sessionResourceComponents: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem>): void;
@@ -95,7 +94,6 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
      * Re-sends pending and in-flight requests from the original session on the committed session.
      */
     private _resendPendingRequests;
-    private handleSessionModelOverrides;
     private _provideChatSessionContent;
     $unregisterChatSessionItemController(handle: number): void;
     $registerChatSessionContentProvider(handle: number, chatSessionScheme: string): void;
@@ -109,7 +107,6 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     $onDidChangeChatSessionProviderOptions(handle: number): void;
     private _refreshProviderOptions;
     dispose(): void;
-    private _reviveTooltip;
     /**
      * Notify the extension about option changes for a session
      */

package/vscode/src/vs/workbench/api/browser/mainThreadChatSessions.js

@@ -3,10 +3,11 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { markdownStringEqual, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableResourceMap, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -18,15 +19,15 @@ import { hasValidDiff } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
 import { isIChatViewViewContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { getInProgressSessionDescription } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSessions/chatSessionDescription';
+import { getSessionStatusForModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSessions/chatSessions.contribution';
 import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
-import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
-import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatSessionOptionsMap, ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { ChatSessionOptionsMap } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
-import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { getChatSessionType, isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { IChatArtifactsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service';
 import { IChatTodoListService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
@@ -35,7 +36,20 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 
+function stringOrMarkdownEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    if (typeof a === "string" || typeof b === "string") {
+        return false;
+    }
+    return markdownStringEqual(a, b);
+}
 class ObservableChatSession extends Disposable {
     get options() {
         return this._options ? ( new Map(this._options)) : undefined;
@@ -97,7 +111,8 @@ class ObservableChatSession extends Disposable {
                             variables
                         } : undefined,
                         id: turn.id,
-                        modelId: turn.modelId
+                        modelId: turn.modelId,
+                        modeInstructions: turn.modeInstructions ? revive(turn.modeInstructions) : undefined
                     };
                 }
                 return {
@@ -250,7 +265,8 @@ class ObservableChatSession extends Disposable {
             participant: request.participant,
             command: request.command,
             variableData: undefined,
-            modelId: request.modelId
+            modelId: request.modelId,
+            modeInstructions: request.modeInstructions
         };
     }
     dispose() {
@@ -266,24 +282,49 @@ class ObservableChatSession extends Disposable {
     }
 }
 let MainThreadChatSessionItemController = class MainThreadChatSessionItemController extends Disposable {
-    constructor(proxy, chatSessionType, handle, chatService, _logService) {
+    constructor(proxy, chatSessionType, handle, _chatService, _logService) {
         super();
+        this._chatService = _chatService;
         this._logService = _logService;
         this._onDidChangeChatSessionItems = this._register(( new Emitter()));
         this.onDidChangeChatSessionItems = this._onDidChangeChatSessionItems.event;
+        this._modelListeners = this._register(( new DisposableResourceMap()));
+        this._isDisposed = false;
         this._items = ( new ResourceMap());
         this._proxy = proxy;
         this._handle = handle;
-        this._register(
-            chatService.registerChatModelChangeListeners(chatSessionType, sessionResource => {
-                const item = this._items.get(sessionResource);
-                if (item) {
-                    this._onDidChangeChatSessionItems.fire({
-                        addedOrUpdated: [item]
-                    });
-                }
-            })
-        );
+        const addModelListeners = async model => {
+            if (getChatSessionType(model.sessionResource) !== chatSessionType) {
+                return;
+            }
+            await this.refresh(CancellationToken.None);
+            if (this._isDisposed) {
+                return;
+            }
+            this.tryUpdateItemForModel(model);
+            const requestChangeListener = ( model.lastRequestObs.map(
+                last => last?.response && observableSignalFromEvent("chatSessions.modelRequestChangeListener", last.response.onDidChange)
+            ));
+            const modelChangeListener = observableSignalFromEvent("chatSessions.modelChangeListener", model.onDidChange);
+            this._modelListeners.set(model.sessionResource, autorun(reader => {
+                requestChangeListener.read(reader)?.read(reader);
+                modelChangeListener.read(reader);
+                this.tryUpdateItemForModel(model);
+            }));
+        };
+        this._register(_chatService.onDidCreateModel(model => addModelListeners(model)));
+        for (const model of _chatService.chatModels.get()) {
+            addModelListeners(model);
+        }
+        this._register(_chatService.onDidDisposeSession(e => {
+            for (const sessionResource of e.sessionResources) {
+                this._modelListeners.deleteAndDispose(sessionResource);
+            }
+        }));
+    }
+    dispose() {
+        this._isDisposed = true;
+        super.dispose();
     }
     get items() {
         return Array.from(( this._items.values()));
@@ -300,39 +341,77 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
         if (!dto) {
             return undefined;
         }
-        const item = {
-            ...dto,
-            resource: URI.revive(dto.resource),
-            changes: revive(dto.changes)
-        };
-        this._items.set(item.resource, item);
-        this._onDidChangeChatSessionItems.fire({
-            addedOrUpdated: [item]
-        });
+        const item = this.addOrUpdateItem(dto);
         return item;
     }
-    acceptChange(change) {
+    async acceptChange(change) {
+        const addedOrUpdatedItems = [];
         for (const item of change.addedOrUpdated) {
-            warnOnUntitledSessionResource(item.resource, this._logService);
-            this._items.set(item.resource, item);
+            addedOrUpdatedItems.push(await this.addOrUpdateItem(item));
         }
         for (const uri of change.removed) {
             this._items.delete(uri);
         }
         this._onDidChangeChatSessionItems.fire({
-            addedOrUpdated: change.addedOrUpdated,
+            addedOrUpdated: addedOrUpdatedItems,
             removed: change.removed
         });
     }
-    addOrUpdateItem(item) {
-        warnOnUntitledSessionResource(item.resource, this._logService);
-        this._items.set(item.resource, item);
+    async addOrUpdateItem(dto) {
+        const resource = URI.revive(dto.resource);
+        warnOnUntitledSessionResource(resource, this._logService);
+        const existing = this._items.get(resource);
+        const updated = ( new MainThreadChatSessionItem(
+            dto,
+            this._chatService.getSession(resource),
+            await this._chatService.getMetadataForSession(resource)
+        ));
+        if (existing?.isEqual(updated)) {
+            return existing;
+        }
+        this._items.set(resource, updated);
         this._onDidChangeChatSessionItems.fire({
-            addedOrUpdated: [item]
+            addedOrUpdated: [updated]
         });
+        return updated;
+    }
+    async tryUpdateItemForModel(model) {
+        const resource = model.sessionResource;
+        const existing = this._items.get(resource);
+        if (existing) {
+            this.addOrUpdateItem(existing);
+        }
     }
 };
 MainThreadChatSessionItemController = ( __decorate([( __param(3, IChatService)), ( __param(4, ILogService))], MainThreadChatSessionItemController));
+class MainThreadChatSessionItem {
+    constructor(dto, model, detailOverrides) {
+        this.resource = URI.revive(dto.resource);
+        this.label = dto.label;
+        this.timing = dto.timing;
+        this.iconPath = dto.iconPath;
+        this.badge = reviveMarkdownString(dto.badge);
+        this.tooltip = reviveMarkdownString(dto.tooltip);
+        this.archived = dto.archived;
+        this.metadata = dto.metadata;
+        this.description = (model && getInProgressSessionDescription(model)) ?? reviveMarkdownString(dto.description);
+        this.status = (model && getSessionStatusForModel(model)) ?? dto.status;
+        this.changes = revive(dto.changes);
+        if (detailOverrides && !this.changes) {
+            const diffs = {
+                files: detailOverrides.stats?.fileCount || 0,
+                insertions: detailOverrides.stats?.added || 0,
+                deletions: detailOverrides.stats?.removed || 0
+            };
+            if (hasValidDiff(diffs)) {
+                this.changes = diffs;
+            }
+        }
+    }
+    isEqual(other) {
+        return isEqual(this.resource, other.resource) && this.label === other.label && this.description === other.description && this.status === other.status && this.timing.created === other.timing.created && this.timing.lastRequestStarted === other.timing.lastRequestStarted && this.timing.lastRequestEnded === other.timing.lastRequestEnded && equals(this.changes, other.changes) && equals(this.iconPath, other.iconPath) && stringOrMarkdownEqual(this.badge, other.badge) && stringOrMarkdownEqual(this.tooltip, other.tooltip) && this.archived === other.archived && equals(this.metadata, other.metadata);
+    }
+}
 let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     constructor(
         _extHostContext,
@@ -425,45 +504,19 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         }
         return registration.controller;
     }
-    async _resolveSessionItem(item) {
-        const uri = URI.revive(item.resource);
-        const model = this._chatService.getSession(uri);
-        if (model) {
-            item = await this.handleSessionModelOverrides(model, item);
-        }
-        let changes = revive(item.changes);
-        if (!changes || !model) {
-            const stats = (await this._chatService.getMetadataForSession(uri))?.stats;
-            const diffs = {
-                files: stats?.fileCount || 0,
-                insertions: stats?.added || 0,
-                deletions: stats?.removed || 0
-            };
-            if (hasValidDiff(diffs)) {
-                changes = diffs;
-            }
-        }
-        return {
-            ...item,
-            changes,
-            resource: uri,
-            iconPath: item.iconPath,
-            tooltip: item.tooltip ? this._reviveTooltip(item.tooltip) : undefined,
-            archived: item.archived
-        };
-    }
     async $updateChatSessionItems(controllerHandle, change) {
         const controller = this.getController(controllerHandle);
-        const resolvedItems = await Promise.all(( change.addedOrUpdated.map(item => this._resolveSessionItem(item))));
         controller.acceptChange({
-            addedOrUpdated: resolvedItems,
+            addedOrUpdated: change.addedOrUpdated,
             removed: ( change.removed.map(uri => URI.revive(uri)))
         });
     }
     async $addOrUpdateChatSessionItem(controllerHandle, item) {
         const controller = this.getController(controllerHandle);
-        const resolvedItem = await this._resolveSessionItem(item);
-        controller.addOrUpdateItem(resolvedItem);
+        controller.acceptChange({
+            addedOrUpdated: [item],
+            removed: []
+        });
     }
     $onDidChangeChatSessionOptions(handle, sessionResourceComponents, updates) {
         const sessionResource = URI.revive(sessionResourceComponents);
@@ -486,7 +539,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         const contribution = this._chatSessionsService.getAllChatSessionContributions().find(c => c.type === chatSessionType);
         try {
             this._chatTodoListService.migrateTodos(originalResource, modifiedResource);
-            this._chatArtifactsService.migrateArtifacts(originalResource, modifiedResource);
+            this._chatArtifactsService.getArtifacts(originalResource).migrate(this._chatArtifactsService.getArtifacts(modifiedResource));
             if (chatSessionType === "copilotcli") {
                 this._chatDebugService.invokeProviders(modifiedResource).catch(() => {});
             }
@@ -529,6 +582,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 ref?.dispose();
             }
             this._resendPendingRequests(originalResource, modifiedResource);
+            this._chatSessionsService.fireSessionCommitted(originalResource, modifiedResource);
         } finally {
             originalModel?.dispose();
         }
@@ -536,29 +590,6 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     _resendPendingRequests(originalResource, modifiedResource) {
         this._chatService.migrateRequests(originalResource, modifiedResource);
     }
-    async handleSessionModelOverrides(model, session) {
-        const outgoingSession = {
-            ...session
-        };
-        const inProgress = model.getRequests().filter(r => r.response && !r.response.isComplete);
-        if (inProgress.length) {
-            outgoingSession.description = this._chatSessionsService.getInProgressSessionDescription(model);
-        }
-        if (!(outgoingSession.changes instanceof Array)) {
-            const modelStats = await awaitStatsForSession(model);
-            if (modelStats) {
-                outgoingSession.changes = {
-                    files: modelStats.fileCount,
-                    insertions: modelStats.added,
-                    deletions: modelStats.removed
-                };
-            }
-        }
-        if (model.lastRequest?.response?.state === ResponseModelState.NeedsInput) {
-            outgoingSession.status = ChatSessionStatus.NeedsInput;
-        }
-        return outgoingSession;
-    }
     async _provideChatSessionContent(providerHandle, sessionResource, token) {
         warnOnUntitledSessionResource(sessionResource, this._logService);
         let session = this._activeSessions.get(sessionResource);
@@ -709,18 +740,6 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._sessionDisposables.clear();
         super.dispose();
     }
-    _reviveTooltip(tooltip) {
-        if (!tooltip) {
-            return undefined;
-        }
-        if (typeof tooltip === "string") {
-            return tooltip;
-        }
-        if (typeof tooltip === "object" && "value" in tooltip) {
-            return MarkdownString.lift(tooltip);
-        }
-        return undefined;
-    }
     async notifyOptionsChange(handle, sessionResource, updates) {
         this._logService.trace(
             `[MainThreadChatSessions] notifyOptionsChange: starting proxy call for handle ${handle}, sessionResource ${sessionResource}`
@@ -751,5 +770,17 @@ function warnOnUntitledSessionResource(resource, logService) {
         );
     }
 }
+function reviveMarkdownString(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "object" && "value" in value) {
+        return MarkdownString.lift(value);
+    }
+    return undefined;
+}
 
 export { MainThreadChatSessions, ObservableChatSession };

package/vscode/src/vs/workbench/api/browser/mainThreadLanguageModelTools.js

@@ -34,6 +34,7 @@ let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Di
             displayName: tool.displayName,
             toolReferenceName: tool.toolReferenceName,
             legacyToolReferenceFullNames: tool.legacyToolReferenceFullNames,
+            fullReferenceName: tool.source.type === "mcp" ? this._languageModelToolsService.getFullReferenceName(tool) : undefined,
             tags: tool.tags,
             userDescription: tool.userDescription,
             modelDescription: tool.modelDescription,

package/vscode/src/vs/workbench/contrib/browserView/common/browserEditorInput.d.ts

@@ -24,7 +24,7 @@ export declare class BrowserEditorInput extends EditorInput {
     static readonly EDITOR_ID = "workbench.editor.browser";
     private static readonly DEFAULT_LABEL;
     private readonly _id;
-    private readonly _initialData;
+    private _initialData;
     private _model;
     private _modelPromise;
     constructor(options: IBrowserEditorInputData, themeService: IThemeService, browserViewWorkbenchService: IBrowserViewWorkbenchService, lifecycleService: ILifecycleService, instantiationService: IInstantiationService, telemetryService: ITelemetryService);
@@ -32,6 +32,7 @@ export declare class BrowserEditorInput extends EditorInput {
     get url(): string | undefined;
     get title(): string | undefined;
     get favicon(): string | undefined;
+    navigate(url: string): void;
     resolve(): Promise<IBrowserViewModel>;
     get typeId(): string;
     get editorId(): string;

package/vscode/src/vs/workbench/contrib/browserView/common/browserEditorInput.js

@@ -39,7 +39,7 @@ let BrowserEditorInput = class BrowserEditorInput extends EditorInput {
         this.EDITOR_ID = "workbench.editor.browser";
     }
     static {
-        this.DEFAULT_LABEL = ( localize(4618, "Browser"));
+        this.DEFAULT_LABEL = ( localize(4617, "Browser"));
     }
     constructor(
         options,
@@ -80,6 +80,17 @@ let BrowserEditorInput = class BrowserEditorInput extends EditorInput {
     get favicon() {
         return this._model ? this._model.favicon : this._initialData.favicon;
     }
+    navigate(url) {
+        if (this._model) {
+            void this._model.loadURL(url);
+        } else {
+            this._initialData = {
+                id: this._id,
+                url
+            };
+            this._onDidChangeLabel.fire();
+        }
+    }
     async resolve() {
         if (!this._model && !this._modelPromise) {
             this._modelPromise = (async () => {
@@ -195,7 +206,7 @@ let BrowserEditorInput = class BrowserEditorInput extends EditorInput {
         return {
             resource: this.resource,
             options: {
-                override: BrowserEditorInput_1.ID,
+                override: BrowserEditorInput_1.EDITOR_ID,
                 viewState
             }
         };

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -60,7 +60,7 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
         }));
         this._register(extensionService.onWillStop(e => {
             e.veto(true, ( localize(
-                7949,
+                8014,
                 "An extension provided text editor for '{0}' is still open that would close otherwise.",
                 this.name
             )));

package/vscode/src/vs/workbench/services/extensionManagement/browser/extensionBisect.js

@@ -169,11 +169,11 @@ let ExtensionBisectUi = class ExtensionBisectUi {
     }
     _showBisectPrompt() {
         const goodPrompt = {
-            label: ( localize(15893, "I can't reproduce")),
+            label: ( localize(15979, "I can't reproduce")),
             run: () => this._commandService.executeCommand("extension.bisect.next", false)
         };
         const badPrompt = {
-            label: ( localize(15894, "I can reproduce")),
+            label: ( localize(15980, "I can reproduce")),
             run: () => this._commandService.executeCommand("extension.bisect.next", true)
         };
         const stop = {
@@ -181,10 +181,10 @@ let ExtensionBisectUi = class ExtensionBisectUi {
             run: () => this._commandService.executeCommand("extension.bisect.stop")
         };
         const message = this._extensionBisectService.disabledCount === 1 ? ( localize(
-            15895,
+            15981,
             "Extension Bisect is active and has disabled 1 extension. Check if you can still reproduce the problem and proceed by selecting from these options."
         )) : ( localize(
-            15896,
+            15982,
             "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
             this._extensionBisectService.disabledCount
         ));
@@ -200,7 +200,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "extension.bisect.start",
-            title: ( localize2(15897, "Start Extension Bisect")),
+            title: ( localize2(15983, "Start Extension Bisect")),
             category: Categories.Help,
             f1: true,
             precondition: ( ExtensionBisectUi.ctxIsBisectActive.negate()),
@@ -220,13 +220,13 @@ registerAction2(class extends Action2 {
         const extensionsBisect = accessor.get(IExtensionBisectService);
         const extensions = (await extensionManagement.getInstalled(ExtensionType.User)).filter(ext => extensionEnablementService.isEnabled(ext));
         const res = await dialogService.confirm({
-            message: ( localize(15898, "Extension Bisect")),
+            message: ( localize(15984, "Extension Bisect")),
             detail: ( localize(
-                15899,
+                15985,
                 "Extension Bisect will use binary search to find an extension that causes a problem. During the process the window reloads repeatedly (~{0} times). Each time you must confirm if you are still seeing problems.",
                 2 + Math.log2(extensions.length) | 0
             )),
-            primaryButton: ( localize(15900, "&&Start Extension Bisect"))
+            primaryButton: ( localize(15986, "&&Start Extension Bisect"))
         });
         if (res.confirmed) {
             await extensionsBisect.start(extensions);
@@ -238,7 +238,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "extension.bisect.next",
-            title: ( localize2(15901, "Continue Extension Bisect")),
+            title: ( localize2(15987, "Continue Extension Bisect")),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive
@@ -272,24 +272,24 @@ registerAction2(class extends Action2 {
             return;
         }
         if (done.bad) {
-            await dialogService.info(( localize(15902, "Extension Bisect")), ( localize(
-                15903,
+            await dialogService.info(( localize(15988, "Extension Bisect")), ( localize(
+                15989,
                 "Extension Bisect is done but no extension has been identified. This might be a problem with {0}.",
                 productService.nameShort
             )));
         } else {
             const res = await dialogService.confirm({
                 type: Severity.Info,
-                message: ( localize(15902, "Extension Bisect")),
-                primaryButton: ( localize(15904, "&&Report Issue & Continue")),
-                cancelButton: ( localize(15905, "Continue")),
+                message: ( localize(15988, "Extension Bisect")),
+                primaryButton: ( localize(15990, "&&Report Issue & Continue")),
+                cancelButton: ( localize(15991, "Continue")),
                 detail: ( localize(
-                    15906,
+                    15992,
                     "Extension Bisect is done and has identified {0} as the extension causing the problem.",
                     done.id
                 )),
                 checkbox: {
-                    label: ( localize(15907, "Keep this extension disabled")),
+                    label: ( localize(15993, "Keep this extension disabled")),
                     checked: true
                 }
             });
@@ -310,24 +310,24 @@ registerAction2(class extends Action2 {
             result
         } = await dialogService.prompt({
             type: Severity.Info,
-            message: ( localize(15908, "Extension Bisect")),
+            message: ( localize(15994, "Extension Bisect")),
             detail: ( localize(
-                15909,
+                15995,
                 "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
                 bisectService.disabledCount
             )),
             buttons: [{
-                label: ( localize(15910, "I ca&&n't reproduce")),
+                label: ( localize(15996, "I ca&&n't reproduce")),
                 run: () => false
             }, {
-                label: ( localize(15911, "I can &&reproduce")),
+                label: ( localize(15997, "I can &&reproduce")),
                 run: () => true
             }, {
-                label: ( localize(15912, "&&Stop Bisect")),
+                label: ( localize(15998, "&&Stop Bisect")),
                 run: () => undefined
             }],
             cancelButton: {
-                label: ( localize(15913, "&&Cancel Bisect")),
+                label: ( localize(15999, "&&Cancel Bisect")),
                 run: () => null
             }
         });
@@ -338,7 +338,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "extension.bisect.stop",
-            title: ( localize2(15914, "Stop Extension Bisect")),
+            title: ( localize2(16000, "Stop Extension Bisect")),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive

package/vscode/src/vs/workbench/services/extensionManagement/browser/webExtensionsScannerService.js

@@ -768,7 +768,7 @@ let WebExtensionsScannerService = class WebExtensionsScannerService extends Disp
         }
         if (!this.extensionManifestPropertiesService.canExecuteOnWeb(manifest)) {
             throw ( new Error(( localize(
-                15929,
+                16015,
                 "Cannot add '{0}' because this extension is not a web extension.",
                 manifest.displayName || manifest.name
             ))));
@@ -1049,7 +1049,7 @@ if (isWeb) {
         constructor() {
             super({
                 id: "workbench.extensions.action.openInstalledWebExtensionsResource",
-                title: ( localize2(15930, "Open Installed Web Extensions Resource")),
+                title: ( localize2(16016, "Open Installed Web Extensions Resource")),
                 category: Categories.Developer,
                 f1: true,
                 precondition: IsWebContext

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.js

@@ -221,13 +221,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                     }
                 }, {
                     id: "join.disconnectRemote",
-                    label: ( localize(15996, "Disconnect Remote Agent")),
+                    label: ( localize(16082, "Disconnect Remote Agent")),
                     order: WillShutdownJoinerOrder.Last
                 });
             } else {
                 event.join(this._doStopExtensionHosts(), {
                     id: "join.stopExtensionHosts",
-                    label: ( localize(15997, "Stopping Extension Hosts"))
+                    label: ( localize(16083, "Stopping Extension Hosts"))
                 });
             }
         }));
@@ -300,7 +300,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    15998,
+                    16084,
                     "The following extensions contain dependency loops and have been disabled: {0}",
                     ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(", ")
                 ))
@@ -537,7 +537,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    15998,
+                    16084,
                     "The following extensions contain dependency loops and have been disabled: {0}",
                     ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(", ")
                 ))
@@ -552,7 +552,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
             const msg = ( localize(
-                15999,
+                16085,
                 "No extension host found that can launch the test runner at {0}.",
                 (this._environmentService.extensionTestsLocationURI.toString())
             ));
@@ -722,7 +722,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( localize(16000, "{0} (Error: {1})", reason, toErrorMessage(error))));
+                        vetoReasons.add(( localize(16086, "{0} (Error: {1})", reason, toErrorMessage(error))));
                     });
                 }
             }
@@ -740,9 +740,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                     confirmed
                 } = await this._dialogService.confirm({
                     type: Severity.Warning,
-                    message: ( localize(16001, "Please confirm restart of extensions.")),
+                    message: ( localize(16087, "Please confirm restart of extensions.")),
                     detail: vetoReasonsArray.length === 1 ? vetoReasonsArray[0] : vetoReasonsArray.join("\n -"),
-                    primaryButton: ( localize(16002, "Restart Anyway"))
+                    primaryButton: ( localize(16088, "Restart Anyway"))
                 });
                 if (confirmed) {
                     return true;
@@ -856,16 +856,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._remoteCrashTracker.registerCrash();
             if (this._remoteCrashTracker.shouldAutomaticallyRestart()) {
                 this._logService.info(`Automatically restarting the remote extension host.`);
-                this._notificationService.status(( localize(16003, "The remote extension host terminated unexpectedly. Restarting...")), {
+                this._notificationService.status(( localize(16089, "The remote extension host terminated unexpectedly. Restarting...")), {
                     hideAfter: 5000
                 });
                 this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
             } else {
                 this._notificationService.prompt(Severity.Error, ( localize(
-                    16004,
+                    16090,
                     "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
                 )), [{
-                    label: ( localize(16005, "Restart Remote Extension Host")),
+                    label: ( localize(16091, "Restart Remote Extension Host")),
                     run: () => {
                         this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
                     }
@@ -1413,7 +1413,7 @@ class ActivationFeatureMarkdowneRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "activationEvents",
-    label: ( localize(16006, "Activation Events")),
+    label: ( localize(16092, "Activation Events")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManager.js

@@ -485,7 +485,7 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     constructor() {
         super({
             id: "editor.action.measureExtHostLatency",
-            title: ( localize2(16007, "Measure Extension Host Latency")),
+            title: ( localize2(16093, "Measure Extension Host Latency")),
             category: Categories.Developer,
             f1: true
         });

package/vscode/src/vs/workbench/services/extensions/common/extensionsProposedApi.js

@@ -110,7 +110,7 @@ class ApiProposalsMarkdowneRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "enabledApiProposals",
-    label: ( localize(16008, "API Proposals")),
+    label: ( localize(16094, "API Proposals")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/services/extensions/common/extensionsUtil.js

@@ -9,7 +9,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
         const extension = result.get(systemExtension.identifier);
         if (extension) {
             logService.warn(( localize(
-                16097,
+                16183,
                 "Overwriting extension {0} with {1}.",
                 extension.extensionLocation.fsPath,
                 systemExtension.extensionLocation.fsPath
@@ -30,7 +30,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
                 userExtension.isBuiltin = true;
             } else {
                 logService.warn(( localize(
-                    16097,
+                    16183,
                     "Overwriting extension {0} with {1}.",
                     extension.extensionLocation.fsPath,
                     userExtension.extensionLocation.fsPath
@@ -48,7 +48,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
         const extension = result.get(workspaceExtension.identifier);
         if (extension) {
             logService.warn(( localize(
-                16098,
+                16184,
                 "Overwriting {0} with Workspace Extension {1}.",
                 extension.extensionLocation.fsPath,
                 workspaceExtension.extensionLocation.fsPath
@@ -58,7 +58,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
     });
     development.forEach(developedExtension => {
         logService.info(( localize(
-            16099,
+            16185,
             "Loading development extension at {0}",
             developedExtension.extensionLocation.fsPath
         )));

package/vscode/src/vs/workbench/services/themes/browser/cssExtensionPoint.js

@@ -22,14 +22,14 @@ const CSS_CACHE_STORAGE_KEY = "workbench.contrib.css.cache";
 const cssExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "css",
     jsonSchema: {
-        description: ( localize(16320, "Contributes CSS files to be loaded in the workbench.")),
+        description: ( localize(16406, "Contributes CSS files to be loaded in the workbench.")),
         type: "array",
         items: {
             type: "object",
             properties: {
                 path: {
                     description: ( localize(
-                        16321,
+                        16407,
                         "Path to the CSS file. The path is relative to the extension folder."
                     )),
                     type: "string"
@@ -121,7 +121,7 @@ let CSSExtensionPoint = class CSSExtensionPoint {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( localize(16322, "'contributes.css' must be an array.")));
+                    collector.error(( localize(16408, "'contributes.css' must be an array.")));
                     continue;
                 }
                 const extensionId = extension.description.identifier.value;
@@ -166,13 +166,13 @@ let CSSExtensionPoint = class CSSExtensionPoint {
         const cssLocations = [];
         for (const cssContribution of extensionValue) {
             if (!cssContribution.path || typeof cssContribution.path !== "string") {
-                collector.error(( localize(16323, "'contributes.css.path' must be a string.")));
+                collector.error(( localize(16409, "'contributes.css.path' must be a string.")));
                 continue;
             }
             const cssLocation = joinPath(extensionLocation, cssContribution.path);
             if (!isEqualOrParent(cssLocation, extensionLocation)) {
                 collector.warn(( localize(
-                    16324,
+                    16410,
                     "Expected 'contributes.css.path' ({0}) to be included inside extension's folder ({1}).",
                     cssLocation.path,
                     extensionLocation.path