@codingame/monaco-vscode-api 26.2.2 → 28.0.0

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

@@ -48,8 +48,8 @@ function createManageTodoListToolData() {
         legacyToolReferenceFullNames: ["todos"],
         canBeReferencedInPrompt: true,
         icon: ThemeIcon.fromId(Codicon.checklist.id),
-        displayName: ( localize(6572, "Manage and track todo items for task planning")),
-        userDescription: ( localize(6573, "Manage and track todo items for task planning")),
+        displayName: ( localize(7355, "Manage and track todo items for task planning")),
+        userDescription: ( localize(7356, "Manage and track todo items for task planning")),
         modelDescription: "Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Mark ONE todo as in-progress before starting work\n3. Complete the work for that specific todo\n4. Mark that todo as completed IMMEDIATELY\n5. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.",
         source: ToolDataSource.Internal,
         inputSchema: inputSchema
@@ -107,7 +107,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
         const currentTodoItems = this.chatTodoListService.getTodos(chatSessionResource);
         let message;
         if (args.operation === "read") {
-            message = ( localize(6574, "Read todo list"));
+            message = ( localize(7357, "Read todo list"));
         } else if (args.todoList) {
             message = this.generatePastTenseMessage(currentTodoItems, args.todoList);
         }
@@ -118,7 +118,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             status: todo.status
         })));
         return {
-            pastTenseMessage: ( new MarkdownString(message ?? ( localize(6575, "Updated todo list")))),
+            pastTenseMessage: ( new MarkdownString(message ?? ( localize(7358, "Updated todo list")))),
             toolSpecificData: {
                 kind: "todoList",
                 todoList: todoList
@@ -127,7 +127,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
     }
     generatePastTenseMessage(currentTodos, newTodos) {
         if (currentTodos.length === 0) {
-            return newTodos.length === 1 ? ( localize(6576, "Created 1 todo")) : ( localize(6577, "Created {0} todos", newTodos.length));
+            return newTodos.length === 1 ? ( localize(7359, "Created 1 todo")) : ( localize(7360, "Created {0} todos", newTodos.length));
         }
         const currentTodoMap = ( new Map(( currentTodos.map(todo => [todo.id, todo]))));
         const startedTodos = newTodos.filter(newTodo => {
@@ -139,7 +139,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             const totalTodos = newTodos.length;
             const currentPosition = newTodos.findIndex(todo => todo.id === startedTodo.id) + 1;
             return localize(
-                6578,
+                7361,
                 "Starting: *{0}* ({1}/{2})",
                 startedTodo.title,
                 currentPosition,
@@ -155,7 +155,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             const totalTodos = newTodos.length;
             const currentPosition = newTodos.findIndex(todo => todo.id === completedTodo.id) + 1;
             return localize(
-                6579,
+                7362,
                 "Completed: *{0}* ({1}/{2})",
                 completedTodo.title,
                 currentPosition,
@@ -164,9 +164,9 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
         }
         const addedTodos = newTodos.filter(newTodo => !( currentTodoMap.has(newTodo.id)));
         if (addedTodos.length > 0) {
-            return addedTodos.length === 1 ? ( localize(6580, "Added 1 todo")) : ( localize(6581, "Added {0} todos", addedTodos.length));
+            return addedTodos.length === 1 ? ( localize(7363, "Added 1 todo")) : ( localize(7364, "Added {0} todos", addedTodos.length));
         }
-        return localize(6582, "Updated todo list");
+        return localize(7365, "Updated todo list");
     }
     handleRead(todoItems, sessionResource) {
         if (todoItems.length === 0) {

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

@@ -0,0 +1,11 @@
+import { CancellationToken } from "../../../../../../base/common/cancellation.js";
+import { IChatDebugService } from "../../chatDebugService.service.js";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "../languageModelToolsService.js";
+export declare const ResolveDebugEventDetailsToolId = "vscode_resolveDebugEventDetails_internal";
+export declare const ResolveDebugEventDetailsToolData: IToolData;
+export declare class ResolveDebugEventDetailsTool implements IToolImpl {
+    private readonly chatDebugService;
+    constructor(chatDebugService: IChatDebugService);
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,205 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../../../../nls.js';
+import { ChatContextKeys } from '../../actions/chatContextKeys.js';
+import { IChatDebugService } from '../../chatDebugService.service.js';
+import { ToolDataSource } from '../languageModelToolsService.js';
+
+const ResolveDebugEventDetailsToolId = "vscode_resolveDebugEventDetails_internal";
+const ResolveDebugEventDetailsToolData = {
+    id: ResolveDebugEventDetailsToolId,
+    toolReferenceName: "resolveDebugEventDetails",
+    displayName: ( localize(7366, "Resolve Debug Event Details")),
+    when: ChatContextKeys.chatSessionHasAttachedDebugData,
+    canBeReferencedInPrompt: false,
+    modelDescription: "Resolves the full details for a specific chat debug event by its event ID. Use this tool to get detailed information about a debug event such as tool call input/output, model turn details, user message sections, or file lists. The event ID can be found in the debug event log summary provided in the conversation context.",
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: "object",
+        properties: {
+            eventId: {
+                type: "string",
+                description: "The ID of the debug event to resolve details for."
+            }
+        },
+        required: ["eventId"]
+    }
+};
+function formatResolvedContent(content) {
+    switch (content.kind) {
+    case "text":
+        return content.value;
+    case "fileList":
+        {
+            const lines = [`File list (${content.discoveryType}):`];
+            if (content.sourceFolders) {
+                for (const folder of content.sourceFolders) {
+                    lines.push(`  Source folder: ${( folder.uri.toString())} (${folder.storage}, ${folder.fileCount} files${folder.exists ? "" : ", missing"})`);
+                }
+            }
+            for (const file of content.files) {
+                const status = file.status === "loaded" ? "loaded" : `skipped${file.skipReason ? `: ${file.skipReason}` : ""}`;
+                lines.push(`  ${( file.uri.toString())} [${status}]`);
+            }
+            return lines.join("\n");
+        }
+    case "message":
+        {
+            const lines = [
+                `${content.type === "user" ? "User" : "Agent"} message: ${content.message}`
+            ];
+            for (const section of content.sections) {
+                lines.push(`--- ${section.name} ---`);
+                lines.push(section.content);
+            }
+            return lines.join("\n");
+        }
+    case "toolCall":
+        {
+            const lines = [`Tool call: ${content.toolName}`];
+            if (content.result) {
+                lines.push(`Result: ${content.result}`);
+            }
+            if (content.durationInMillis !== undefined) {
+                lines.push(`Duration: ${content.durationInMillis}ms`);
+            }
+            if (content.input) {
+                lines.push(`Input:\n${content.input}`);
+            }
+            if (content.output) {
+                lines.push(`Output:\n${content.output}`);
+            }
+            return lines.join("\n");
+        }
+    case "modelTurn":
+        {
+            const lines = [`Model turn: ${content.requestName}`];
+            if (content.model) {
+                lines.push(`Model: ${content.model}`);
+            }
+            if (content.status) {
+                lines.push(`Status: ${content.status}`);
+            }
+            if (content.durationInMillis !== undefined) {
+                lines.push(`Duration: ${content.durationInMillis}ms`);
+            }
+            if (content.inputTokens !== undefined || content.outputTokens !== undefined) {
+                lines.push(
+                    `Tokens: input=${content.inputTokens ?? "?"}, output=${content.outputTokens ?? "?"}, cached=${content.cachedTokens ?? "?"}, total=${content.totalTokens ?? "?"}`
+                );
+            }
+            if (content.errorMessage) {
+                lines.push(`Error: ${content.errorMessage}`);
+            }
+            if (content.sections) {
+                for (const section of content.sections) {
+                    lines.push(`--- ${section.name} ---`);
+                    lines.push(section.content);
+                }
+            }
+            return lines.join("\n");
+        }
+    default:
+        {
+            const _ = content;
+            return JSON.stringify(_);
+        }
+    }
+}
+function truncate(text, maxLength = 30) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    const lastSpace = text.lastIndexOf(" ", maxLength);
+    const cutoff = lastSpace > maxLength / 2 ? lastSpace : maxLength;
+    return text.substring(0, cutoff) + "…";
+}
+function getEventLabel(event) {
+    switch (event.kind) {
+    case "generic":
+        return event.name;
+    case "toolCall":
+        return event.toolName;
+    case "modelTurn":
+        return event.requestName ?? ( localize(7367, "Model Turn"));
+    case "userMessage":
+        return localize(7368, "User Message: {0}", truncate(event.message));
+    case "agentResponse":
+        return localize(7369, "Agent Response: {0}", truncate(event.message));
+    case "subagentInvocation":
+        return event.agentName;
+    }
+}
+let ResolveDebugEventDetailsTool = class ResolveDebugEventDetailsTool {
+    constructor(chatDebugService) {
+        this.chatDebugService = chatDebugService;
+    }
+    async prepareToolInvocation(context, _token) {
+        const eventId = context.parameters?.eventId;
+        let eventLabel;
+        if (typeof eventId === "string" && context.chatSessionResource) {
+            const events = this.chatDebugService.getEvents(context.chatSessionResource);
+            const event = events.find(e => e.id === eventId);
+            if (event) {
+                eventLabel = getEventLabel(event);
+            }
+        }
+        if (eventLabel) {
+            return {
+                invocationMessage: ( localize(7370, "Resolving details for \"{0}\"", eventLabel)),
+                pastTenseMessage: ( localize(7371, "Resolved details for \"{0}\"", eventLabel))
+            };
+        }
+        return {
+            invocationMessage: ( localize(7372, "Resolving debug event details")),
+            pastTenseMessage: ( localize(7373, "Resolved debug event details"))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const eventId = invocation.parameters["eventId"];
+        if (typeof eventId !== "string" || !eventId) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: eventId parameter is required."
+                }]
+            };
+        }
+        const sessionResource = invocation.context?.sessionResource;
+        if (!sessionResource) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: no chat session context available."
+                }]
+            };
+        }
+        const sessionEvents = this.chatDebugService.getEvents(sessionResource);
+        if (!( sessionEvents.some(e => e.id === eventId))) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `No event with ID "${eventId}" found in the current session.`
+                }]
+            };
+        }
+        const resolved = await this.chatDebugService.resolveEvent(eventId);
+        if (!resolved) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `No details found for event ID: ${eventId}`
+                }]
+            };
+        }
+        return {
+            content: [{
+                kind: "text",
+                value: formatResolvedContent(resolved)
+            }]
+        };
+    }
+};
+ResolveDebugEventDetailsTool = ( __decorate([( __param(0, IChatDebugService))], ResolveDebugEventDetailsTool));
+
+export { ResolveDebugEventDetailsTool, ResolveDebugEventDetailsToolData, ResolveDebugEventDetailsToolId };

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

