@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/chat/common/sessionChatPills.js

@@ -30,21 +30,21 @@ const SESSION_CHAT_PILL_KINDS = [
 function getSessionChatPillLabel(kind) {
     switch (kind) {
     case SessionChatPillKind.Changes:
-        return localize(10663, "Changes");
+        return localize(10858, "Changes");
     case SessionChatPillKind.Artifacts:
-        return localize(10664, "Artifacts");
+        return localize(10859, "Artifacts");
     case SessionChatPillKind.References:
-        return localize(10665, "References");
+        return localize(10860, "References");
     case SessionChatPillKind.Customizations:
-        return localize(10666, "Customizations");
+        return localize(10861, "Customizations");
     case SessionChatPillKind.PullRequests:
-        return localize(10667, "Pull Requests");
+        return localize(10862, "Pull Requests");
     case SessionChatPillKind.Issues:
-        return localize(10668, "Issues");
+        return localize(10863, "Issues");
     case SessionChatPillKind.Browsers:
-        return localize(10669, "Browsers");
+        return localize(10864, "Browsers");
     case SessionChatPillKind.Subagents:
-        return localize(10670, "Subagents");
+        return localize(10865, "Subagents");
     }
 }
 function isSessionChatPillHideable(kind) {
@@ -71,7 +71,7 @@ function getSessionChatPillMenu(
     }
     const hide = targetKind !== undefined && offeredKinds.includes(targetKind) && isSessionChatPillHideable(targetKind) ? {
         kind: targetKind,
-        label: ( localize(10671, "Hide {0}", getSessionChatPillLabel(targetKind)))
+        label: ( localize(10866, "Hide {0}", getSessionChatPillLabel(targetKind)))
     } : undefined;
     return {
         ...(hide ? {

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

@@ -0,0 +1,36 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export declare const ConfirmationToolId = "vscode_get_confirmation";
+export declare const ConfirmationToolWithOptionsId = "vscode_get_confirmation_with_options";
+export declare const ModifiedFilesConfirmationToolId = "vscode_get_modified_files_confirmation";
+export declare const ConfirmationToolData: IToolData;
+export declare const ConfirmationToolWithOptionsData: IToolData;
+export declare const ModifiedFilesConfirmationToolData: IToolData;
+export interface IConfirmationToolParams {
+    title: string;
+    message: string;
+    confirmationType?: "basic" | "terminal";
+    terminalCommand?: string;
+    buttons?: string[];
+}
+export interface IModifiedFilesConfirmationToolParams {
+    title: string;
+    message: string;
+    options: string[];
+    modifiedFiles: {
+        uri: string;
+        originalUri?: string;
+        insertions?: number;
+        deletions?: number;
+        title?: string;
+        description?: string;
+    }[];
+}
+export declare class ConfirmationTool implements IToolImpl {
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}
+export declare class ModifiedFilesConfirmationTool 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/confirmationTool.js

@@ -0,0 +1,239 @@
+
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { ConfirmationOptionKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+
+const ConfirmationToolId = "vscode_get_confirmation";
+const ConfirmationToolWithOptionsId = "vscode_get_confirmation_with_options";
+const ModifiedFilesConfirmationToolId = "vscode_get_modified_files_confirmation";
+const ConfirmationToolData = {
+    id: ConfirmationToolId,
+    displayName: "Confirmation Tool",
+    modelDescription: "A tool that demonstrates different types of confirmations. Takes a title, message, and confirmation type (basic or terminal).",
+    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"
+            },
+            confirmationType: {
+                type: "string",
+                enum: ["basic", "terminal"],
+                description: "Type of confirmation to show - basic for simple confirmation, terminal for terminal command confirmation"
+            },
+            terminalCommand: {
+                type: "string",
+                description: "Terminal command to show (only used when confirmationType is \"terminal\")"
+            }
+        },
+        required: ["title", "message", "confirmationType"],
+        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
+    }
+};
+const ModifiedFilesConfirmationToolData = {
+    id: ModifiedFilesConfirmationToolId,
+    displayName: "Modified Files Confirmation Tool",
+    modelDescription: "A tool that shows a modified-files confirmation UI with a split primary button and a hardcoded cancel action.",
+    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"
+            },
+            options: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                minItems: 1,
+                description: "Selectable option labels. The first option is used for the primary split button and the remaining options are placed in the dropdown menu."
+            },
+            modifiedFiles: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        uri: {
+                            type: "string",
+                            description: "URI of the modified file."
+                        },
+                        originalUri: {
+                            type: "string",
+                            description: "Optional original URI used when opening a diff."
+                        },
+                        insertions: {
+                            type: "number",
+                            description: "Optional number of lines added."
+                        },
+                        deletions: {
+                            type: "number",
+                            description: "Optional number of lines removed."
+                        },
+                        title: {
+                            type: "string",
+                            description: "Optional title shown in the file tooltip."
+                        },
+                        description: {
+                            type: "string",
+                            description: "Optional secondary label shown for the file entry."
+                        }
+                    },
+                    required: ["uri"],
+                    additionalProperties: false
+                },
+                description: "Modified files to show in the confirmation UI."
+            }
+        },
+        required: ["title", "message", "options", "modifiedFiles"],
+        additionalProperties: false
+    }
+};
+class ConfirmationTool {
+    async prepareToolInvocation(context, token) {
+        const parameters = context.parameters;
+        if (!parameters.title || !parameters.message) {
+            throw ( new Error("Missing required parameters for ConfirmationTool"));
+        }
+        const confirmationType = parameters.confirmationType ?? "basic";
+        let toolSpecificData;
+        if (confirmationType === "terminal") {
+            toolSpecificData = {
+                kind: "terminal",
+                commandLine: {
+                    original: parameters.terminalCommand ?? ""
+                },
+                language: "bash"
+            };
+        } else {
+            toolSpecificData = undefined;
+        }
+        return {
+            confirmationMessages: {
+                title: parameters.title,
+                message: ( new MarkdownString(parameters.message)),
+                allowAutoConfirm: (parameters.buttons || []).length ? false : true,
+                customOptions: parameters.buttons?.map((label, index) => ({
+                    id: label,
+                    label,
+                    kind: index === 0 ? ConfirmationOptionKind.Approve : ConfirmationOptionKind.Deny
+                }))
+            },
+            toolSpecificData,
+            presentation: ToolInvocationPresentation.HiddenAfterComplete
+        };
+    }
+    async invoke(invocation, countTokens, progress, token) {
+        if (invocation.selectedCustomButton) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: invocation.selectedCustomButton
+                }]
+            };
+        }
+        return {
+            content: [{
+                kind: "text",
+                value: "yes"
+            }]
+        };
+    }
+}
+class ModifiedFilesConfirmationTool {
+    async prepareToolInvocation(context, token) {
+        const parameters = context.parameters;
+        if (!parameters.title || !parameters.message) {
+            throw ( new Error("Missing required parameters for ModifiedFilesConfirmationTool"));
+        }
+        if (!parameters.options?.length) {
+            throw ( new Error("ModifiedFilesConfirmationTool requires at least one option"));
+        }
+        const toolSpecificData = {
+            kind: "modifiedFilesConfirmation",
+            options: parameters.options,
+            modifiedFiles: ( parameters.modifiedFiles.map(file => ({
+                uri: ( URI.parse(file.uri)).toJSON(),
+                originalUri: file.originalUri ? ( URI.parse(file.originalUri)).toJSON() : undefined,
+                insertions: file.insertions,
+                deletions: file.deletions,
+                title: file.title,
+                description: file.description
+            })))
+        };
+        return {
+            confirmationMessages: {
+                title: parameters.title,
+                message: ( new MarkdownString(parameters.message)),
+                allowAutoConfirm: false
+            },
+            toolSpecificData,
+            presentation: ToolInvocationPresentation.HiddenAfterComplete
+        };
+    }
+    async invoke(invocation, countTokens, progress, token) {
+        if (invocation.selectedCustomButton) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: invocation.selectedCustomButton
+                }]
+            };
+        }
+        return {
+            content: [{
+                kind: "text",
+                value: "yes"
+            }]
+        };
+    }
+}
+
+export { ConfirmationTool, ConfirmationToolData, ConfirmationToolId, ConfirmationToolWithOptionsData, ConfirmationToolWithOptionsId, ModifiedFilesConfirmationTool, ModifiedFilesConfirmationToolData, ModifiedFilesConfirmationToolId };

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

