@codingame/monaco-vscode-chat-service-override 17.2.1 → 18.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatToolPicker.js

@@ -0,0 +1,344 @@
+
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { diffSets } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { AddConfigurationAction } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/browser/mcpCommands';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { ToolDataSource, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { ConfigureToolSets } from '../tools/toolSetsContribution.js';
+
+var BucketOrdinal;
+(function (BucketOrdinal) {
+    BucketOrdinal[BucketOrdinal["User"] = 0] = "User";
+    BucketOrdinal[BucketOrdinal["BuiltIn"] = 1] = "BuiltIn";
+    BucketOrdinal[BucketOrdinal["Mcp"] = 2] = "Mcp";
+    BucketOrdinal[BucketOrdinal["Extension"] = 3] = "Extension";
+})(BucketOrdinal || (BucketOrdinal = {}));
+function isBucketPick(obj) {
+    return Boolean(obj.children);
+}
+function isToolSetPick(obj) {
+    return Boolean(obj.toolset);
+}
+function isToolPick(obj) {
+    return Boolean(obj.tool);
+}
+function isCallbackPick(obj) {
+    return Boolean(obj.run);
+}
+function isActionableButton(obj) {
+    return typeof obj.action === 'function';
+}
+async function showToolsPicker(accessor, placeHolder, toolsEntries, onUpdate) {
+    const quickPickService = accessor.get(IQuickInputService);
+    const mcpService = accessor.get(IMcpService);
+    const mcpRegistry = accessor.get(IMcpRegistry);
+    const commandService = accessor.get(ICommandService);
+    const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+    const editorService = accessor.get(IEditorService);
+    const toolsService = accessor.get(ILanguageModelToolsService);
+    const mcpServerByTool = ( new Map());
+    for (const server of mcpService.servers.get()) {
+        for (const tool of server.tools.get()) {
+            mcpServerByTool.set(tool.id, server);
+        }
+    }
+    const builtinBucket = {
+        type: 'item',
+        children: [],
+        label: ( localize(4498, "Built-In")),
+        ordinal: BucketOrdinal.BuiltIn,
+        picked: false,
+    };
+    const userBucket = {
+        type: 'item',
+        children: [],
+        label: ( localize(4499, "User Defined Tool Sets")),
+        ordinal: BucketOrdinal.User,
+        alwaysShow: true,
+        picked: false,
+    };
+    const addMcpPick = { type: 'item', label: ( localize(4500, "Add MCP Server...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: () => commandService.executeCommand(AddConfigurationAction.ID) };
+    const configureToolSetsPick = { type: 'item', label: ( localize(4501, "Configure Tool Sets...")), iconClass: ThemeIcon.asClassName(Codicon.gear), pickable: false, run: () => commandService.executeCommand(ConfigureToolSets.ID) };
+    const addExpPick = { type: 'item', label: ( localize(4502, "Install Extension...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: () => extensionWorkbenchService.openSearch('@tag:language-model-tools') };
+    const addPick = {
+        type: 'item', label: ( localize(4503, "Add More Tools...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: async () => {
+            const pick = await quickPickService.pick([addMcpPick, addExpPick], {
+                canPickMany: false,
+                placeHolder: ( localize(4504, "Add tools to chat"))
+            });
+            pick?.run();
+        }
+    };
+    const toolBuckets = ( new Map());
+    if (!toolsEntries) {
+        const defaultEntries = ( new Map());
+        for (const tool of toolsService.getTools()) {
+            defaultEntries.set(tool, false);
+        }
+        for (const toolSet of toolsService.toolSets.get()) {
+            defaultEntries.set(toolSet, false);
+        }
+        toolsEntries = defaultEntries;
+    }
+    for (const [toolSetOrTool, picked] of toolsEntries) {
+        let bucket;
+        const buttons = [];
+        if (toolSetOrTool.source.type === 'mcp') {
+            const key = ToolDataSource.toKey(toolSetOrTool.source);
+            const { definitionId } = toolSetOrTool.source;
+            const mcpServer = mcpService.servers.get().find(candidate => candidate.definition.id === definitionId);
+            if (!mcpServer) {
+                continue;
+            }
+            const buttons = [];
+            bucket = toolBuckets.get(key) ?? {
+                type: 'item',
+                label: ( localize(4505, "MCP Server: {0}", toolSetOrTool.source.label)),
+                ordinal: BucketOrdinal.Mcp,
+                picked: false,
+                alwaysShow: true,
+                children: [],
+                buttons
+            };
+            toolBuckets.set(key, bucket);
+            const collection = mcpRegistry.collections.get().find(c => c.id === mcpServer.collection.id);
+            if (collection?.presentation?.origin) {
+                buttons.push({
+                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                    tooltip: ( localize(4506, "Configure {0}", collection.label)),
+                    action: () => editorService.openEditor({
+                        resource: collection.presentation.origin,
+                    })
+                });
+            }
+            if (mcpServer.connectionState.get().state === McpConnectionState.Kind.Error) {
+                buttons.push({
+                    iconClass: ThemeIcon.asClassName(Codicon.warning),
+                    tooltip: ( localize(4507, "Show Output")),
+                    action: () => mcpServer.showOutput(),
+                });
+            }
+        }
+        else if (toolSetOrTool.source.type === 'extension') {
+            const key = ToolDataSource.toKey(toolSetOrTool.source);
+            bucket = toolBuckets.get(key) ?? {
+                type: 'item',
+                label: ( localize(4508, 'Extension: {0}', toolSetOrTool.source.label)),
+                ordinal: BucketOrdinal.Extension,
+                picked: false,
+                alwaysShow: true,
+                children: []
+            };
+            toolBuckets.set(key, bucket);
+        }
+        else if (toolSetOrTool.source.type === 'internal') {
+            bucket = builtinBucket;
+        }
+        else if (toolSetOrTool.source.type === 'user') {
+            bucket = userBucket;
+            buttons.push({
+                iconClass: ThemeIcon.asClassName(Codicon.edit),
+                tooltip: ( localize(4509, "Edit Tool Set")),
+                action: () => {
+                    assertType(toolSetOrTool.source.type === 'user');
+                    editorService.openEditor({ resource: toolSetOrTool.source.file });
+                }
+            });
+        }
+        else {
+            assertNever();
+        }
+        if (toolSetOrTool instanceof ToolSet) {
+            if (toolSetOrTool.source.type !== 'mcp') {
+                bucket.children.push({
+                    parent: bucket,
+                    type: 'item',
+                    picked,
+                    toolset: toolSetOrTool,
+                    label: toolSetOrTool.referenceName,
+                    description: toolSetOrTool.description,
+                    indented: true,
+                    buttons
+                });
+            }
+            else {
+                bucket.toolset = toolSetOrTool;
+            }
+        }
+        else if (toolSetOrTool.canBeReferencedInPrompt) {
+            bucket.children.push({
+                parent: bucket,
+                type: 'item',
+                picked,
+                tool: toolSetOrTool,
+                label: toolSetOrTool.toolReferenceName ?? toolSetOrTool.displayName,
+                description: toolSetOrTool.userDescription ?? toolSetOrTool.modelDescription,
+                indented: true,
+            });
+        }
+        if (picked) {
+            bucket.picked = true;
+        }
+    }
+    for (const bucket of [builtinBucket, userBucket]) {
+        if (bucket.children.length > 0) {
+            toolBuckets.set(generateUuid(), bucket);
+        }
+    }
+    const store = ( new DisposableStore());
+    const picks = [];
+    for (const bucket of Array.from(( toolBuckets.values())).sort((a, b) => a.ordinal - b.ordinal)) {
+        picks.push({
+            type: 'separator',
+            label: bucket.status
+        });
+        picks.push(bucket);
+        picks.push(...bucket.children.sort((a, b) => a.label.localeCompare(b.label)));
+    }
+    const picker = store.add(quickPickService.createQuickPick({ useSeparators: true }));
+    picker.placeholder = placeHolder;
+    picker.canSelectMany = true;
+    picker.keepScrollPosition = true;
+    picker.sortByLabel = false;
+    picker.matchOnDescription = true;
+    if (picks.length === 0) {
+        picker.placeholder = ( localize(4504, "Add tools to chat"));
+        picker.canSelectMany = false;
+        picks.push(addMcpPick, addExpPick);
+    }
+    else {
+        picks.push({ type: 'separator' }, configureToolSetsPick, addPick);
+    }
+    let lastSelectedItems = ( new Set());
+    let ignoreEvent = false;
+    const result = ( new Map());
+    const _update = () => {
+        ignoreEvent = true;
+        try {
+            const items = picks.filter((p) => p.type === 'item' && Boolean(p.picked));
+            lastSelectedItems = ( new Set(items));
+            picker.selectedItems = items;
+            result.clear();
+            for (const item of picks) {
+                if (item.type !== 'item') {
+                    continue;
+                }
+                if (isToolSetPick(item)) {
+                    result.set(item.toolset, item.picked);
+                }
+                else if (isToolPick(item)) {
+                    result.set(item.tool, item.picked);
+                }
+                else if (isBucketPick(item)) {
+                    if (item.toolset) {
+                        result.set(item.toolset, item.picked);
+                    }
+                    for (const child of item.children) {
+                        if (isToolSetPick(child)) {
+                            result.set(child.toolset, item.picked);
+                        }
+                        else if (isToolPick(child)) {
+                            result.set(child.tool, item.picked);
+                        }
+                    }
+                }
+            }
+            if (onUpdate) {
+                let didChange = toolsEntries.size !== result.size;
+                for (const [key, value] of toolsEntries) {
+                    if (didChange) {
+                        break;
+                    }
+                    didChange = result.get(key) !== value;
+                }
+                if (didChange) {
+                    onUpdate(result);
+                }
+            }
+        }
+        finally {
+            ignoreEvent = false;
+        }
+    };
+    _update();
+    picker.items = picks;
+    picker.show();
+    store.add(picker.onDidTriggerItemButton(e => {
+        if (isActionableButton(e.button)) {
+            e.button.action();
+            store.dispose();
+        }
+    }));
+    store.add(picker.onDidChangeSelection(selectedPicks => {
+        if (ignoreEvent) {
+            return;
+        }
+        const addPick = selectedPicks.find(isCallbackPick);
+        if (addPick) {
+            addPick.run();
+            picker.hide();
+            return;
+        }
+        const { added, removed } = diffSets(lastSelectedItems, ( new Set(selectedPicks)));
+        for (const item of added) {
+            item.picked = true;
+            if (isBucketPick(item)) {
+                for (const toolPick of item.children) {
+                    toolPick.picked = true;
+                }
+            }
+            else if (isToolPick(item) || isToolSetPick(item)) {
+                item.parent.picked = true;
+            }
+        }
+        for (const item of removed) {
+            item.picked = false;
+            if (isBucketPick(item)) {
+                for (const toolPick of item.children) {
+                    toolPick.picked = false;
+                }
+            }
+            else if ((isToolPick(item) || isToolSetPick(item)) && item.parent.children.every(child => !child.picked)) {
+                item.parent.picked = false;
+            }
+        }
+        _update();
+    }));
+    let didAccept = false;
+    store.add(picker.onDidAccept(() => {
+        picker.activeItems.find(isCallbackPick)?.run();
+        didAccept = true;
+    }));
+    await Promise.race([Event.toPromise(Event.any(picker.onDidAccept, picker.onDidHide))]);
+    store.dispose();
+    const mcpToolSets = ( new Set());
+    for (const item of toolsService.toolSets.get()) {
+        if (item.source.type === 'mcp') {
+            mcpToolSets.add(item);
+            if (Iterable.every(item.getTools(), tool => result.get(tool))) {
+                for (const tool of item.getTools()) {
+                    result.delete(tool);
+                }
+                result.set(item, true);
+            }
+        }
+    }
+    return didAccept ? result : undefined;
+}
+
+export { showToolsPicker };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/codeBlockOperations.d.ts

@@ -32,7 +32,6 @@ export declare class ApplyCodeBlockOperation {
     private readonly editorService;
     private readonly textFileService;
     private readonly chatService;
-    private readonly languageService;
     private readonly fileService;
     private readonly dialogService;
     private readonly logService;
@@ -42,14 +41,16 @@ export declare class ApplyCodeBlockOperation {
     private readonly labelService;
     private readonly instantiationService;
     private readonly notebookService;
-    constructor(editorService: IEditorService, textFileService: ITextFileService, chatService: IChatService, languageService: ILanguageService, fileService: IFileService, dialogService: IDialogService, logService: ILogService, codeMapperService: ICodeMapperService, progressService: IProgressService, quickInputService: IQuickInputService, labelService: ILabelService, instantiationService: IInstantiationService, notebookService: INotebookService);
+    constructor(editorService: IEditorService, textFileService: ITextFileService, chatService: IChatService, fileService: IFileService, dialogService: IDialogService, logService: ILogService, codeMapperService: ICodeMapperService, progressService: IProgressService, quickInputService: IQuickInputService, labelService: ILabelService, instantiationService: IInstantiationService, notebookService: INotebookService);
     run(context: ICodeBlockActionContext): Promise<void>;
     private evaluateURIToUse;
     private handleNotebookEditor;
     private handleTextEditor;
-    private getEdits;
+    private getTextEdits;
+    private getNotebookEdits;
     private waitForFirstElement;
     private applyWithInlinePreview;
+    private applyNotebookEditsWithInlinePreview;
     private tryToRevealCodeBlock;
     private notify;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/actions/codeBlockOperations.js

@@ -22,12 +22,12 @@ import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platfor
 import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
-import { reviewEdits } from '@codingame/monaco-vscode-9f229325-8261-585c-a552-16085958c680-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { reviewEdits, reviewNotebookEdits } from '@codingame/monaco-vscode-6c0f93b9-169c-58c3-a9cb-7d60698eb52c-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 import { insertCell } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
 import { CellKind, NOTEBOOK_EDITOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { ICodeMapperService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { isResponseVM } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { isResponseVM } from '@codingame/monaco-vscode-3a35f433-1297-5707-ab58-c261b8180e6d-common/vscode/vs/workbench/contrib/chat/common/chatViewModel';
 import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
@@ -55,7 +55,7 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
             }
             else {
                 this.notify(( localize(
-                    4486,
+                    4510,
                     "To insert the code block, open a code editor or notebook editor and set the cursor at the location where to insert the code block."
                 )));
             }
@@ -68,7 +68,7 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
     }
     async handleNotebookEditor(notebookEditor, codeBlockContext) {
         if (notebookEditor.isReadOnly) {
-            this.notify(( localize(4487, "Cannot insert the code block to read-only notebook editor.")));
+            this.notify(( localize(4511, "Cannot insert the code block to read-only notebook editor.")));
             return false;
         }
         const focusRange = notebookEditor.getFocus();
@@ -79,7 +79,7 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
     async handleTextEditor(codeEditor, codeBlockContext) {
         const activeModel = codeEditor.getModel();
         if (isReadOnly(activeModel, this.textFileService)) {
-            this.notify(( localize(4488, "Cannot insert the code block to read-only code editor.")));
+            this.notify(( localize(4512, "Cannot insert the code block to read-only code editor.")));
             return false;
         }
         const range = codeEditor.getSelection() ?? ( new Range(activeModel.getLineCount(), 1, activeModel.getLineCount(), 1));
@@ -103,11 +103,10 @@ InsertCodeBlockOperation = ( __decorate([
     ( __param(6, IDialogService))
 ], InsertCodeBlockOperation));
 let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
-    constructor(editorService, textFileService, chatService, languageService, fileService, dialogService, logService, codeMapperService, progressService, quickInputService, labelService, instantiationService, notebookService) {
+    constructor(editorService, textFileService, chatService, fileService, dialogService, logService, codeMapperService, progressService, quickInputService, labelService, instantiationService, notebookService) {
         this.editorService = editorService;
         this.textFileService = textFileService;
         this.chatService = chatService;
-        this.languageService = languageService;
         this.fileService = fileService;
         this.dialogService = dialogService;
         this.logService = logService;
@@ -133,7 +132,7 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
                     activeEditorControl = codeEditor;
                 }
                 else {
-                    this.notify(( localize(4489, "Failed to open {0} in a code editor.", (codemapperUri.toString()))));
+                    this.notify(( localize(4513, "Failed to open {0} in a code editor.", (codemapperUri.toString()))));
                     return;
                 }
             }
@@ -149,10 +148,10 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         else {
             const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
             if (activeNotebookEditor) {
-                result = await this.handleNotebookEditor(activeNotebookEditor, context.code);
+                result = await this.handleNotebookEditor(activeNotebookEditor, context.chatSessionId, context.code);
             }
             else {
-                this.notify(( localize(4490, "To apply this code block, open a code or notebook editor.")));
+                this.notify(( localize(4514, "To apply this code block, open a code or notebook editor.")));
             }
         }
         notifyUserAction(this.chatService, context, {
@@ -168,15 +167,15 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
             return resource;
         }
         const activeEditorOption = activeEditorControl?.getModel().uri ? { label: ( localize(
-            4491,
+            4515,
             "Active editor '{0}'",
             this.labelService.getUriLabel(activeEditorControl.getModel().uri, { relative: true })
         )), id: 'activeEditor' } : undefined;
-        const untitledEditorOption = { label: ( localize(4492, "New untitled editor")), id: 'newUntitledFile' };
+        const untitledEditorOption = { label: ( localize(4516, "New untitled editor")), id: 'newUntitledFile' };
         const options = [];
         if (resource) {
             options.push({ label: ( localize(
-                4493,
+                4517,
                 "New file '{0}'",
                 this.labelService.getUriLabel(resource, { relative: true })
             )), id: 'createFile' });
@@ -191,7 +190,7 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
             }
             options.push(untitledEditorOption);
         }
-        const selected = options.length > 1 ? await this.quickInputService.pick(options, { placeHolder: ( localize(4494, "Select where to apply the code block")) }) : options[0];
+        const selected = options.length > 1 ? await this.quickInputService.pick(options, { placeHolder: ( localize(4518, "Select where to apply the code block")) }) : options[0];
         if (selected) {
             switch (selected.id) {
                 case 'createFile':
@@ -200,7 +199,7 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
                             await this.fileService.writeFile(resource, VSBuffer.fromString(''));
                         }
                         catch (error) {
-                            this.notify(( localize(4495, "Failed to create file: {0}", error.message)));
+                            this.notify(( localize(4519, "Failed to create file: {0}", error.message)));
                             return ( URI.from({ scheme: 'untitled', path: resource.path }));
                         }
                     }
@@ -213,41 +212,66 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         }
         return undefined;
     }
-    async handleNotebookEditor(notebookEditor, code) {
+    async handleNotebookEditor(notebookEditor, chatSessionId, code) {
         if (notebookEditor.isReadOnly) {
-            this.notify(( localize(4496, "Cannot apply code block to read-only notebook editor.")));
+            this.notify(( localize(4520, "Cannot apply code block to read-only notebook editor.")));
             return undefined;
         }
-        const focusRange = notebookEditor.getFocus();
-        const next = Math.max(focusRange.end - 1, 0);
-        insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', code, true);
-        return undefined;
+        const uri = notebookEditor.textModel.uri;
+        const codeBlock = { code, resource: uri, markdownBeforeBlock: undefined };
+        const codeMapper = this.codeMapperService.providers[0]?.displayName;
+        if (!codeMapper) {
+            this.notify(( localize(4521, "No code mapper available.")));
+            return undefined;
+        }
+        let editsProposed = false;
+        const cancellationTokenSource = ( new CancellationTokenSource());
+        try {
+            const iterable = await this.progressService.withProgress({ location: ProgressLocation.Notification, delay: 500, sticky: true, cancellable: true }, async (progress) => {
+                progress.report({ message: ( localize(4522, "Applying code block using {0}...", codeMapper)) });
+                const editsIterable = this.getNotebookEdits(codeBlock, chatSessionId, cancellationTokenSource.token);
+                return await this.waitForFirstElement(editsIterable);
+            }, () => cancellationTokenSource.cancel());
+            editsProposed = await this.applyNotebookEditsWithInlinePreview(iterable, uri, cancellationTokenSource);
+        }
+        catch (e) {
+            if (!isCancellationError(e)) {
+                this.notify(( localize(4523, "Failed to apply code block: {0}", e.message)));
+            }
+        }
+        finally {
+            cancellationTokenSource.dispose();
+        }
+        return {
+            editsProposed,
+            codeMapper
+        };
     }
     async handleTextEditor(codeEditor, chatSessionId, code) {
         const activeModel = codeEditor.getModel();
         if (isReadOnly(activeModel, this.textFileService)) {
-            this.notify(( localize(4497, "Cannot apply code block to read-only file.")));
+            this.notify(( localize(4524, "Cannot apply code block to read-only file.")));
             return undefined;
         }
         const codeBlock = { code, resource: activeModel.uri, chatSessionId, markdownBeforeBlock: undefined };
         const codeMapper = this.codeMapperService.providers[0]?.displayName;
         if (!codeMapper) {
-            this.notify(( localize(4498, "No code mapper available.")));
+            this.notify(( localize(4521, "No code mapper available.")));
             return undefined;
         }
         let editsProposed = false;
         const cancellationTokenSource = ( new CancellationTokenSource());
         try {
             const iterable = await this.progressService.withProgress({ location: ProgressLocation.Notification, delay: 500, sticky: true, cancellable: true }, async (progress) => {
-                progress.report({ message: ( localize(4499, "Applying code block using {0}...", codeMapper)) });
-                const editsIterable = this.getEdits(codeBlock, chatSessionId, cancellationTokenSource.token);
+                progress.report({ message: ( localize(4522, "Applying code block using {0}...", codeMapper)) });
+                const editsIterable = this.getTextEdits(codeBlock, chatSessionId, cancellationTokenSource.token);
                 return await this.waitForFirstElement(editsIterable);
             }, () => cancellationTokenSource.cancel());
             editsProposed = await this.applyWithInlinePreview(iterable, codeEditor, cancellationTokenSource);
         }
         catch (e) {
             if (!isCancellationError(e)) {
-                this.notify(( localize(4500, "Failed to apply code block: {0}", e.message)));
+                this.notify(( localize(4523, "Failed to apply code block: {0}", e.message)));
             }
         }
         finally {
@@ -258,7 +282,7 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
             codeMapper
         };
     }
-    getEdits(codeBlock, chatSessionId, token) {
+    getTextEdits(codeBlock, chatSessionId, token) {
         return ( new AsyncIterableObject(async (executor) => {
             const request = {
                 codeBlocks: [codeBlock],
@@ -277,6 +301,27 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
             }
         }));
     }
+    getNotebookEdits(codeBlock, chatSessionId, token) {
+        return ( new AsyncIterableObject(async (executor) => {
+            const request = {
+                codeBlocks: [codeBlock],
+                chatSessionId,
+                location: 'panel'
+            };
+            const response = {
+                textEdit: (target, edits) => {
+                    executor.emitOne([target, edits]);
+                },
+                notebookEdit(_resource, edit) {
+                    executor.emitOne(edit);
+                },
+            };
+            const result = await this.codeMapperService.mapCode(request, response, token);
+            if (result?.errorMessage) {
+                executor.reject(( new Error(result.errorMessage)));
+            }
+        }));
+    }
     async waitForFirstElement(iterable) {
         const iterator = iterable[Symbol.asyncIterator]();
         let result = await iterator.next();
@@ -299,6 +344,9 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
     async applyWithInlinePreview(edits, codeEditor, tokenSource) {
         return this.instantiationService.invokeFunction(reviewEdits, codeEditor, edits, tokenSource.token);
     }
+    async applyNotebookEditsWithInlinePreview(edits, uri, tokenSource) {
+        return this.instantiationService.invokeFunction(reviewNotebookEdits, uri, edits, tokenSource.token);
+    }
     tryToRevealCodeBlock(codeEditor, codeBlock) {
         const match = codeBlock.match(/(\S[^\n]*)\n/);
         if (match && match[1].length > 10) {
@@ -316,16 +364,15 @@ ApplyCodeBlockOperation = ( __decorate([
     ( __param(0, IEditorService)),
     ( __param(1, ITextFileService)),
     ( __param(2, IChatService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, IFileService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ICodeMapperService)),
-    ( __param(8, IProgressService)),
-    ( __param(9, IQuickInputService)),
-    ( __param(10, ILabelService)),
-    ( __param(11, IInstantiationService)),
-    ( __param(12, INotebookService))
+    ( __param(3, IFileService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, ILogService)),
+    ( __param(6, ICodeMapperService)),
+    ( __param(7, IProgressService)),
+    ( __param(8, IQuickInputService)),
+    ( __param(9, ILabelService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, INotebookService))
 ], ApplyCodeBlockOperation));
 function notifyUserAction(chatService, context, action) {
     if (isResponseVM(context.element)) {

package/vscode/src/vs/workbench/contrib/chat/browser/actions/promptActions/chatAttachInstructionsAction.d.ts

@@ -1,10 +1,25 @@
-import { IChatWidget } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidget } from "@codingame/monaco-vscode-7adbeffb-8051-54a9-8c9b-b62ce9e5836f-common/vscode/vs/workbench/contrib/chat/browser/chat";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service";
+import { ChatContextPick, IChatContextPickerItem } from "@codingame/monaco-vscode-f338ac19-278c-5fe1-bec8-b588de04a788-common/vscode/vs/workbench/contrib/chat/browser/chatContextPickService";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 export interface IAttachInstructionsActionOptions {
     readonly widget?: IChatWidget;
     readonly resource?: URI;
     readonly skipSelectionDialog?: boolean;
 }
-export declare const runAttachInstructionsAction: (commandService: ICommandService, options: IAttachInstructionsActionOptions) => Promise<void>;
 export declare const registerAttachPromptActions: () => void;
+export declare class ChatInstructionsPickerPick implements IChatContextPickerItem {
+    private readonly promptsService;
+    private readonly labelService;
+    readonly type = "pickerPick";
+    readonly label: string;
+    readonly icon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+    readonly commandId = "workbench.action.chat.attach.instructions";
+    constructor(promptsService: IPromptsService, labelService: ILabelService);
+    isEnabled(widget: IChatWidget): Promise<boolean> | boolean;
+    asPicker(): {
+        readonly placeholder: string;
+        readonly picks: Promise<ChatContextPick[]>;
+    };
+}