@codingame/monaco-vscode-api 26.2.1 → 27.0.0

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

@@ -0,0 +1,47 @@
+import { CancellationToken } from "../../../../../../base/common/cancellation.js";
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { IChatService } from "../../chatService/chatService.service.js";
+import { ILogService } from "../../../../../../platform/log/common/log.service.js";
+import { ITelemetryService } from "../../../../../../platform/telemetry/common/telemetry.service.js";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "../languageModelToolsService.js";
+export declare const AskQuestionsToolId = "vscode_askQuestions";
+export interface IQuestionOption {
+    readonly label: string;
+    readonly description?: string;
+    readonly recommended?: boolean;
+}
+export interface IQuestion {
+    readonly header: string;
+    readonly question: string;
+    readonly multiSelect?: boolean;
+    readonly options?: IQuestionOption[];
+    readonly allowFreeformInput?: boolean;
+}
+export interface IAskQuestionsParams {
+    readonly questions: IQuestion[];
+}
+export interface IQuestionAnswer {
+    readonly selected: string[];
+    readonly freeText: string | null;
+    readonly skipped: boolean;
+}
+export interface IAnswerResult {
+    readonly answers: Record<string, IQuestionAnswer>;
+}
+export declare function createAskQuestionsToolData(): IToolData;
+export declare const AskQuestionsToolData: IToolData;
+export declare class AskQuestionsTool extends Disposable implements IToolImpl {
+    private readonly chatService;
+    private readonly telemetryService;
+    private readonly logService;
+    constructor(chatService: IChatService, telemetryService: ITelemetryService, logService: ILogService);
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    private getRequest;
+    private toQuestionCarousel;
+    private toChatQuestion;
+    protected convertCarouselAnswers(questions: IQuestion[], carouselAnswers: Record<string, unknown> | undefined, idToHeaderMap: Map<string, string>): IAnswerResult;
+    private collectMetrics;
+    private createSkippedResult;
+    private sendTelemetry;
+}

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