@@ -5,17 +5,13 @@ import { IConfigurationChangeEvent } from "../../../../../../platform/configurat
 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 { IProductService } from "../../../../../../platform/product/common/productService.service.js";
 import { IChatService } from "../../chatService/chatService.service.js";
 import { ILanguageModelsService } from "../../languageModels.service.js";
 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;
@@ -31,11 +27,12 @@ export declare class RunSubagentTool extends Disposable implements IToolImpl {
     private readonly configurationService;
     private readonly promptsService;
     private readonly instantiationService;
+    private readonly productService;
     static readonly Id = "runSubagent";
     readonly onDidUpdateToolData: Event<IConfigurationChangeEvent>;
     /** Hack to port data between prepare/invoke */
     private readonly _resolvedModels;
-    constructor(chatAgentService: IChatAgentService, chatService: IChatService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, logService: ILogService, toolsService: ILanguageModelToolsService, configurationService: IConfigurationService, promptsService: IPromptsService, instantiationService: IInstantiationService);
+    constructor(chatAgentService: IChatAgentService, chatService: IChatService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, logService: ILogService, toolsService: ILanguageModelToolsService, configurationService: IConfigurationService, promptsService: IPromptsService, instantiationService: IInstantiationService, productService: IProductService);
     getToolData(): IToolData;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
     private getSubAgentByName;

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

@@ -11,30 +11,23 @@ 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 { IProductService } from '../../../../../../platform/product/common/productService.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 { mergeHooks } from '../../promptSyntax/hookSchema.js';
+import { HookType } from '../../promptSyntax/hookTypes.js';
 import { IPromptsService } from '../../promptSyntax/service/promptsService.service.js';
+import { isBuiltinAgent } from '../../promptSyntax/utils/promptsServiceUtils.js';
 import { ToolDataSource, VSCodeToolReference, isToolSet } from '../languageModelToolsService.js';
 import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
 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.
@@ -58,7 +51,8 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         toolsService,
         configurationService,
         promptsService,
-        instantiationService
+        instantiationService,
+        productService
     ) {
         super();
         this.chatAgentService = chatAgentService;
@@ -70,6 +64,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         this.configurationService = configurationService;
         this.promptsService = promptsService;
         this.instantiationService = instantiationService;
+        this.productService = productService;
         this._resolvedModels = ( new Map());
         this.onDidUpdateToolData = Event.filter(
             this.configurationService.onDidChangeConfiguration,
@@ -103,9 +98,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(7374, "Run Subagent")),
             userDescription: ( localize(
-                6584,
+                7375,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -167,7 +162,8 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         name: subAgentName,
                         content: instructions.content,
                         toolReferences: this.toolsService.toToolReferences(instructions.toolReferences),
-                        metadata: instructions.metadata
+                        metadata: instructions.metadata,
+                        isBuiltin: isBuiltinAgent(subagent.source, subagent.uri, this.productService)
                     };
                 } else {
                     throw ( new Error(
@@ -228,15 +224,32 @@ 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);
             }
+            if (subagent?.hooks) {
+                const remapped = {
+                    ...subagent.hooks
+                };
+                if (remapped[HookType.Stop]) {
+                    const stopHooks = remapped[HookType.Stop];
+                    remapped[HookType.SubagentStop] = remapped[HookType.SubagentStop] ? [...remapped[HookType.SubagentStop], ...stopHooks] : stopHooks;
+                    remapped[HookType.Stop] = undefined;
+                }
+                collectedHooks = mergeHooks(collectedHooks, remapped);
+            }
             const agentRequest = {
                 sessionResource: invocation.context.sessionResource,
                 requestId: invocation.callId ?? `subagent-${Date.now()}`,
@@ -251,6 +264,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 +314,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;
                 }
@@ -345,6 +356,6 @@ 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));
+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)), ( __param(9, IProductService))], RunSubagentTool));
 
