@codingame/monaco-vscode-api 26.1.1 → 26.1.2

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/runSubagentTool.js

@@ -4,26 +4,37 @@ import { CancellationToken } from '../../../../../../base/common/cancellation.js
 import { Codicon } from '../../../../../../base/common/codicons.js';
 import { Event } from '../../../../../../base/common/event.js';
 import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
-import { generateUuid } from '../../../../../../base/common/uuid.js';
 import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
 import { ThemeIcon } from '../../../../../../base/common/themables.js';
+import { generateUuid } from '../../../../../../base/common/uuid.js';
 import { localize } from '../../../../../../nls.js';
 import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../../../platform/log/common/log.service.js';
-import { IChatAgentService } from '../../participants/chatAgents.service.js';
-import { IChatService } from '../../chatService/chatService.service.js';
 import { ChatRequestVariableSet } from '../../attachments/chatVariableEntries.js';
+import { IChatService } from '../../chatService/chatService.service.js';
 import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '../../constants.js';
 import { ILanguageModelsService } from '../../languageModels.service.js';
+import { IChatAgentService } from '../../participants/chatAgents.service.js';
+import { ComputeAutomaticInstructions } from '../../promptSyntax/computeAutomaticInstructions.js';
+import { IPromptsService } from '../../promptSyntax/service/promptsService.service.js';
 import { ToolDataSource, VSCodeToolReference, isToolSet } from '../languageModelToolsService.js';
 import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
-import { ComputeAutomaticInstructions } from '../../promptSyntax/computeAutomaticInstructions.js';
 import { ManageTodoListToolToolId } from './manageTodoListTool.js';
 import { createToolSimpleTextResult } from './toolHelpers.js';
-import { IPromptsService } from '../../promptSyntax/service/promptsService.service.js';
 
 var RunSubagentTool_1;
