@codingame/monaco-vscode-api 26.2.1 → 27.0.0

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

@@ -11,11 +11,6 @@ import { IChatAgentService } from "../../participants/chatAgents.service.js";
 import { IPromptsService } from "../../promptSyntax/service/promptsService.service.js";
 import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "../languageModelToolsService.js";
 import { ILanguageModelToolsService } from "../languageModelToolsService.service.js";
-/**
- * Parses a multiplier string like "2X" or "0.5X" to a number.
- * Returns 1 if parsing fails.
- */
-export declare function parseMultiplier(multiplier: string | undefined): number;
 export interface IRunSubagentToolInputParams {
     prompt: string;
     description: string;

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

@@ -24,17 +24,6 @@ import { ManageTodoListToolToolId } from './manageTodoListTool.js';
 import { createToolSimpleTextResult } from './toolHelpers.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.
@@ -103,9 +92,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(6583, "Run Subagent")),
+            displayName: ( localize(7189, "Run Subagent")),
             userDescription: ( localize(
-                6584,
+                7190,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -228,11 +217,17 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 modeTools["copilot_askQuestions"] = false;
             }
             const variableSet = ( new ChatRequestVariableSet());
-            const computer = this.instantiationService.createInstance(ComputeAutomaticInstructions, ChatModeKind.Agent, modeTools, undefined);
+            const computer = this.instantiationService.createInstance(
+                ComputeAutomaticInstructions,
+                ChatModeKind.Agent,
+                modeTools,
+                undefined,
+                invocation.context.sessionResource
+            );
             await computer.collect(variableSet, token);
             let collectedHooks;
             try {
-                const info = await this.promptsService.getHooks(token);
+                const info = await this.promptsService.getHooks(token, invocation.context.sessionResource);
                 collectedHooks = info?.hooks;
             } catch (error) {
                 this.logService.warn("[ChatService] Failed to collect hooks:", error);
@@ -251,6 +246,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 userSelectedModelId: modeModelId,
                 userSelectedTools: modeTools,
                 modeInstructions,
+                parentRequestId: invocation.chatRequestId,
                 hooks: collectedHooks,
                 hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr.length > 0))
             };