-export { RunSubagentTool, parseMultiplier };
+export { RunSubagentTool };

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

@@ -0,0 +1,12 @@
+import { CancellationToken } from "../../../../../../base/common/cancellation.js";
+import { IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress, CountTokensCallback } from "../languageModelToolsService.js";
+export declare const TaskCompleteToolId = "task_complete";
+/**
+ * Message sent to the agent when the session goes idle without task completion.
+ */
+export declare const AUTOPILOT_CONTINUATION_MESSAGE: string;
+export declare const TaskCompleteToolData: IToolData;
+export declare class TaskCompleteTool implements IToolImpl {
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,53 @@
+
+import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
+
+const TaskCompleteToolId = 'task_complete';
+const TaskCompleteToolData = {
+    id: TaskCompleteToolId,
+    displayName: 'Task Complete',
+    modelDescription: 'Signal that the user\'s task is fully done. You MUST call this tool when your work is complete — ' +
+        'whether you made code changes, answered a question, or completed any other kind of task. ' +
+        'Provide a brief summary of what was accomplished. ' +
+        'Do not restate the summary in your message text — it is shown to the user directly.\n\n' +
+        'IMPORTANT: Before calling this tool, you MUST output a brief text message summarizing what was done. ' +
+        'The task is not complete until both your summary message AND this tool call are present.\n\n' +
+        'When to call:\n' +
+        '- After answering the user\'s question or completing a conversational request\n' +
+        '- After you have completed ALL requested changes\n' +
+        '- After verifying results: tests pass, terminal commands succeeded, tool calls returned expected output\n\n' +
+        'When NOT to call:\n' +
+        '- If a terminal command failed or produced unexpected output\n' +
+        '- If an MCP or external tool call returned an error\n' +
+        '- If you encountered errors you have not resolved\n' +
+        '- If there are remaining steps to complete\n' +
+        '- If you have not verified your changes work',
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            summary: {
+                type: 'string',
+                description: 'Brief summary of what was accomplished. Omit for trivial interactions.',
+            },
+        },
+    },
+};
+class TaskCompleteTool {
+    async prepareToolInvocation(_context, _token) {
+        return {
+            presentation: ToolInvocationPresentation.Hidden,
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const params = invocation.parameters;
+        const summary = params?.summary ?? 'All done!';
+        return {
+            content: [{
+                    kind: 'text',
+                    value: summary,
+                }],
+        };
+    }
+}
+
+export { TaskCompleteTool, TaskCompleteToolData, TaskCompleteToolId };

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

@@ -3,10 +3,13 @@ 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 { ResolveDebugEventDetailsTool, ResolveDebugEventDetailsToolData } from './resolveDebugEventDetailsTool.js';
 import { RunSubagentTool } from './runSubagentTool.js';
+import { TaskCompleteTool, TaskCompleteToolData } from './taskCompleteTool.js';
 
 let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
     static {
@@ -16,11 +19,24 @@ 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 taskCompleteTool = instantiationService.createInstance(TaskCompleteTool);
+        this._register(toolsService.registerTool(TaskCompleteToolData, taskCompleteTool));
+        const resolveDebugEventDetailsTool = instantiationService.createInstance(ResolveDebugEventDetailsTool);
+        this._register(
+            toolsService.registerTool(ResolveDebugEventDetailsToolData, resolveDebugEventDetailsTool)
+        );
+        this._register(toolsService.readToolSet.addTool(ResolveDebugEventDetailsToolData));
         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>;
 }
@@ -28,7 +30,7 @@ export interface ILanguageModelToolConfirmationActionProducer {
 export interface ILanguageModelToolConfirmationContributionQuickTreeItem extends IQuickTreeItem {
     onDidTriggerItemButton?(button: IQuickInputButton): void;
     onDidChangeChecked?(checked: boolean): void;
-    onDidOpen?(): void;
+    onDidOpen?(): void | Promise<void>;
 }
 /**
  * Type that can be registered to provide more specific confirmation

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

@@ -19,12 +19,21 @@ export interface ILanguageModelToolsConfirmationService extends ILanguageModelTo
     /** Opens an IQuickTree to let the user manage their preferences.  */
     manageConfirmationPreferences(tools: readonly IToolData[], options?: {
         defaultScope?: "workspace" | "profile" | "session";
+        focusToolId?: string;
     }): void;
     /**
     * Registers a contribution that provides more specific confirmation logic
     * for a tool, in addition to the default confirmation handling.
     */
     registerConfirmationContribution(toolName: string, contribution: ILanguageModelToolConfirmationContribution): IDisposable;
+    /**
+    * Returns true if the tool has confirmation that can be managed, either
+    * because it has {@link IToolData.canRequestPreApproval} or
+    * {@link IToolData.canRequestPostApproval} set, because a
+    * {@link ILanguageModelToolConfirmationContribution} is registered for it,
+    * or because it has stored auto-confirmation settings.
+    */
+    toolCanManageConfirmation(tool: IToolData): boolean;
     /** Resets all tool and server confirmation preferences */
     resetToolAutoConfirmation(): void;
 }