@@ -0,0 +1,21 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { ICodeMapperService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export { ExtensionEditToolId, InternalEditToolId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolIds";
+export declare const EditToolData: IToolData;
+export interface EditToolParams {
+    uri: UriComponents;
+    explanation: string;
+    code: string;
+}
+export declare class EditTool implements IToolImpl {
+    private readonly chatService;
+    private readonly codeMapperService;
+    private readonly notebookService;
+    constructor(chatService: IChatService, codeMapperService: ICodeMapperService, notebookService: INotebookService);
+    invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+}

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

@@ -0,0 +1,143 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { ICodeMapperService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { InternalEditToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolIds';
+export { ExtensionEditToolId, InternalEditToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolIds';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const EditToolData = {
+    id: InternalEditToolId,
+    displayName: "",
+    modelDescription: "",
+    source: ToolDataSource.Internal
+};
+let EditTool = class EditTool {
+    constructor(chatService, codeMapperService, notebookService) {
+        this.chatService = chatService;
+        this.codeMapperService = codeMapperService;
+        this.notebookService = notebookService;
+    }
+    async invoke(invocation, countTokens, _progress, token) {
+        if (!invocation.context) {
+            throw ( new Error("toolInvocationToken is required for this tool"));
+        }
+        const parameters = invocation.parameters;
+        const fileUri = URI.revive(parameters.uri);
+        const uri = CellUri.parse(fileUri)?.notebook || fileUri;
+        const model = this.chatService.getSession(invocation.context.sessionResource);
+        const request = model.getRequests().at(-1);
+        model.acceptResponseProgress(request, {
+            kind: "markdownContent",
+            content: ( new MarkdownString("\n````\n"))
+        });
+        model.acceptResponseProgress(request, {
+            kind: "codeblockUri",
+            uri,
+            isEdit: true
+        });
+        model.acceptResponseProgress(request, {
+            kind: "markdownContent",
+            content: ( new MarkdownString("\n````\n"))
+        });
+        if (this.notebookService.hasSupportedNotebooks(uri) && (this.notebookService.getNotebookTextModel(uri))) {
+            model.acceptResponseProgress(request, {
+                kind: "notebookEdit",
+                edits: [],
+                uri
+            });
+        } else {
+            model.acceptResponseProgress(request, {
+                kind: "textEdit",
+                edits: [],
+                uri
+            });
+        }
+        const editSession = model.editingSession;
+        if (!editSession) {
+            throw ( new Error("This tool must be called from within an editing session"));
+        }
+        const result = await this.codeMapperService.mapCode({
+            codeBlocks: [{
+                code: parameters.code,
+                resource: uri,
+                markdownBeforeBlock: parameters.explanation
+            }],
+            location: "tool",
+            chatRequestId: invocation.chatRequestId,
+            chatRequestModel: invocation.modelId,
+            chatSessionResource: invocation.context.sessionResource
+        }, {
+            textEdit: (target, edits) => {
+                model.acceptResponseProgress(request, {
+                    kind: "textEdit",
+                    uri: target,
+                    edits
+                });
+            },
+            notebookEdit(target, edits) {
+                model.acceptResponseProgress(request, {
+                    kind: "notebookEdit",
+                    uri: target,
+                    edits
+                });
+            }
+        }, token);
+        if (this.notebookService.hasSupportedNotebooks(uri) && (this.notebookService.getNotebookTextModel(uri))) {
+            model.acceptResponseProgress(request, {
+                kind: "notebookEdit",
+                uri,
+                edits: [],
+                done: true
+            });
+        } else {
+            model.acceptResponseProgress(request, {
+                kind: "textEdit",
+                uri,
+                edits: [],
+                done: true
+            });
+        }
+        if (result?.errorMessage) {
+            throw ( new Error(result.errorMessage));
+        }
+        let dispose;
+        await ( new Promise(resolve => {
+            let wasFileBeingModified = false;
+            dispose = autorun(r => {
+                const entries = editSession.entries.read(r);
+                const currentFile = entries?.find(e => isEqual(e.modifiedURI, uri));
+                if (currentFile) {
+                    if (currentFile.isCurrentlyBeingModifiedBy.read(r)) {
+                        wasFileBeingModified = true;
+                    } else if (wasFileBeingModified) {
+                        resolve(true);
+                    }
+                }
+            });
+        })).finally(() => {
+            dispose.dispose();
+        });
+        return {
+            content: [{
+                kind: "text",
+                value: "The file was edited successfully"
+            }]
+        };
+    }
+    async prepareToolInvocation(context, token) {
+        return {
+            presentation: ToolInvocationPresentation.Hidden
+        };
+    }
+};
+EditTool = ( __decorate([( __param(0, IChatService)), ( __param(1, ICodeMapperService)), ( __param(2, INotebookService))], EditTool));
+
+export { EditTool, EditToolData };

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

@@ -0,0 +1,24 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IToolData, IToolImpl, IToolInvocation, IToolResult, IToolInvocationPreparationContext, IPreparedToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service";
+export declare const ManageTodoListToolToolId = "manage_todo_list";
+export declare function createManageTodoListToolData(): IToolData;
+export declare const ManageTodoListToolData: IToolData;
+export declare class ManageTodoListTool extends Disposable implements IToolImpl {
+    private readonly chatTodoListService;
+    private readonly logService;
+    private readonly telemetryService;
+    constructor(chatTodoListService: IChatTodoListService, logService: ILogService, telemetryService: ITelemetryService);
+    invoke(invocation: IToolInvocation, _countTokens: any, _progress: any, _token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    private generatePastTenseMessage;
+    private handleRead;
+    private handleReadOperation;
+    private handleWriteOperation;
+    private calculateStatusCounts;
+    private formatTodoListAsMarkdownTaskList;
+    private calculateTodoChanges;
+}