@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/cellChatActions.js

@@ -0,0 +1,195 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyChord, KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, MenuId, MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { InputFocusedContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { MENU_INLINE_CHAT_WIDGET_STATUS, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_RESPONSE_TYPE, InlineChatResponseType, CTX_INLINE_CHAT_VISIBLE } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { CTX_NOTEBOOK_CHAT_HAS_AGENT } from './notebookChatContext.js';
+import { NotebookAction, getEditorFromArgsOrActivePane, getContextFromActiveEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { insertNewCell } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/controller/insertCellActions';
+import { NotebookSetting, CellKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_EDITOR_FOCUSED } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { InlineChatController } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { EditorAction2 } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+
+async function startChat(accessor, context, index, input, autoSend, source) {
+    const configurationService = accessor.get(IConfigurationService);
+    const commandService = accessor.get(ICommandService);
+    if (configurationService.getValue(NotebookSetting.cellGenerate) || configurationService.getValue(NotebookSetting.cellChat)) {
+        const activeCell = context.notebookEditor.getActiveCell();
+        const targetCell = activeCell?.getTextLength() === 0 && source !== "insertToolbar" ? activeCell : (await insertNewCell(accessor, context, CellKind.Code, "below"));
+        if (targetCell) {
+            targetCell.enableAutoLanguageDetection();
+            await context.notebookEditor.revealFirstLineIfOutsideViewport(targetCell);
+            const codeEditor = context.notebookEditor.codeEditors.find(ce => ce[0] === targetCell)?.[1];
+            if (codeEditor) {
+                codeEditor.focus();
+                commandService.executeCommand("inlineChat.start");
+            }
+        }
+    }
+}
+registerAction2(class extends NotebookAction {
+    constructor() {
+        super({
+            id: "notebook.cell.chat.start",
+            title: {
+                value: "$(sparkle) " + ( localize(9676, "Generate")),
+                original: "$(sparkle) Generate"
+            },
+            tooltip: ( localize(9677, "Start Chat to Generate Code")),
+            metadata: {
+                description: ( localize(9677, "Start Chat to Generate Code")),
+                args: [{
+                    name: "args",
+                    schema: {
+                        type: "object",
+                        required: ["index"],
+                        properties: {
+                            "index": {
+                                type: "number"
+                            },
+                            "input": {
+                                type: "string"
+                            },
+                            "autoSend": {
+                                type: "boolean"
+                            }
+                        }
+                    }
+                }]
+            },
+            f1: false,
+            keybinding: {
+                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ContextKeyExpr.not(InputFocusedContextKey), CTX_NOTEBOOK_CHAT_HAS_AGENT, ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)), ( ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true)))))),
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyI,
+                secondary: [KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyI)]
+            },
+            menu: [{
+                id: MenuId.NotebookCellBetween,
+                group: "inline",
+                order: -1,
+                when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), CTX_NOTEBOOK_CHAT_HAS_AGENT, ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)), ( ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))))))
+            }]
+        });
+    }
+    getEditorContextFromArgsOrActive(accessor, ...args) {
+        const [firstArg] = args;
+        if (!firstArg) {
+            const notebookEditor = getEditorFromArgsOrActivePane(accessor);
+            if (!notebookEditor) {
+                return undefined;
+            }
+            const activeCell = notebookEditor.getActiveCell();
+            if (!activeCell) {
+                return undefined;
+            }
+            return {
+                cell: activeCell,
+                notebookEditor,
+                input: undefined,
+                autoSend: undefined
+            };
+        }
+        if (typeof firstArg !== "object" || typeof firstArg.index !== "number") {
+            return undefined;
+        }
+        const notebookEditor = getEditorFromArgsOrActivePane(accessor);
+        if (!notebookEditor) {
+            return undefined;
+        }
+        const cell = firstArg.index <= 0 ? undefined : notebookEditor.cellAt(firstArg.index - 1);
+        return {
+            cell,
+            notebookEditor,
+            input: firstArg.input,
+            autoSend: firstArg.autoSend
+        };
+    }
+    async runWithContext(accessor, context) {
+        const index = Math.max(
+            0,
+            context.cell ? context.notebookEditor.getCellIndex(context.cell) + 1 : 0
+        );
+        await startChat(accessor, context, index, context.input, context.autoSend, context.source);
+    }
+});
+registerAction2(class extends NotebookAction {
+    constructor() {
+        super({
+            id: "notebook.cell.chat.startAtTop",
+            title: {
+                value: "$(sparkle) " + ( localize(9676, "Generate")),
+                original: "$(sparkle) Generate"
+            },
+            tooltip: ( localize(9677, "Start Chat to Generate Code")),
+            f1: false,
+            menu: [{
+                id: MenuId.NotebookCellListTop,
+                group: "inline",
+                order: -1,
+                when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), CTX_NOTEBOOK_CHAT_HAS_AGENT, ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)), ( ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))))))
+            }]
+        });
+    }
+    async runWithContext(accessor, context) {
+        await startChat(accessor, context);
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
+    command: {
+        id: "notebook.cell.chat.start",
+        icon: Codicon.sparkle,
+        title: ( localize(9678, "Generate")),
+        tooltip: ( localize(9679, "Start Chat to Generate Code"))
+    },
+    order: -10,
+    group: "navigation/add",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.insertToolbarLocation", "betweenCells")), ( ContextKeyExpr.notEquals("config.notebook.insertToolbarLocation", "hidden")), CTX_NOTEBOOK_CHAT_HAS_AGENT, ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${NotebookSetting.cellChat}`, true)), ( ContextKeyExpr.equals(`config.${NotebookSetting.cellGenerate}`, true))))))
+});
+class AcceptChangesAndRun extends EditorAction2 {
+    constructor() {
+        super({
+            id: "notebook.inlineChat.acceptChangesAndRun",
+            title: ( localize2(9680, "Accept and Run")),
+            shortTitle: ( localize(9681, "Accept & Run")),
+            tooltip: ( localize(9682, "Accept the changes and run the cell")),
+            icon: Codicon.check,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), CTX_INLINE_CHAT_VISIBLE)),
+            keybinding: undefined,
+            menu: [{
+                id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                group: "0_main",
+                order: 2,
+                when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ChatContextKeys.inputHasText.toNegated()), ( CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.toNegated()), ( CTX_INLINE_CHAT_RESPONSE_TYPE.isEqualTo(InlineChatResponseType.MessagesAndEdits))))
+            }]
+        });
+    }
+    runEditorCommand(accessor, codeEditor) {
+        const editor = getContextFromActiveEditor(accessor.get(IEditorService));
+        const ctrl = InlineChatController.get(codeEditor);
+        if (!editor || !ctrl) {
+            return;
+        }
+        const matchedCell = editor.notebookEditor.codeEditors.find(e => e[1] === codeEditor);
+        const cell = matchedCell?.[0];
+        if (!cell) {
+            return;
+        }
+        ctrl.acceptSession();
+        return editor.notebookEditor.executeNotebookCells(Iterable.single(cell));
+    }
+}
+registerAction2(AcceptChangesAndRun);
+
+export { AcceptChangesAndRun };

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/notebook.chat.contribution.d.ts