@@ -300,23 +296,20 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 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 (lmByQualifiedName?.identifier) {
+                        modeModelId = lmByQualifiedName.identifier;
+                        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) {
+                const mainMultiplier = mainModelMetadata?.multiplierNumeric;
+                const subagentMultiplier = subagentModelMetadata?.multiplierNumeric;
+                if (mainMultiplier !== undefined && subagentMultiplier !== undefined && 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.`
+                        `[RunSubagentTool] Subagent '${subagent.name}' requested model '${subagentModelMetadata?.name}' (multiplier: ${subagentMultiplier}) which has a larger multiplier than the main agent model '${mainModelMetadata?.name}' (multiplier: ${mainMultiplier}). Falling back to the main agent model.`
                     );
                     modeModelId = mainModelId;
                 }
@@ -347,4 +340,4 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
 };
 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, parseMultiplier };
+export { RunSubagentTool };

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

@@ -3,7 +3,8 @@ import { __decorate, __param } from '../../../../../../../../../external/tslib/t
 import { Disposable } from '../../../../../../base/common/lifecycle.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
-import { ConfirmationTool, ConfirmationToolData } from './confirmationTool.js';
+import { AskQuestionsTool, AskQuestionsToolData } from './askQuestionsTool.js';
+import { ConfirmationTool, ConfirmationToolData, ConfirmationToolWithOptionsData } from './confirmationTool.js';
 import { EditTool, EditToolData } from './editFileTool.js';
 import { createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
 import { RunSubagentTool } from './runSubagentTool.js';
@@ -16,11 +17,17 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         super();
         const editTool = instantiationService.createInstance(EditTool);
         this._register(toolsService.registerTool(EditToolData, editTool));
+        const askQuestionsTool = this._register(instantiationService.createInstance(AskQuestionsTool));
+        this._register(toolsService.registerTool(AskQuestionsToolData, askQuestionsTool));
+        this._register(toolsService.vscodeToolSet.addTool(AskQuestionsToolData));
         const todoToolData = createManageTodoListToolData();
         const manageTodoListTool = this._register(instantiationService.createInstance(ManageTodoListTool));
         this._register(toolsService.registerTool(todoToolData, manageTodoListTool));
         const confirmationTool = instantiationService.createInstance(ConfirmationTool);
         this._register(toolsService.registerTool(ConfirmationToolData, confirmationTool));
+        this._register(
+            toolsService.registerTool(ConfirmationToolWithOptionsData, confirmationTool)
+        );
         const runSubagentTool = this._register(instantiationService.createInstance(RunSubagentTool));
         let runSubagentRegistration;
         let toolSetRegistration;

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

@@ -7,4 +7,5 @@ export interface IChatTodoListService {
     readonly onDidUpdateTodos: Event<URI>;
     getTodos(sessionResource: URI): IChatTodo[];
     setTodos(sessionResource: URI, todos: IChatTodo[]): void;
+    migrateTodos(oldSessionResource: URI, newSessionResource: URI): void;
 }

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

@@ -9,6 +9,8 @@ export interface ILanguageModelToolConfirmationActions {
     detail?: string;
     /** Show a separator before this action */
     divider?: boolean;
+    /** The scope of this action, if applicable */
+    scope?: "session" | "workspace" | "profile";
     /** Selects this action. Resolves true if the action should be confirmed after selection */
     select(): Promise<boolean>;
 }

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

@@ -30,7 +30,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     },
     jsonSchema: {
         description: ( localize(
-            6585,
+            7191,
             "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(
-                        6586,
+                        7192,
                         "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(
-                        6587,
+                        7193,
                         "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(
-                        6588,
+                        7194,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: "string"
                 },
                 userDescription: {
-                    description: ( localize(6589, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(7195, "A description of this tool that may be shown to the user.")),
                     type: "string"
                 },
                 modelDescription: {
                     description: ( localize(
-                        6590,
+                        7196,
                         "A description of this tool that may be used by a language model to select it."
                     )),
                     type: "string"
                 },
                 inputSchema: {
                     description: ( localize(
-                        6591,
+                        7197,
                         "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(
-                        6592,
+                        7198,
                         "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(
-                        6593,
+                        7199,
                         "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(6594, "Icon path when a light theme is used")),
+                                description: ( localize(7200, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(6595, "Icon path when a dark theme is used")),
+                                description: ( localize(7201, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
@@ -127,14 +127,14 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        6596,
+                        7202,
                         "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(
-                        6597,
+                        7203,
                         "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(
-            6598,
+            7204,
             "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(
-                        6599,
+                        7205,
                         "A name for this tool set. Used as reference and should not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 description: {
-                    description: ( localize(6600, "A description of this tool set.")),
+                    description: ( localize(7206, "A description of this tool set.")),
                     type: "string"
                 },
                 icon: {
-                    markdownDescription: ( localize(6601, "An icon that represents this tool set, like `$(zap)`")),
+                    markdownDescription: ( localize(7207, "An icon that represents this tool set, like `$(zap)`")),
                     type: "string"
                 },
                 tools: {
                     markdownDescription: ( localize(
-                        6602,
+                        7208,
                         "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",
@@ -328,6 +328,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                     }
                     const tools = [];
                     const toolSets = [];
+                    const missingToolNames = [];
                     for (const toolName of toolSet.tools) {
                         const toolObj = languageModelToolsService.getToolByName(toolName);
                         if (toolObj) {
@@ -339,9 +340,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                             toolSets.push(toolSetObj);
                             continue;
                         }
-                        extension.collector.warn(
-                            `Tool set '${toolSet.name}' CANNOT find tool or tool set by name: ${toolName}`
-                        );
+                        missingToolNames.push(toolName);
                     }
                     if (toolSets.length === 0 && tools.length === 0) {
                         extension.collector.error(
@@ -375,6 +374,27 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                         tools.forEach(tool => store.add(obj.addTool(tool, tx)));
                         toolSets.forEach(toolSet => store.add(obj.addToolSet(toolSet, tx)));
                     });
+                    if (missingToolNames.length > 0) {
+                        const pending = ( new Set(missingToolNames));
+                        const listener = store.add(languageModelToolsService.onDidChangeTools(() => {
+                            for (const toolName of pending) {
+                                const toolObj = languageModelToolsService.getToolByName(toolName);
+                                if (toolObj) {
+                                    store.add(obj.addTool(toolObj));
+                                    pending.delete(toolName);
+                                } else {
+                                    const toolSetObj = languageModelToolsService.getToolSetByName(toolName);
+                                    if (toolSetObj) {
+                                        store.add(obj.addToolSet(toolSetObj));
+                                        pending.delete(toolName);
+                                    }
+                                }
+                            }
+                            if (pending.size === 0) {
+                                store.delete(listener);
+                            }
+                        }));
+                    }
                     this._registrationDisposables.set(toToolSetKey(extension.description.identifier, toolSet.name), store);
                 }
             }
@@ -406,7 +426,7 @@ class LanguageModelToolDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(6603, "Name")), ( localize(6604, "Display Name")), ( localize(6605, "Description"))];
+        const headers = [( localize(7209, "Name")), ( localize(7210, "Display Name")), ( localize(7211, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.displayName, t.userDescription ?? t.modelDescription];
         }));
@@ -421,7 +441,7 @@ class LanguageModelToolDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelTools",
-    label: ( localize(6606, "Language Model Tools")),
+    label: ( localize(7212, "Language Model Tools")),
     access: {
         canToggle: false
     },
@@ -446,7 +466,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(6607, "Name")), ( localize(6608, "Reference Name")), ( localize(6609, "Tools")), ( localize(6610, "Description"))];
+        const headers = [( localize(7213, "Name")), ( localize(7214, "Reference Name")), ( localize(7215, "Tools")), ( localize(7216, "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 +481,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelToolSets",
-    label: ( localize(6611, "Language Model Tool Sets")),
+    label: ( localize(7217, "Language Model Tool Sets")),
     access: {
         canToggle: false
     },

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

@@ -12,7 +12,7 @@ import { ContextKeyExpression } from "../../../../../platform/contextkey/common/
 import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
 import { ExtensionIdentifier } from "../../../../../platform/extensions/common/extensions.js";
 import { IProgress } from "../../../../../platform/progress/common/progress.js";
-import { IChatExtensionsContent, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, type IChatTerminalToolInvocationData } from "../chatService/chatService.js";
+import { IChatExtensionsContent, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, type IChatTerminalToolInvocationData } from "../chatService/chatService.js";
 import { ILanguageModelChatMetadata, LanguageModelPartAudience } from "../languageModels.js";
 import { UserSelectedTools } from "../participants/chatAgents.js";
 /**
@@ -126,15 +126,15 @@ export interface IToolInvocation {
      * Lets us add some nicer UI to toolcalls that came from a sub-agent, but in the long run, this should probably just be rendered in a similar way to thinking text + tool call groups
      */
     subAgentInvocationId?: string;
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData;
     modelId?: string;
     userSelectedTools?: UserSelectedTools;
+    /** The label of the custom button selected by the user during confirmation, if custom buttons were used. */
+    selectedCustomButton?: string;
     /** 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 */
-    readonly sessionId: string;
     readonly sessionResource: URI;
 }
 export declare function isToolInvocationContext(obj: any): obj is IToolInvocationContext;
@@ -142,12 +142,10 @@ 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. */
+    /** If set, tells the tool that it should include confirmation messages. */
     forceConfirmationReason?: string;
 }
 export type ToolInputOutputBase = {
@@ -190,7 +188,7 @@ export interface IToolResult {
     content: (IToolResultPromptTsxPart | IToolResultTextPart | IToolResultDataPart)[];
     toolResultMessage?: string | IMarkdownString;
     toolResultDetails?: Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetails;
-    toolResultError?: string;
+    toolResultError?: string | boolean;
     toolMetadata?: unknown;
     /** Whether to ask the user to confirm these tool results. Overrides {@link IToolConfirmationMessages.confirmResults}. */
     confirmResults?: boolean;
@@ -229,6 +227,8 @@ export interface IToolConfirmationMessages {
     confirmResults?: boolean;
     /** If title is not set (no confirmation needed), this reason will be shown to explain why confirmation was not needed */
     confirmationNotNeededReason?: string | IMarkdownString;
+    /** Custom button labels to display instead of the default Allow/Skip buttons. */
+    customButtons?: string[];
 }
 export interface IToolConfirmationAction {
     label: string;
@@ -245,8 +245,6 @@ export interface IToolInvocationStreamContext {
     toolCallId: string;
     rawInput: unknown;
     chatRequestId?: string;
-    /** @deprecated Use {@link chatSessionResource} instead */
-    chatSessionId?: string;
     chatSessionResource?: URI;
     chatInteractionId?: string;
 }
@@ -259,7 +257,7 @@ export interface IPreparedToolInvocation {
     originMessage?: string | IMarkdownString;
     confirmationMessages?: IToolConfirmationMessages;
     presentation?: ToolInvocationPresentation;
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData;
 }
 export interface IToolImpl {
     invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;

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(6612, "Built-In"))
+                label: ( localize(7218, "Built-In"))
             };
         } else if (source.type === "mcp") {
             return {
@@ -64,7 +64,7 @@ var ToolDataSource;
         } else if (source.type === "user") {
             return {
                 ordinal: 0,
-                label: ( localize(6613, "User Defined"))
+                label: ( localize(7219, "User Defined"))
             };
         } else {
             return {
@@ -76,7 +76,7 @@ var ToolDataSource;
     ToolDataSource.classify = classify;
 })(ToolDataSource || (ToolDataSource = {}));
 function isToolInvocationContext(obj) {
-    return typeof obj === "object" && typeof obj.sessionId === "string" && URI.isUri(obj.sessionResource);
+    return obj !== null && typeof obj === "object" && URI.isUri(obj.sessionResource);
 }
 function isToolResultInputOutputDetails(obj) {
     return typeof obj === "object" && typeof obj?.input === "string" && (typeof obj?.output === "string" || Array.isArray(obj?.output));
@@ -93,7 +93,7 @@ function toolContentToA11yString(part) {
             return p.value;
         case "data":
             return localize(
-                6614,
+                7220,
                 "{0} of {1} binary data",
                 ByteSize.formatSize(p.value.data.byteLength),
                 p.value.mimeType || "unknown"

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

@@ -2,6 +2,9 @@
  * This is a subset of the types export from jsonTypes.d.ts in @vscode/prompt-tsx.
  * It's just the types needed to stringify prompt-tsx tool results.
  * It should be kept in sync with the types in that file.
+ *
+ * Note: do NOT use `declare` with const enums, esbuild doesn't inline them.
+ * See https://github.com/evanw/esbuild/issues/4394
  */
 export declare enum PromptNodeType {
     Piece = 1,

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

@@ -1,5 +1,16 @@
 
 
+var PromptNodeType;
+(function (PromptNodeType) {
+    PromptNodeType[PromptNodeType["Piece"] = 1] = "Piece";
+    PromptNodeType[PromptNodeType["Text"] = 2] = "Text";
+})(PromptNodeType || (PromptNodeType = {}));
+var PieceCtorKind;
+(function (PieceCtorKind) {
+    PieceCtorKind[PieceCtorKind["BaseChatMessage"] = 1] = "BaseChatMessage";
+    PieceCtorKind[PieceCtorKind["Other"] = 2] = "Other";
+    PieceCtorKind[PieceCtorKind["ImageChatMessage"] = 3] = "ImageChatMessage";
+})(PieceCtorKind || (PieceCtorKind = {}));
 function stringifyPromptElementJSON(element) {
     const strs = [];
     stringifyPromptNodeJSON(element.node, strs);
@@ -24,4 +35,4 @@ function stringifyPromptNodeJSON(node, strs) {
     }
 }
 
-export { stringifyPromptElementJSON };
+export { PieceCtorKind, PromptNodeType, stringifyPromptElementJSON };

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(6630, "Other Models")),
+    label: ( localize(7237, "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(
-            6631,
+            7238,
             "Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes."
-        )), ( localize(6632, "Triggers Code Actions only when explicitly saved")), ( localize(6633, "Never triggers Code Actions on save")), ( localize(
-            6634,
+        )), ( localize(7239, "Triggers Code Actions only when explicitly saved")), ( localize(7240, "Never triggers Code Actions on save")), ( localize(
+            7241,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"explicit\"."
         )), ( localize(
-            6635,
+            7242,
             "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(6636, "Triggers Code Actions only when explicitly saved.")), ( localize(6637, "Never triggers Code Actions on save.")), ( localize(
-            6638,
+        enumDescriptions: [( localize(7243, "Triggers Code Actions only when explicitly saved.")), ( localize(7244, "Never triggers Code Actions on save.")), ( localize(
+            7245,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"explicit\"."
         )), ( localize(
-            6639,
+            7246,
             "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(
-        6640,
+        7247,
         "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(
-        6641,
+        7248,
         "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(
-                    6642,
+                    7249,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    6642,
+                    7249,
                     "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(6648, "Voice"));
+const VOICE_CATEGORY = ( localize2(7255, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: "workbench.action.editorDictation.start",
-            title: ( localize2(6649, "Start Dictation in Editor")),
+            title: ( localize2(7256, "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(6650, "Stop Dictation in Editor")),
+            title: ( localize2(7257, "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(6651, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(6652, "Stop Dictation")),
+            label: stopActionKeybinding ? ( localize(7258, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(7259, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), {