+function parseMultiplier(multiplier) {
+    if (!multiplier) {
+        return 1000;
+    }
+    const match = /^([\d.]+)\s*[xX]$/i.exec(multiplier.trim());
+    if (!match) {
+        return 1;
+    }
+    const value = parseFloat(match[1]);
+    return isNaN(value) ? 1 : value;
+}
 const BaseModelDescription = `Launch a new agent to handle complex, multi-step tasks autonomously. This tool is good at researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries, use this agent to perform the search for you.
 
 - Agents do not run async or in the background, you will wait for the agent\'s result.
@@ -59,6 +70,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         this.configurationService = configurationService;
         this.promptsService = promptsService;
         this.instantiationService = instantiationService;
+        this._resolvedModels = ( new Map());
         this.onDidUpdateToolData = Event.filter(
             this.configurationService.onDidChangeConfiguration,
             e => e.affectsConfiguration(ChatConfiguration.SubagentToolCustomAgents)
@@ -91,9 +103,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(6394, "Run Subagent")),
+            displayName: ( localize(6583, "Run Subagent")),
             userDescription: ( localize(
-                6395,
+                6584,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -125,27 +137,24 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             let modeTools = invocation.userSelectedTools;
             let modeInstructions;
             let subagent;
+            let resolvedModelName;
             const subAgentName = args.agentName;
             if (subAgentName) {
                 subagent = await this.getSubAgentByName(subAgentName);
                 if (subagent) {
-                    const modeModelQualifiedNames = subagent.model;
-                    if (modeModelQualifiedNames) {
-                        outer:
-                        for (const qualifiedName of modeModelQualifiedNames) {
-                            const lmByQualifiedName = this.languageModelsService.lookupLanguageModelByQualifiedName(qualifiedName);
-                            for (const fullId of this.languageModelsService.getLanguageModelIds()) {
-                                const lmById = this.languageModelsService.lookupLanguageModel(fullId);
-                                if (lmById && lmById?.id === lmByQualifiedName?.id) {
-                                    modeModelId = fullId;
-                                    break outer;
-                                }
-                            }
-                        }
+                    const cached = this._resolvedModels.get(invocation.callId);
+                    if (cached) {
+                        this._resolvedModels.delete(invocation.callId);
+                        modeModelId = cached.modeModelId;
+                        resolvedModelName = cached.resolvedModelName;
+                    } else {
+                        const resolved = this.resolveSubagentModel(subagent, invocation.modelId);
+                        modeModelId = resolved.modeModelId;
+                        resolvedModelName = resolved.resolvedModelName;
                     }
                     const modeCustomTools = subagent.tools;
                     if (modeCustomTools) {
-                        const enablementMap = this.languageModelToolsService.toToolAndToolSetEnablementMap(modeCustomTools, subagent.target, undefined);
+                        const enablementMap = this.languageModelToolsService.toToolAndToolSetEnablementMap(modeCustomTools, undefined);
                         modeTools = {};
                         for (const [tool, enabled] of enablementMap) {
                             if (!isToolSet(tool)) {
@@ -165,6 +174,15 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         `Requested agent '${subAgentName}' not found. Try again with the correct agent name, or omit the agentName to use the current agent.`
                     ));
                 }
+            } else {
+                const cached = this._resolvedModels.get(invocation.callId);
+                if (cached) {
+                    this._resolvedModels.delete(invocation.callId);
+                    resolvedModelName = cached.resolvedModelName;
+                } else {
+                    const resolvedModelMetadata = modeModelId ? this.languageModelsService.lookupLanguageModel(modeModelId) : undefined;
+                    resolvedModelName = resolvedModelMetadata?.name;
+                }
             }
             const markdownParts = [];
             const subAgentInvocationId = invocation.callId ?? `subagent-${generateUuid()}`;
@@ -187,6 +205,11 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         } else {
                             model.acceptResponseProgress(request, part);
                         }
+                    } else if (part.kind === "hook") {
+                        model.acceptResponseProgress(request, {
+                            ...part,
+                            subAgentInvocationId
+                        });
                     } else if (part.kind === "markdownContent") {
                         if (inEdit) {
                             model.acceptResponseProgress(request, {
@@ -207,6 +230,13 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             const variableSet = ( new ChatRequestVariableSet());
             const computer = this.instantiationService.createInstance(ComputeAutomaticInstructions, ChatModeKind.Agent, modeTools, undefined);
             await computer.collect(variableSet, token);
+            let collectedHooks;
+            try {
+                const info = await this.promptsService.getHooks(token);
+                collectedHooks = info?.hooks;
+            } catch (error) {
+                this.logService.warn("[ChatService] Failed to collect hooks:", error);
+            }
             const agentRequest = {
                 sessionResource: invocation.context.sessionResource,
                 requestId: invocation.callId ?? `subagent-${Date.now()}`,
@@ -220,7 +250,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 subAgentName: subAgentName,
                 userSelectedModelId: modeModelId,
                 userSelectedTools: modeTools,
-                modeInstructions
+                modeInstructions,
+                hooks: collectedHooks,
+                hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr.length > 0))
             };
             store.add(this.languageModelToolsService.onDidInvokeTool(e => {
                 if (e.subagentInvocationId === subAgentInvocationId) {
@@ -234,6 +266,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             const resultText = markdownParts.join("").replace(/^\n*```\n+```\n*/g, "").trim() || "Agent completed with no output";
             if (invocation.toolSpecificData?.kind === "subagent") {
                 invocation.toolSpecificData.result = resultText;
+                invocation.toolSpecificData.modelName = resolvedModelName;
             }
             return {
                 content: [{
@@ -243,7 +276,8 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 toolMetadata: {
                     subAgentInvocationId,
                     description: args.description,
-                    agentName: agentRequest.subAgentName
+                    agentName: agentRequest.subAgentName,
+                    modelName: resolvedModelName
                 }
             };
         } catch (error) {
@@ -258,20 +292,59 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         const agents = await this.promptsService.getCustomAgents(CancellationToken.None);
         return agents.find(agent => agent.name === name);
     }
+    resolveSubagentModel(subagent, mainModelId) {
+        let modeModelId = mainModelId;
+        if (subagent) {
+            const modeModelQualifiedNames = subagent.model;
+            if (modeModelQualifiedNames) {
+                outer:
+                for (const qualifiedName of modeModelQualifiedNames) {
+                    const lmByQualifiedName = this.languageModelsService.lookupLanguageModelByQualifiedName(qualifiedName);
+                    for (const fullId of this.languageModelsService.getLanguageModelIds()) {
+                        const lmById = this.languageModelsService.lookupLanguageModel(fullId);
+                        if (lmById && lmById?.id === lmByQualifiedName?.id) {
+                            modeModelId = fullId;
+                            break outer;
+                        }
+                    }
+                }
+            }
+            if (modeModelId && modeModelId !== mainModelId) {
+                const mainModelMetadata = mainModelId ? this.languageModelsService.lookupLanguageModel(mainModelId) : undefined;
+                const subagentModelMetadata = this.languageModelsService.lookupLanguageModel(modeModelId);
+                const mainMultiplier = parseMultiplier(mainModelMetadata?.multiplier);
+                const subagentMultiplier = parseMultiplier(subagentModelMetadata?.multiplier);
+                if (subagentMultiplier > mainMultiplier) {
+                    this.logService.warn(
+                        `[RunSubagentTool] Subagent '${subagent.name}' requested model '${subagentModelMetadata?.name}' (multiplier: ${subagentModelMetadata?.multiplier ?? "unknown"}) which has a larger multiplier than the main agent model '${mainModelMetadata?.name}' (multiplier: ${mainModelMetadata?.multiplier ?? "unknown"}). Falling back to the main agent model.`
+                    );
+                    modeModelId = mainModelId;
+                }
+            }
+        }
+        const resolvedModelMetadata = modeModelId ? this.languageModelsService.lookupLanguageModel(modeModelId) : undefined;
+        return {
+            modeModelId,
+            resolvedModelName: resolvedModelMetadata?.name
+        };
+    }
     async prepareToolInvocation(context, _token) {
         const args = context.parameters;
         const subagent = args.agentName ? await this.getSubAgentByName(args.agentName) : undefined;
+        const resolved = this.resolveSubagentModel(subagent, context.modelId);
+        this._resolvedModels.set(context.toolCallId, resolved);
         return {
             invocationMessage: args.description,
             toolSpecificData: {
                 kind: "subagent",
                 description: args.description,
                 agentName: subagent?.name,
-                prompt: args.prompt
+                prompt: args.prompt,
+                modelName: resolved.resolvedModelName
             }
         };
     }
 };
 RunSubagentTool = RunSubagentTool_1 = ( __decorate([( __param(0, IChatAgentService)), ( __param(1, IChatService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, ILanguageModelsService)), ( __param(4, ILogService)), ( __param(5, ILanguageModelToolsService)), ( __param(6, IConfigurationService)), ( __param(7, IPromptsService)), ( __param(8, IInstantiationService))], RunSubagentTool));
 
-export { RunSubagentTool };
+export { RunSubagentTool, parseMultiplier };

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.js

@@ -30,7 +30,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     },
     jsonSchema: {
         description: ( localize(
-            6396,
+            6585,
             "Contributes a tool that can be invoked by a language model in a chat session, or from a standalone command. Registered tools can be used by all extensions."
         )),
         type: "array",
@@ -56,7 +56,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
             properties: {
                 name: {
                     description: ( localize(
-                        6397,
+                        6586,
                         "A unique name for this tool. This name must be a globally unique identifier, and is also used as a name when presenting this tool to a language model."
                     )),
                     type: "string",
@@ -64,7 +64,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 toolReferenceName: {
                     markdownDescription: ( localize(
-                        6398,
+                        6587,
                         "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
                         "`canBeReferencedInPrompt`"
                     )),
@@ -73,32 +73,32 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 displayName: {
                     description: ( localize(
-                        6399,
+                        6588,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: "string"
                 },
                 userDescription: {
-                    description: ( localize(6400, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(6589, "A description of this tool that may be shown to the user.")),
                     type: "string"
                 },
                 modelDescription: {
                     description: ( localize(
-                        6401,
+                        6590,
                         "A description of this tool that may be used by a language model to select it."
                     )),
                     type: "string"
                 },
                 inputSchema: {
                     description: ( localize(
-                        6402,
+                        6591,
                         "A JSON schema for the input this tool accepts. The input must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."
                     )),
                     $ref: toolsParametersSchemaSchemaId
                 },
                 canBeReferencedInPrompt: {
                     markdownDescription: ( localize(
-                        6403,
+                        6592,
                         "If true, this tool shows up as an attachment that the user can add manually to their request. Chat participants will receive the tool in {0}.",
                         "`ChatRequest#toolReferences`"
                     )),