@@ -0,0 +1,478 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationError } from '../../../../../../base/common/errors.js';
+import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { generateUuid } from '../../../../../../base/common/uuid.js';
+import { localize } from '../../../../../../nls.js';
+import { IChatService } from '../../chatService/chatService.service.js';
+import { ChatQuestionCarouselData } from '../../model/chatProgressTypes/chatQuestionCarouselData.js';
+import { StopWatch } from '../../../../../../base/common/stopwatch.js';
+import { ILogService } from '../../../../../../platform/log/common/log.service.js';
+import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.service.js';
+import { ToolDataSource } from '../languageModelToolsService.js';
+import { ThemeIcon } from '../../../../../../base/common/themables.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { raceCancellation } from '../../../../../../base/common/async.js';
+
+const AskQuestionsToolId = "vscode_askQuestions";
+const SoftLimits = {
+    header: 50,
+    question: 200
+};
+const HardLimits = {
+    header: 75,
+    question: 300
+};
+function truncateToLimit(value, limit) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value.length > limit) {
+        return value.slice(0, limit - 3) + "...";
+    }
+    return value;
+}
+function createAskQuestionsToolData() {
+    const questionSchema = {
+        type: "object",
+        properties: {
+            header: {
+                type: "string",
+                description: "Short identifier for the question. Must be unique so answers can be mapped back to the question.",
+                maxLength: SoftLimits.header
+            },
+            question: {
+                type: "string",
+                description: "The question text to display to the user. Keep it concise, ideally one sentence.",
+                maxLength: SoftLimits.question
+            },
+            multiSelect: {
+                type: "boolean",
+                description: "Allow selecting multiple options when options are provided."
+            },
+            allowFreeformInput: {
+                type: "boolean",
+                description: "Allow freeform text answers in addition to option selection."
+            },
+            options: {
+                type: "array",
+                description: "Optional list of selectable answers. If omitted, the question is free text.",
+                items: {
+                    type: "object",
+                    properties: {
+                        label: {
+                            type: "string",
+                            description: "Display label and value for the option."
+                        },
+                        description: {
+                            type: "string",
+                            description: "Optional secondary text shown with the option."
+                        },
+                        recommended: {
+                            type: "boolean",
+                            description: "Mark this option as the recommended default."
+                        }
+                    },
+                    required: ["label"]
+                }
+            }
+        },
+        required: ["header", "question"]
+    };
+    const inputSchema = {
+        type: "object",
+        properties: {
+            questions: {
+                type: "array",
+                description: "List of questions to ask the user. Order is preserved.",
+                items: questionSchema,
+                minItems: 1
+            }
+        },
+        required: ["questions"]
+    };
+    return {
+        id: AskQuestionsToolId,
+        toolReferenceName: "askQuestions",
+        legacyToolReferenceFullNames: [AskQuestionsToolId, "vscode/askQuestions"],
+        canBeReferencedInPrompt: false,
+        icon: ThemeIcon.fromId(Codicon.question.id),
+        displayName: ( localize(7169, "Ask Clarifying Questions")),
+        userDescription: ( localize(
+            7170,
+            "Ask structured clarifying questions using single select, multi-select, or freeform inputs to collect task requirements before proceeding."
+        )),
+        modelDescription: "Use this tool to ask the user a small number of clarifying questions before proceeding. Provide the questions array with concise headers and prompts. Use options for fixed choices, set multiSelect when multiple selections are allowed, and set allowFreeformInput to let users supply their own answer.",
+        source: ToolDataSource.Internal,
+        inputSchema
+    };
+}
+const AskQuestionsToolData = createAskQuestionsToolData();
+let AskQuestionsTool = class AskQuestionsTool extends Disposable {
+    constructor(chatService, telemetryService, logService) {
+        super();
+        this.chatService = chatService;
+        this.telemetryService = telemetryService;
+        this.logService = logService;
+    }
+    async invoke(invocation, _countTokens, progress, token) {
+        const stopWatch = StopWatch.create(true);
+        const parameters = invocation.parameters;
+        const {
+            questions
+        } = parameters;
+        this.logService.trace(`[AskQuestionsTool] Invoking with ${questions?.length ?? 0} question(s)`);
+        if (!questions || questions.length === 0) {
+            throw ( new Error(( localize(
+                7171,
+                "No questions provided. The questions array must contain at least one question."
+            ))));
+        }
+        const chatSessionResource = invocation.context?.sessionResource;
+        const chatRequestId = invocation.chatRequestId;
+        const {
+            request,
+            sessionResource
+        } = this.getRequest(chatSessionResource, chatRequestId);
+        if (!sessionResource || !request) {
+            this.logService.warn(
+                "[AskQuestionsTool] Missing chat context; marking all questions as skipped."
+            );
+            return this.createSkippedResult(questions);
+        }
+        const {
+            carousel,
+            idToHeaderMap
+        } = this.toQuestionCarousel(questions);
+        this.chatService.appendProgress(request, carousel);
+        const answerResult = await raceCancellation(carousel.completion.p, token);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        progress.report({
+            message: ( localize(7172, "Analyzing your answers..."))
+        });
+        const converted = this.convertCarouselAnswers(questions, answerResult?.answers, idToHeaderMap);
+        const {
+            answeredCount,
+            skippedCount,
+            freeTextCount,
+            recommendedAvailableCount,
+            recommendedSelectedCount
+        } = this.collectMetrics(questions, converted);
+        this.sendTelemetry(
+            invocation.chatRequestId,
+            questions.length,
+            answeredCount,
+            skippedCount,
+            freeTextCount,
+            recommendedAvailableCount,
+            recommendedSelectedCount,
+            stopWatch.elapsed()
+        );
+        const toolResultJson = JSON.stringify(converted);
+        this.logService.trace(
+            `[AskQuestionsTool] Returning tool result with metrics: questions=${questions.length}, answered=${answeredCount}, skipped=${skippedCount}, freeText=${freeTextCount}, recommendedAvailable=${recommendedAvailableCount}, recommendedSelected=${recommendedSelectedCount}`
+        );
+        return {
+            content: [{
+                kind: "text",
+                value: toolResultJson
+            }]
+        };
+    }
+    async prepareToolInvocation(context, _token) {
+        const parameters = context.parameters;
+        const {
+            questions
+        } = parameters;
+        if (!questions || questions.length === 0) {
+            throw ( new Error(( localize(
+                7171,
+                "No questions provided. The questions array must contain at least one question."
+            ))));
+        }
+        for (const question of questions) {
+            if (question.options && question.options.length === 1) {
+                throw ( new Error(( localize(
+                    7173,
+                    "Question \"{0}\" must have at least two options, or none for free text input.",
+                    question.header
+                ))));
+            }
+            question.question = truncateToLimit(question.question, HardLimits.question) ?? question.question;
+        }
+        const questionCount = questions.length;
+        const headers = ( questions.map(q => q.header)).join(", ");
+        const message = questionCount === 1 ? ( localize(7174, "Asking a question ({0})", headers)) : ( localize(7175, "Asking {0} questions ({1})", questionCount, headers));
+        const pastMessage = questionCount === 1 ? ( localize(7176, "Asked a question ({0})", headers)) : ( localize(7177, "Asked {0} questions ({1})", questionCount, headers));
+        return {
+            invocationMessage: ( new MarkdownString(message)),
+            pastTenseMessage: ( new MarkdownString(pastMessage))
+        };
+    }
+    getRequest(chatSessionResource, chatRequestId) {
+        if (!chatSessionResource) {
+            return {
+                request: undefined,
+                sessionResource: undefined
+            };
+        }
+        const model = this.chatService.getSession(chatSessionResource);
+        let request;
+        if (model) {
+            if (chatRequestId) {
+                request = model.getRequests().find(r => r.id === chatRequestId);
+            }
+            if (!request) {
+                request = model.getRequests().at(-1);
+            }
+        }
+        if (!request) {
+            return {
+                request: undefined,
+                sessionResource: chatSessionResource
+            };
+        }
+        return {
+            request,
+            sessionResource: chatSessionResource
+        };
+    }
+    toQuestionCarousel(questions) {
+        const idToHeaderMap = ( new Map());
+        const mappedQuestions = ( questions.map(question => this.toChatQuestion(question, idToHeaderMap)));
+        return {
+            carousel: ( new ChatQuestionCarouselData(mappedQuestions, true, generateUuid())),
+            idToHeaderMap
+        };
+    }
+    toChatQuestion(question, idToHeaderMap) {
+        let type;
+        if (!question.options || question.options.length === 0) {
+            type = "text";
+        } else if (question.multiSelect) {
+            type = "multiSelect";
+        } else {
+            type = "singleSelect";
+        }
+        let defaultValue;
+        if (question.options) {
+            const recommendedOptions = question.options.filter(opt => opt.recommended);
+            if (recommendedOptions.length > 0) {
+                defaultValue = question.multiSelect ? ( recommendedOptions.map(opt => opt.label)) : recommendedOptions[0].label;
+            }
+        }
+        const internalId = generateUuid();
+        idToHeaderMap.set(internalId, question.header);
+        const displayTitle = truncateToLimit(question.header, HardLimits.header) ?? question.header;
+        return {
+            id: internalId,
+            type,
+            title: displayTitle,
+            message: question.question,
+            options: question.options?.map(opt => ({
+                id: opt.label,
+                label: opt.description ? `${opt.label} - ${opt.description}` : opt.label,
+                value: opt.label
+            })),
+            defaultValue,
+            allowFreeformInput: question.allowFreeformInput ?? false
+        };
+    }
+    convertCarouselAnswers(questions, carouselAnswers, idToHeaderMap) {
+        const result = {
+            answers: {}
+        };
+        if (carouselAnswers) {
+            this.logService.trace(`[AskQuestionsTool] Carousel answer keys: ${( Object.keys(carouselAnswers)).join(", ")}`);
+            this.logService.trace(`[AskQuestionsTool] Question headers: ${( questions.map(q => q.header)).join(", ")}`);
+        }
+        const headerToIdMap = ( new Map());
+        for (const [internalId, originalHeader] of idToHeaderMap) {
+            headerToIdMap.set(originalHeader, internalId);
+        }
+        for (const question of questions) {
+            if (!carouselAnswers) {
+                result.answers[question.header] = {
+                    selected: [],
+                    freeText: null,
+                    skipped: true
+                };
+                continue;
+            }
+            const internalId = headerToIdMap.get(question.header);
+            const answer = internalId ? carouselAnswers[internalId] : undefined;
+            this.logService.trace(
+                `[AskQuestionsTool] Processing question "${question.header}" (internal ID: ${internalId}), raw answer: ${JSON.stringify(answer)}, type: ${typeof answer}`
+            );
+            if (answer === undefined) {
+                result.answers[question.header] = {
+                    selected: [],
+                    freeText: null,
+                    skipped: true
+                };
+            } else if (typeof answer === "string") {
+                if (question.options?.some(opt => opt.label === answer)) {
+                    result.answers[question.header] = {
+                        selected: [answer],
+                        freeText: null,
+                        skipped: false
+                    };
+                } else {
+                    result.answers[question.header] = {
+                        selected: [],
+                        freeText: answer,
+                        skipped: false
+                    };
+                }
+            } else if (Array.isArray(answer)) {
+                result.answers[question.header] = {
+                    selected: ( answer.map(a => String(a))),
+                    freeText: null,
+                    skipped: false
+                };
+            } else if (typeof answer === "object" && answer !== null) {
+                const answerObj = answer;
+                const freeformValue = typeof answerObj.freeformValue === "string" && answerObj.freeformValue ? answerObj.freeformValue : null;
+                const selectedValues = Array.isArray(answerObj.selectedValues) ? ( answerObj.selectedValues.map(v => String(v))) : undefined;
+                const selectedValue = answerObj.selectedValue;
+                const label = typeof answerObj.label === "string" ? answerObj.label : undefined;
+                if (selectedValues) {
+                    result.answers[question.header] = {
+                        selected: selectedValues,
+                        freeText: freeformValue,
+                        skipped: false
+                    };
+                } else if (typeof selectedValue === "string") {
+                    if (question.options?.some(opt => opt.label === selectedValue)) {
+                        result.answers[question.header] = {
+                            selected: [selectedValue],
+                            freeText: freeformValue,
+                            skipped: false
+                        };
+                    } else {
+                        result.answers[question.header] = {
+                            selected: [],
+                            freeText: freeformValue ?? selectedValue,
+                            skipped: false
+                        };
+                    }
+                } else if (Array.isArray(selectedValue)) {
+                    result.answers[question.header] = {
+                        selected: ( selectedValue.map(v => String(v))),
+                        freeText: freeformValue,
+                        skipped: false
+                    };
+                } else if (selectedValue === undefined || selectedValue === null) {
+                    if (freeformValue) {
+                        result.answers[question.header] = {
+                            selected: [],
+                            freeText: freeformValue,
+                            skipped: false
+                        };
+                    } else {
+                        result.answers[question.header] = {
+                            selected: [],
+                            freeText: null,
+                            skipped: true
+                        };
+                    }
+                } else if (freeformValue) {
+                    result.answers[question.header] = {
+                        selected: [],
+                        freeText: freeformValue,
+                        skipped: false
+                    };
+                } else if (label) {
+                    result.answers[question.header] = {
+                        selected: [label],
+                        freeText: null,
+                        skipped: false
+                    };
+                } else {
+                    this.logService.warn(
+                        `[AskQuestionsTool] Unknown answer object format for "${question.header}": ${JSON.stringify(answer)}`
+                    );
+                    result.answers[question.header] = {
+                        selected: [],
+                        freeText: null,
+                        skipped: true
+                    };
+                }
+            } else {
+                this.logService.warn(
+                    `[AskQuestionsTool] Unknown answer format for "${question.header}": ${typeof answer}`
+                );
+                result.answers[question.header] = {
+                    selected: [],
+                    freeText: null,
+                    skipped: true
+                };
+            }
+        }
+        return result;
+    }
+    collectMetrics(questions, result) {
+        const answers = ( Object.values(result.answers));
+        const answeredCount = answers.filter(a => !a.skipped).length;
+        const skippedCount = answers.filter(a => a.skipped).length;
+        const freeTextCount = answers.filter(a => a.freeText !== null).length;
+        const recommendedAvailableCount = questions.filter(q => q.options?.some(opt => opt.recommended)).length;
+        const recommendedSelectedCount = questions.filter(q => {
+            const answer = result.answers[q.header];
+            const recommendedOption = q.options?.find(opt => opt.recommended);
+            return answer && !answer.skipped && recommendedOption && answer.selected.includes(recommendedOption.label);
+        }).length;
+        return {
+            answeredCount,
+            skippedCount,
+            freeTextCount,
+            recommendedAvailableCount,
+            recommendedSelectedCount
+        };
+    }
+    createSkippedResult(questions) {
+        const skippedAnswers = {};
+        for (const question of questions) {
+            skippedAnswers[question.header] = {
+                selected: [],
+                freeText: null,
+                skipped: true
+            };
+        }
+        return {
+            content: [{
+                kind: "text",
+                value: JSON.stringify({
+                    answers: skippedAnswers
+                })
+            }]
+        };
+    }
+    sendTelemetry(
+        requestId,
+        questionCount,
+        answeredCount,
+        skippedCount,
+        freeTextCount,
+        recommendedAvailableCount,
+        recommendedSelectedCount,
+        duration
+    ) {
+        this.telemetryService.publicLog2("askQuestionsToolInvoked", {
+            requestId,
+            questionCount,
+            answeredCount,
+            skippedCount,
+            freeTextCount,
+            recommendedAvailableCount,
+            recommendedSelectedCount,
+            duration
+        });
+    }
+};
+AskQuestionsTool = ( __decorate([( __param(0, IChatService)), ( __param(1, ITelemetryService)), ( __param(2, ILogService))], AskQuestionsTool));
+
+export { AskQuestionsTool, AskQuestionsToolData, AskQuestionsToolId, createAskQuestionsToolData };

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