@@ -0,0 +1,8 @@
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare class SelectAndInsertKernelVariableAction extends Action2 {
+    constructor();
+    static readonly ID = "notebook.chat.selectAndInsertKernelVariable";
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+    private addVariableReference;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/notebook.chat.contribution.js

@@ -0,0 +1,368 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { codiconsLibrary } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codiconsLibrary';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, registerAction2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatContextPickService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatContextPickService.service';
+import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables';
+import { computeCompletionRanges } from '../../../../chat/browser/widget/input/editor/chatInputCompletions.js';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { chatVariableLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_OUTPUT_MIMETYPE } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
+import { NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST, createNotebookOutputVariableEntry } from '../../contrib/chat/notebookChatUtils.js';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { copyIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { getOutputViewModelFromId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/controller/cellOutputActions';
+import { NOTEBOOK_ACTIONS_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import './cellChatActions.js';
+import { CTX_NOTEBOOK_CHAT_HAS_AGENT } from './notebookChatContext.js';
+
+const NotebookKernelVariableKey = "kernelVariable";
+let NotebookChatContribution = class NotebookChatContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.notebookChatContribution";
+    }
+    constructor(
+        contextKeyService,
+        chatAgentService,
+        editorService,
+        chatWidgetService,
+        notebookKernelService,
+        languageFeaturesService,
+        chatContextPickService
+    ) {
+        super();
+        this.editorService = editorService;
+        this.chatWidgetService = chatWidgetService;
+        this.notebookKernelService = notebookKernelService;
+        this.languageFeaturesService = languageFeaturesService;
+        this._register(chatContextPickService.registerChatContextItem(( new KernelVariableContextPicker(this.editorService, this.notebookKernelService))));
+        this._ctxHasProvider = CTX_NOTEBOOK_CHAT_HAS_AGENT.bindTo(contextKeyService);
+        const updateNotebookAgentStatus = () => {
+            const hasNotebookAgent = Boolean(chatAgentService.getDefaultAgent(ChatAgentLocation.Notebook));
+            this._ctxHasProvider.set(hasNotebookAgent);
+        };
+        updateNotebookAgentStatus();
+        this._register(chatAgentService.onDidChangeAgents(updateNotebookAgentStatus));
+        this._register(this.languageFeaturesService.completionProvider.register({
+            scheme: Schemas.vscodeChatInput,
+            hasAccessToAllModels: true
+        }, {
+            _debugDisplayName: "chatKernelDynamicCompletions",
+            triggerCharacters: [chatVariableLeader],
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.supportsFileReferences) {
+                    return null;
+                }
+                if (widget.location !== ChatAgentLocation.Notebook) {
+                    return null;
+                }
+                const variableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, "g"));
+                const range = computeCompletionRanges(model, position, variableNameDef, true);
+                if (!range) {
+                    return null;
+                }
+                const result = {
+                    suggestions: []
+                };
+                const afterRange = ( new Range(
+                    position.lineNumber,
+                    range.replace.startColumn,
+                    position.lineNumber,
+                    range.replace.startColumn + `${chatVariableLeader}${NotebookKernelVariableKey}:`.length
+                ));
+                result.suggestions.push({
+                    label: `${chatVariableLeader}${NotebookKernelVariableKey}`,
+                    insertText: `${chatVariableLeader}${NotebookKernelVariableKey}:`,
+                    detail: ( localize(9683, "Pick a variable from the kernel")),
+                    range,
+                    kind: CompletionItemKind.Text,
+                    command: {
+                        id: SelectAndInsertKernelVariableAction.ID,
+                        title: SelectAndInsertKernelVariableAction.ID,
+                        arguments: [{
+                            widget,
+                            range: afterRange
+                        }]
+                    },
+                    sortText: "z"
+                });
+                await this.addKernelVariableCompletion(widget, result, range, token);
+                return result;
+            }
+        }));
+        NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT.bindTo(contextKeyService).set(NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST);
+    }
+    async addKernelVariableCompletion(widget, result, info, token) {
+        let pattern;
+        if (info.varWord?.word && info.varWord.word.startsWith(chatVariableLeader)) {
+            pattern = info.varWord.word.toLowerCase().slice(1);
+        }
+        const notebook = getNotebookEditorFromEditorPane(this.editorService.activeEditorPane)?.getViewModel()?.notebookDocument;
+        if (!notebook) {
+            return;
+        }
+        const selectedKernel = this.notebookKernelService.getMatchingKernel(notebook).selected;
+        const hasVariableProvider = selectedKernel?.hasVariableProvider;
+        if (!hasVariableProvider) {
+            return;
+        }
+        const variables = selectedKernel.provideVariables(notebook.uri, undefined, "named", 0, CancellationToken.None);
+        for await (const variable of variables) {
+            if (pattern && !variable.name.toLowerCase().includes(pattern)) {
+                continue;
+            }
+            result.suggestions.push({
+                label: {
+                    label: variable.name,
+                    description: variable.type
+                },
+                insertText: `${chatVariableLeader}${NotebookKernelVariableKey}:${variable.name} `,
+                filterText: `${chatVariableLeader}${variable.name}`,
+                range: info,
+                kind: CompletionItemKind.Variable,
+                sortText: "z",
+                command: {
+                    id: SelectAndInsertKernelVariableAction.ID,
+                    title: SelectAndInsertKernelVariableAction.ID,
+                    arguments: [{
+                        widget,
+                        range: info.insert,
+                        variable: variable.name
+                    }]
+                },
+                detail: variable.type,
+                documentation: variable.value
+            });
+        }
+    }
+};
+NotebookChatContribution = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IChatAgentService)), ( __param(2, IEditorService)), ( __param(3, IChatWidgetService)), ( __param(4, INotebookKernelService)), ( __param(5, ILanguageFeaturesService)), ( __param(6, IChatContextPickService))], NotebookChatContribution));
+class SelectAndInsertKernelVariableAction extends Action2 {
+    constructor() {
+        super({
+            id: SelectAndInsertKernelVariableAction.ID,
+            title: ""
+        });
+    }
+    static {
+        this.ID = "notebook.chat.selectAndInsertKernelVariable";
+    }
+    async run(accessor, ...args) {
+        const editorService = accessor.get(IEditorService);
+        const notebookKernelService = accessor.get(INotebookKernelService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const notebook = getNotebookEditorFromEditorPane(editorService.activeEditorPane)?.getViewModel()?.notebookDocument;
+        if (!notebook) {
+            return;
+        }
+        const context = args[0];
+        if (!context || !("widget" in context) || !("range" in context)) {
+            return;
+        }
+        const widget = context.widget;
+        const range = context.range;
+        const variable = context.variable;
+        if (variable !== undefined) {
+            this.addVariableReference(widget, variable, range, false);
+            return;
+        }
+        const selectedKernel = notebookKernelService.getMatchingKernel(notebook).selected;
+        const hasVariableProvider = selectedKernel?.hasVariableProvider;
+        if (!hasVariableProvider) {
+            return;
+        }
+        const variables = selectedKernel.provideVariables(notebook.uri, undefined, "named", 0, CancellationToken.None);
+        const quickPickItems = [];
+        for await (const variable of variables) {
+            quickPickItems.push({
+                label: variable.name,
+                description: variable.value,
+                detail: variable.type
+            });
+        }
+        const placeHolder = quickPickItems.length > 0 ? ( localize(9684, "Select a kernel variable")) : ( localize(9685, "No kernel variables found"));
+        const pickedVariable = await quickInputService.pick(quickPickItems, {
+            placeHolder
+        });
+        if (!pickedVariable) {
+            return;
+        }
+        this.addVariableReference(widget, pickedVariable.label, range, true);
+    }
+    addVariableReference(widget, variableName, range, updateText) {
+        if (range) {
+            const text = `#kernelVariable:${variableName}`;
+            if (updateText) {
+                const editor = widget.inputEditor;
+                const success = editor.executeEdits("chatInsertFile", [{
+                    range,
+                    text: text + " "
+                }]);
+                if (!success) {
+                    return;
+                }
+            }
+            widget.getContrib(ChatDynamicVariableModel.ID)?.addReference({
+                id: "vscode.notebook.variable",
+                range: {
+                    startLineNumber: range.startLineNumber,
+                    startColumn: range.startColumn,
+                    endLineNumber: range.endLineNumber,
+                    endColumn: range.startColumn + text.length
+                },
+                data: variableName,
+                fullName: variableName,
+                icon: codiconsLibrary.variable
+            });
+        } else {
+            widget.attachmentModel.addContext({
+                id: "vscode.notebook.variable",
+                name: variableName,
+                value: variableName,
+                icon: codiconsLibrary.variable,
+                kind: "generic"
+            });
+        }
+    }
+}
+let KernelVariableContextPicker = class KernelVariableContextPicker {
+    constructor(editorService, notebookKernelService) {
+        this.editorService = editorService;
+        this.notebookKernelService = notebookKernelService;
+        this.type = "pickerPick";
+        this.label = ( localize(9686, "Kernel Variable..."));
+        this.icon = Codicon.serverEnvironment;
+    }
+    isEnabled(widget) {
+        return widget.location === ChatAgentLocation.Notebook && Boolean(
+            getNotebookEditorFromEditorPane(this.editorService.activeEditorPane)?.getViewModel()?.notebookDocument
+        );
+    }
+    asPicker() {
+        const picks = (async () => {
+            const notebook = getNotebookEditorFromEditorPane(this.editorService.activeEditorPane)?.getViewModel()?.notebookDocument;
+            if (!notebook) {
+                return [];
+            }
+            const selectedKernel = this.notebookKernelService.getMatchingKernel(notebook).selected;
+            const hasVariableProvider = selectedKernel?.hasVariableProvider;
+            if (!hasVariableProvider) {
+                return [];
+            }
+            const variables = selectedKernel.provideVariables(notebook.uri, undefined, "named", 0, CancellationToken.None);
+            const result = [];
+            for await (const variable of variables) {
+                result.push({
+                    label: variable.name,
+                    description: variable.value,
+                    asAttachment: () => {
+                        return {
+                            kind: "generic",
+                            id: "vscode.notebook.variable",
+                            name: variable.name,
+                            value: variable.value,
+                            icon: codiconsLibrary.variable
+                        };
+                    }
+                });
+            }
+            return result;
+        })();
+        return {
+            placeholder: ( localize(9687, "Select a kernel variable")),
+            picks
+        };
+    }
+};
+KernelVariableContextPicker = ( __decorate([( __param(0, IEditorService)), ( __param(1, INotebookKernelService))], KernelVariableContextPicker));
+registerAction2(class AddCellOutputToChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "notebook.cellOutput.addToChat",
+            title: ( localize(9688, "Add Cell Output to Chat")),
+            menu: {
+                id: MenuId.NotebookOutputToolbar,
+                when: ( ContextKeyExpr.and(NOTEBOOK_CELL_HAS_OUTPUTS, ContextKeyExpr.in(
+                    NOTEBOOK_CELL_OUTPUT_MIMETYPE.key,
+                    NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT.key
+                ))),
+                order: 10,
+                group: "notebook_chat_actions"
+            },
+            category: NOTEBOOK_ACTIONS_CATEGORY,
+            icon: copyIcon,
+            precondition: ChatContextKeys.enabled
+        });
+    }
+    getNoteboookEditor(editorService, outputContext) {
+        if (outputContext && "notebookEditor" in outputContext) {
+            return outputContext.notebookEditor;
+        }
+        return getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    }
+    async run(accessor, outputContext) {
+        const notebookEditor = this.getNoteboookEditor(accessor.get(IEditorService), outputContext);
+        if (!notebookEditor) {
+            return;
+        }
+        let outputViewModel;
+        if (outputContext && "outputId" in outputContext && typeof outputContext.outputId === "string") {
+            outputViewModel = getOutputViewModelFromId(outputContext.outputId, notebookEditor);
+        } else if (outputContext && "outputViewModel" in outputContext) {
+            outputViewModel = outputContext.outputViewModel;
+        }
+        if (!outputViewModel) {
+            const activeCell = notebookEditor.getActiveCell();
+            if (!activeCell) {
+                return;
+            }
+            if (activeCell.focusedOutputId !== undefined) {
+                outputViewModel = activeCell.outputsViewModels.find(output => {
+                    return output.model.outputId === activeCell.focusedOutputId;
+                });
+            } else {
+                outputViewModel = activeCell.outputsViewModels.find(output => output.pickedMimeType?.isTrusted);
+            }
+        }
+        if (!outputViewModel) {
+            return;
+        }
+        const mimeType = outputViewModel.pickedMimeType?.mimeType;
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = await chatWidgetService.revealWidget();
+        if (widget && mimeType && NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST.includes(mimeType)) {
+            const entry = createNotebookOutputVariableEntry(outputViewModel, mimeType, notebookEditor);
+            if (!entry) {
+                return;
+            }
+            widget.attachmentModel.addContext(entry);
+            (await chatWidgetService.revealWidget())?.focusInput();
+        }
+    }
+});
+registerAction2(SelectAndInsertKernelVariableAction);
+registerWorkbenchContribution2(
+    NotebookChatContribution.ID,
+    NotebookChatContribution,
+    WorkbenchPhase.BlockRestore
+);
+
+export { SelectAndInsertKernelVariableAction };

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatContext.d.ts

@@ -0,0 +1,2 @@
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+export declare const CTX_NOTEBOOK_CHAT_HAS_AGENT: RawContextKey<boolean>;

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatContext.js

@@ -0,0 +1,7 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+const CTX_NOTEBOOK_CHAT_HAS_AGENT = ( new RawContextKey("notebookChatAgentRegistered", false, ( localize(9689, "Whether a chat agent for notebook is registered"))));
+
+export { CTX_NOTEBOOK_CHAT_HAS_AGENT };

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookModifiedCellDecorator.d.ts

@@ -1,5 +1,5 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { CellDiffInfo } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel";
+import { CellDiffInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel";
 import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
 export declare class NotebookModifiedCellDecorator extends Disposable {
     private readonly notebookEditor;

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookModifiedCellDecorator.js

@@ -16,7 +16,7 @@ class NotebookModifiedCellDecorator extends Disposable {
         }
         const modifiedCells = [];
         for (const diff of diffInfo) {
-            if (diff.type === 'modified') {
+            if (diff.type === "modified") {
                 const cell = model.cells[diff.modifiedCellIndex];
                 modifiedCells.push(cell);
             }