@@ -106,7 +106,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 icon: {
                     markdownDescription: ( localize(
-                        6404,
+                        6593,
                         "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like \"\\$(zap)\""
                     )),
                     anyOf: [{
@@ -115,11 +115,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(6405, "Icon path when a light theme is used")),
+                                description: ( localize(6594, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(6406, "Icon path when a dark theme is used")),
+                                description: ( localize(6595, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
@@ -127,14 +127,14 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        6407,
+                        6596,
                         "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
                     )),
                     type: "string"
                 },
                 tags: {
                     description: ( localize(
-                        6408,
+                        6597,
                         "A set of tags that roughly describe the tool's capabilities. A tool user may use these to filter the set of tools to just ones that are relevant for the task at hand, or they may want to pick a tag that can be used to identify just the tools contributed by this extension."
                     )),
                     type: "array",
@@ -152,7 +152,7 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
     deps: [languageModelToolsExtensionPoint],
     jsonSchema: {
         description: ( localize(
-            6409,
+            6598,
             "Contributes a set of language model tools that can be used together."
         )),
         type: "array",
@@ -170,23 +170,23 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
             properties: {
                 name: {
                     description: ( localize(
-                        6410,
+                        6599,
                         "A name for this tool set. Used as reference and should not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 description: {
-                    description: ( localize(6411, "A description of this tool set.")),
+                    description: ( localize(6600, "A description of this tool set.")),
                     type: "string"
                 },
                 icon: {
-                    markdownDescription: ( localize(6412, "An icon that represents this tool set, like `$(zap)`")),
+                    markdownDescription: ( localize(6601, "An icon that represents this tool set, like `$(zap)`")),
                     type: "string"
                 },
                 tools: {
                     markdownDescription: ( localize(
-                        6413,
+                        6602,
                         "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools by their `toolReferenceName`."
                     )),
                     type: "array",
@@ -406,7 +406,7 @@ class LanguageModelToolDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(6414, "Name")), ( localize(6415, "Display Name")), ( localize(6416, "Description"))];
+        const headers = [( localize(6603, "Name")), ( localize(6604, "Display Name")), ( localize(6605, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.displayName, t.userDescription ?? t.modelDescription];
         }));
@@ -421,7 +421,7 @@ class LanguageModelToolDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelTools",
-    label: ( localize(6417, "Language Model Tools")),
+    label: ( localize(6606, "Language Model Tools")),
     access: {
         canToggle: false
     },
@@ -446,7 +446,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(6418, "Name")), ( localize(6419, "Reference Name")), ( localize(6420, "Tools")), ( localize(6421, "Description"))];
+        const headers = [( localize(6607, "Name")), ( localize(6608, "Reference Name")), ( localize(6609, "Tools")), ( localize(6610, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.referenceName ? ( new MarkdownString(`\`#${t.referenceName}\``)) : "none", t.tools.join(", "), t.description];
         }));
@@ -461,7 +461,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelToolSets",
-    label: ( localize(6422, "Language Model Tool Sets")),
+    label: ( localize(6611, "Language Model Tool Sets")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsService.d.ts

@@ -102,6 +102,14 @@ export declare namespace ToolDataSource {
         readonly label: string;
     };
 }
+/**
+ * Pre-tool-use hook result passed from the extension when the hook was executed externally.
+ */
+export interface IExternalPreToolUseHookResult {
+    permissionDecision?: "allow" | "deny" | "ask";
+    permissionDecisionReason?: string;
+    updatedInput?: Record<string, any>;
+}
 export interface IToolInvocation {
     callId: string;
     toolId: string;
@@ -121,6 +129,8 @@ export interface IToolInvocation {
     toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData;
     modelId?: string;
     userSelectedTools?: UserSelectedTools;
+    /** Pre-tool-use hook result passed from the extension, if the hook was already executed externally. */
+    preToolUseResult?: IExternalPreToolUseHookResult;
 }
 export interface IToolInvocationContext {
     /** @deprecated Use {@link sessionResource} instead */
@@ -130,11 +140,15 @@ export interface IToolInvocationContext {
 export declare function isToolInvocationContext(obj: any): obj is IToolInvocationContext;
 export interface IToolInvocationPreparationContext {
     parameters: any;
+    toolCallId: string;
     chatRequestId?: string;
     /** @deprecated Use {@link chatSessionResource} instead */
     chatSessionId?: string;
     chatSessionResource: URI | undefined;
     chatInteractionId?: string;
+    modelId?: string;
+    /** If set, tells the tool that it should include confirmmation messages. */
+    forceConfirmationReason?: string;
 }
 export type ToolInputOutputBase = {
     /** Mimetype of the value, optional */

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsService.js

@@ -54,7 +54,7 @@ var ToolDataSource;
         if (source.type === "internal") {
             return {
                 ordinal: 1,
-                label: ( localize(6423, "Built-In"))
+                label: ( localize(6612, "Built-In"))
             };
         } else if (source.type === "mcp") {
             return {
@@ -64,7 +64,7 @@ var ToolDataSource;
         } else if (source.type === "user") {
             return {
                 ordinal: 0,
-                label: ( localize(6424, "User Defined"))
+                label: ( localize(6613, "User Defined"))
             };
         } else {
             return {
@@ -93,7 +93,7 @@ function toolContentToA11yString(part) {
             return p.value;
         case "data":
             return localize(
-                6425,
+                6614,
                 "{0} of {1} binary data",
                 ByteSize.formatSize(p.value.data.byteLength),
                 p.value.mimeType || "unknown"

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service.d.ts

@@ -88,11 +88,10 @@ export interface ILanguageModelToolsService {
     /**
     * Gets the enablement maps based on the given set of references.
     * @param fullReferenceNames The full reference names of the tools and tool sets to enable.
-    * @param target Optional target to filter tools by.
     * @param model Optional language model metadata to filter tools by.
     * If undefined is passed, all tools will be returned, even if normally disabled.
     */
-    toToolAndToolSetEnablementMap(fullReferenceNames: readonly string[], target: string | undefined, model: ILanguageModelChatMetadata | undefined): IToolAndToolSetEnablementMap;
+    toToolAndToolSetEnablementMap(fullReferenceNames: readonly string[], model: ILanguageModelChatMetadata | undefined): IToolAndToolSetEnablementMap;
     toFullReferenceNames(map: IToolAndToolSetEnablementMap): string[];
     toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[];
 }

package/vscode/src/vs/workbench/contrib/chat/common/widget/input/modelPickerWidget.js

@@ -2,7 +2,7 @@
 import { localize } from '../../../../../../nls.js';
 
 const DEFAULT_MODEL_PICKER_CATEGORY = {
-    label: ( localize(6441, "Other Models")),
+    label: ( localize(6630, "Other Models")),
     order: Number.MAX_SAFE_INTEGER
 };
 

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -17,13 +17,13 @@ const createCodeActionsAutoSave = description => {
         type: "string",
         enum: ["always", "explicit", "never", true, false],
         enumDescriptions: [( localize(
-            6442,
+            6631,
             "Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes."
-        )), ( localize(6443, "Triggers Code Actions only when explicitly saved")), ( localize(6444, "Never triggers Code Actions on save")), ( localize(
-            6445,
+        )), ( localize(6632, "Triggers Code Actions only when explicitly saved")), ( localize(6633, "Never triggers Code Actions on save")), ( localize(
+            6634,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"explicit\"."
         )), ( localize(
-            6446,
+            6635,
             "Never triggers Code Actions on save. This value will be deprecated in favor of \"never\"."
         ))],
         default: "explicit",
@@ -34,11 +34,11 @@ const createNotebookCodeActionsAutoSave = description => {
     return {
         type: ["string", "boolean"],
         enum: ["explicit", "never", true, false],
-        enumDescriptions: [( localize(6447, "Triggers Code Actions only when explicitly saved.")), ( localize(6448, "Never triggers Code Actions on save.")), ( localize(
-            6449,
+        enumDescriptions: [( localize(6636, "Triggers Code Actions only when explicitly saved.")), ( localize(6637, "Never triggers Code Actions on save.")), ( localize(
+            6638,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"explicit\"."
         )), ( localize(
-            6450,
+            6639,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"never\"."
         ))],
         default: "explicit",
@@ -58,7 +58,7 @@ const codeActionsOnSaveSchema = {
         }
     }],
     markdownDescription: ( localize(
-        6451,
+        6640,
         "Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `\"source.organizeImports\": \"explicit\" `",
         "`#files.autoSave#`"
     )),
@@ -89,7 +89,7 @@ const notebookCodeActionsOnSaveSchema = {
         }
     }],
     markdownDescription: ( localize(
-        6452,
+        6641,
         "Run a series of Code Actions for a notebook on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `\"notebook.source.organizeImports\": \"explicit\"`",
         "`#files.autoSave#`"
     )),
@@ -144,12 +144,12 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         for (const codeActionKind of allProvidedKinds) {
             if (CodeActionKind.Source.contains(codeActionKind) && !properties[codeActionKind.value]) {
                 properties[codeActionKind.value] = createCodeActionsAutoSave(( localize(
-                    6453,
+                    6642,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    6453,
+                    6642,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.js

@@ -32,12 +32,12 @@ import { isWindows } from '../../../../../base/common/platform.js';
 var EditorDictation_1;
 registerCss(editorDictation);
 const EDITOR_DICTATION_IN_PROGRESS = ( new RawContextKey("editorDictation.inProgress", false));
-const VOICE_CATEGORY = ( localize2(6459, "Voice"));
+const VOICE_CATEGORY = ( localize2(6648, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: "workbench.action.editorDictation.start",
-            title: ( localize2(6460, "Start Dictation in Editor")),
+            title: ( localize2(6649, "Start Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: ( ContextKeyExpr.and(HasSpeechProvider, ( SpeechToTextInProgress.toNegated()), (
             EditorContextKeys.readOnly.toNegated()))),
@@ -74,7 +74,7 @@ class EditorDictationStopAction extends EditorAction2 {
     constructor() {
         super({
             id: EditorDictationStopAction.ID,
-            title: ( localize2(6461, "Stop Dictation in Editor")),
+            title: ( localize2(6650, "Stop Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: EDITOR_DICTATION_IN_PROGRESS,
             f1: true,
@@ -99,7 +99,7 @@ class DictationWidget extends Disposable {
         const stopActionKeybinding = keybindingService.lookupKeybinding(EditorDictationStopAction.ID)?.getLabel();
         actionBar.push(toAction({
             id: EditorDictationStopAction.ID,
-            label: stopActionKeybinding ? ( localize(6462, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(6463, "Stop Dictation")),
+            label: stopActionKeybinding ? ( localize(6651, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(6652, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), {

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorAccessibilityHelp.js

@@ -31,12 +31,12 @@ class DiffEditorAccessibilityHelp {
             return;
         }
         const switchSides = ( localize(
-            6464,
+            6653,
             "Run the command Diff Editor: Switch Side{0} to toggle between the original and modified editors.",
             "<keybinding:diffEditor.switchSide>"
         ));
         const diffEditorActiveAnnouncement = ( localize(
-            6465,
+            6654,
             "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."
         ));
         const keys = [
@@ -44,13 +44,13 @@ class DiffEditorAccessibilityHelp {
             "accessibility.signals.diffLineInserted",
             "accessibility.signals.diffLineModified"
         ];
-        const content = [( localize(6466, "You are in a diff editor.")), ( localize(
-            6467,
+        const content = [( localize(6655, "You are in a diff editor.")), ( localize(
+            6656,
             "View the next{0} or previous{1} diff in diff review mode, which is optimized for screen readers.",
             "<keybinding:" + AccessibleDiffViewerNext.id + ">",
             "<keybinding:" + AccessibleDiffViewerPrev.id + ">"
         )), switchSides, diffEditorActiveAnnouncement, ( localize(
-            6468,
+            6657,
             "To control which accessibility signals should be played, the following settings can be configured: {0}.",
             keys.join(", ")
         ))];