@@ -1,12 +1,15 @@
 import { CancellationToken } from "../../../../../../base/common/cancellation.js";
 import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "../languageModelToolsService.js";
 export declare const ConfirmationToolId = "vscode_get_confirmation";
+export declare const ConfirmationToolWithOptionsId = "vscode_get_confirmation_with_options";
 export declare const ConfirmationToolData: IToolData;
+export declare const ConfirmationToolWithOptionsData: IToolData;
 export interface IConfirmationToolParams {
     title: string;
     message: string;
     confirmationType?: "basic" | "terminal";
     terminalCommand?: string;
+    buttons?: string[];
 }
 export declare class ConfirmationTool implements IToolImpl {
     prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;

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

@@ -3,6 +3,7 @@ import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
 import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
 
 const ConfirmationToolId = "vscode_get_confirmation";
+const ConfirmationToolWithOptionsId = "vscode_get_confirmation_with_options";
 const ConfirmationToolData = {
     id: ConfirmationToolId,
     displayName: "Confirmation Tool",
@@ -33,6 +34,34 @@ const ConfirmationToolData = {
         additionalProperties: false
     }
 };
+const ConfirmationToolWithOptionsData = {
+    id: ConfirmationToolWithOptionsId,
+    displayName: "Confirmation Tool with Options",
+    modelDescription: "A tool that demonstrates different types of confirmations. Takes a title, message, and buttons.",
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Title for the confirmation dialog"
+            },
+            message: {
+                type: "string",
+                description: "Message to show in the confirmation dialog"
+            },
+            buttons: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                description: "Custom button labels to display."
+            }
+        },
+        required: ["title", "message", "buttons"],
+        additionalProperties: false
+    }
+};
 class ConfirmationTool {
     async prepareToolInvocation(context, token) {
         const parameters = context.parameters;
@@ -56,13 +85,22 @@ class ConfirmationTool {
             confirmationMessages: {
                 title: parameters.title,
                 message: ( new MarkdownString(parameters.message)),
-                allowAutoConfirm: true
+                allowAutoConfirm: (parameters.buttons || []).length ? false : true,
+                customButtons: parameters.buttons
             },
             toolSpecificData,
             presentation: ToolInvocationPresentation.HiddenAfterComplete
         };
     }
     async invoke(invocation, countTokens, progress, token) {
+        if (invocation.selectedCustomButton) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: invocation.selectedCustomButton
+                }]
+            };
+        }
         return {
             content: [{
                 kind: "text",
@@ -72,4 +110,4 @@ class ConfirmationTool {
     }
 }
 
-export { ConfirmationTool, ConfirmationToolData, ConfirmationToolId };
+export { ConfirmationTool, ConfirmationToolData, ConfirmationToolId, ConfirmationToolWithOptionsData, ConfirmationToolWithOptionsId };

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(7178, "Manage and track todo items for task planning")),
+        userDescription: ( localize(7179, "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(7180, "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(7181, "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(7182, "Created 1 todo")) : ( localize(7183, "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,
+                7184,
                 "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,
+                7185,
                 "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(7186, "Added 1 todo")) : ( localize(7187, "Added {0} todos", addedTodos.length));
         }
-        return localize(6582, "Updated todo list");
+        return localize(7188, "Updated todo list");
     }
     handleRead(todoItems, sessionResource) {
         if (todoItems.length === 0) {