@codingame/monaco-vscode-chat-service-override 8.0.4 → 9.0.2

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

@@ -1,27 +1,46 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
-let LanguageModelToolsService = class LanguageModelToolsService {
-    constructor(_extensionService) {
+let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
+    constructor(_extensionService, _contextKeyService) {
+        super();
         this._extensionService = _extensionService;
+        this._contextKeyService = _contextKeyService;
         this._onDidChangeTools = ( new Emitter());
         this.onDidChangeTools = this._onDidChangeTools.event;
+        this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
         this._tools = ( new Map());
+        this._toolContextKeys = ( new Set());
+        this._register(this._contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(this._toolContextKeys)) {
+                this._onDidChangeToolsScheduler.schedule();
+            }
+        }));
     }
     registerToolData(toolData) {
-        if (( this._tools.has(toolData.name))) {
-            throw ( new Error(`Tool "${toolData.name}" is already registered.`));
+        if (( this._tools.has(toolData.id))) {
+            throw ( new Error(`Tool "${toolData.id}" is already registered.`));
         }
-        this._tools.set(toolData.name, { data: toolData });
-        this._onDidChangeTools.fire({ added: toolData });
+        this._tools.set(toolData.id, { data: toolData });
+        this._onDidChangeToolsScheduler.schedule();
+        toolData.when?.keys().forEach(key => this._toolContextKeys.add(key));
         return toDisposable(() => {
-            this._tools.delete(toolData.name);
-            this._onDidChangeTools.fire({ removed: toolData.name });
+            this._tools.delete(toolData.id);
+            this._refreshAllToolContextKeys();
+            this._onDidChangeToolsScheduler.schedule();
         });
     }
+    _refreshAllToolContextKeys() {
+        this._toolContextKeys.clear();
+        for (const tool of ( this._tools.values())) {
+            tool.data.when?.keys().forEach(key => this._toolContextKeys.add(key));
+        }
+    }
     registerToolImplementation(name, tool) {
         const entry = this._tools.get(name);
         if (!entry) {
@@ -36,25 +55,47 @@ let LanguageModelToolsService = class LanguageModelToolsService {
         });
     }
     getTools() {
-        return ( Iterable.map(( this._tools.values()), i => i.data));
+        const toolDatas = ( Iterable.map(( this._tools.values()), i => i.data));
+        return Iterable.filter(toolDatas, toolData => !toolData.when || this._contextKeyService.contextMatchesRules(toolData.when));
+    }
+    getTool(id) {
+        return this._getToolEntry(id)?.data;
+    }
+    _getToolEntry(id) {
+        const entry = this._tools.get(id);
+        if (entry && (!entry.data.when || this._contextKeyService.contextMatchesRules(entry.data.when))) {
+            return entry;
+        }
+        else {
+            return undefined;
+        }
+    }
+    getToolByName(name) {
+        for (const toolData of this.getTools()) {
+            if (toolData.name === name) {
+                return toolData;
+            }
+        }
+        return undefined;
     }
-    async invokeTool(name, parameters, token) {
-        let tool = this._tools.get(name);
+    async invokeTool(dto, countTokens, token) {
+        let tool = this._tools.get(dto.toolId);
         if (!tool) {
-            throw ( new Error(`Tool ${name} was not contributed`));
+            throw ( new Error(`Tool ${dto.toolId} was not contributed`));
         }
         if (!tool.impl) {
-            await this._extensionService.activateByEvent(`onLanguageModelTool:${name}`);
-            tool = this._tools.get(name);
+            await this._extensionService.activateByEvent(`onLanguageModelTool:${dto.toolId}`);
+            tool = this._tools.get(dto.toolId);
             if (!tool?.impl) {
-                throw ( new Error(`Tool ${name} does not have an implementation registered.`));
+                throw ( new Error(`Tool ${dto.toolId} does not have an implementation registered.`));
             }
         }
-        return tool.impl.invoke(parameters, token);
+        return tool.impl.invoke(dto, countTokens, token);
     }
 };
 LanguageModelToolsService = ( __decorate([
-    ( __param(0, IExtensionService))
+    ( __param(0, IExtensionService)),
+    ( __param(1, IContextKeyService))
 ], LanguageModelToolsService));
 
 export { LanguageModelToolsService };

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

@@ -3,6 +3,7 @@ import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { localize } from 'vscode/vscode/vs/nls';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ILanguageModelToolsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
@@ -11,48 +12,62 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     extensionPoint: 'languageModelTools',
     activationEventsGenerator: (contributions, result) => {
         for (const contrib of contributions) {
-            result.push(`onLanguageModelTool:${contrib.name}`);
+            result.push(`onLanguageModelTool:${contrib.id}`);
         }
     },
     jsonSchema: {
-        description: ( localize(7168, 'Contributes a tool that can be invoked by a language model.')),
+        description: ( localize(7163, 'Contributes a tool that can be invoked by a language model.')),
         type: 'array',
         items: {
             additionalProperties: false,
             type: 'object',
             defaultSnippets: [{ body: { name: '', description: '' } }],
-            required: ['name', 'description'],
+            required: ['id', 'modelDescription'],
             properties: {
-                name: {
-                    description: ( localize(7169, "A name for this tool which must be unique across all tools.")),
-                    type: 'string'
+                id: {
+                    description: ( localize(7164, "A unique id for this tool.")),
+                    type: 'string',
+                    pattern: '^[\\w-]+$'
                 },
-                description: {
-                    description: ( localize(7170, "A description of this tool that may be passed to a language model.")),
-                    type: 'string'
+                name: {
+                    description: ( localize(
+                        7165,
+                        "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
+                        '`canBeInvokedManually`'
+                    )),
+                    type: 'string',
+                    pattern: '^[\\w-]+$'
                 },
                 displayName: {
                     description: ( localize(
-                        7171,
+                        7166,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: 'string'
                 },
+                userDescription: {
+                    description: ( localize(7167, "A description of this tool that may be shown to the user.")),
+                    type: 'string'
+                },
+                modelDescription: {
+                    description: ( localize(7168, "A description of this tool that may be passed to a language model.")),
+                    type: 'string'
+                },
                 parametersSchema: {
-                    description: ( localize(7172, "A JSON schema for the parameters this tool accepts.")),
+                    description: ( localize(7169, "A JSON schema for the parameters this tool accepts.")),
                     type: 'object',
                     $ref: 'http://json-schema.org/draft-07/schema#'
                 },
                 canBeInvokedManually: {
                     description: ( localize(
-                        7173,
+                        7170,
                         "Whether this tool can be invoked manually by the user through the chat UX."
                     )),
                     type: 'boolean'
                 },
                 icon: {
                     description: ( localize(
-                        7174,
+                        7171,
                         "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like `\\$(zap)`"
                     )),
                     anyOf: [{
@@ -62,15 +77,22 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                             type: 'object',
                             properties: {
                                 light: {
-                                    description: ( localize(7175, 'Icon path when a light theme is used')),
+                                    description: ( localize(7172, 'Icon path when a light theme is used')),
                                     type: 'string'
                                 },
                                 dark: {
-                                    description: ( localize(7176, 'Icon path when a dark theme is used')),
+                                    description: ( localize(7173, 'Icon path when a dark theme is used')),
                                     type: 'string'
                                 }
                             }
                         }]
+                },
+                when: {
+                    markdownDescription: ( localize(
+                        7174,
+                        "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
+                    )),
+                    type: 'string'
                 }
             }
         }
@@ -86,8 +108,16 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
         languageModelToolsExtensionPoint.setHandler((extensions, delta) => {
             for (const extension of delta.added) {
                 for (const rawTool of extension.value) {
-                    if (!rawTool.name || !rawTool.description) {
-                        logService.warn(`Invalid tool contribution from ${extension.description.identifier.value}: ${JSON.stringify(rawTool)}`);
+                    if (!rawTool.id || !rawTool.modelDescription) {
+                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool without name and modelDescription: ${JSON.stringify(rawTool)}`);
+                        continue;
+                    }
+                    if (!rawTool.id.match(/^[\w-]+$/)) {
+                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with invalid id: ${rawTool.id}. The id must match /^[\\w-]+$/.`);
+                        continue;
+                    }
+                    if (rawTool.canBeInvokedManually && !rawTool.name) {
+                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with 'canBeInvokedManually' set without a name: ${JSON.stringify(rawTool)}`);
                         continue;
                     }
                     const rawIcon = rawTool.icon;
@@ -106,15 +136,16 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                     }
                     const tool = {
                         ...rawTool,
-                        icon
+                        icon,
+                        when: rawTool.when ? ContextKeyExpr.deserialize(rawTool.when) : undefined,
                     };
                     const disposable = languageModelToolsService.registerToolData(tool);
-                    this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.name), disposable);
+                    this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.id), disposable);
                 }
             }
             for (const extension of delta.removed) {
                 for (const tool of extension.value) {
-                    this._registrationDisposables.deleteAndDispose(toToolKey(extension.description.identifier, tool.name));
+                    this._registrationDisposables.deleteAndDispose(toToolKey(extension.description.identifier, tool.id));
                 }
             }
         });

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

@@ -20,7 +20,7 @@ var PhraseTextType;
 const VoiceChatInProgress = ( (new RawContextKey(
     'voiceChatInProgress',
     false,
-    { type: 'boolean', description: ( localize(7155, "A speech-to-text session is in progress for chat.")) }
+    { type: 'boolean', description: ( localize(7175, "A speech-to-text session is in progress for chat.")) }
 )));
 let VoiceChatService = class VoiceChatService extends Disposable {
     static { VoiceChatService_1 = this; }

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChat.contribution.js

@@ -1,9 +1,8 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { registerEditorContribution, EditorContributionInstantiation } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { MenuRegistry, registerAction2, MenuId, isIMenuItem } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { registerAction2, MenuRegistry } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, DiscardHunkAction, DiscardAction, RerunAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, AcceptChanges, CopyRecordings } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
-import { INLINE_CHAT_ID, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_CONFIG_TXT_BTNS, MENU_INLINE_CHAT_CONTENT_STATUS, MENU_INLINE_CHAT_WIDGET_STATUS, InlineChatConfigKeys, MENU_INLINE_CHAT_EXECUTE } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, DiscardHunkAction, DiscardAction, RerunAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, AcceptChanges } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
+import { INLINE_CHAT_ID, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_EDITING, MENU_INLINE_CHAT_CONTENT_STATUS, MENU_INLINE_CHAT_WIDGET_STATUS } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
@@ -18,33 +17,49 @@ import { SubmitAction, CancelAction } from 'vscode/vscode/vs/workbench/contrib/c
 import { localize } from 'vscode/vscode/vs/nls';
 import { CONTEXT_CHAT_INPUT_HAS_TEXT } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { InlineChatAccessibilityHelp } from './inlineChatAccessibilityHelp.js';
+import { InlineChatExansionContextKey, InlineChatExpandLineAction } from './inlineChatCurrentLine.js';
 
 registerEditorContribution(INLINE_CHAT_ID, InlineChatController, EditorContributionInstantiation.Eager);
-const sendActionMenuItem = {
+registerEditorContribution(InlineChatExansionContextKey.Id, InlineChatExansionContextKey, EditorContributionInstantiation.BeforeFirstInteraction);
+registerAction2(InlineChatExpandLineAction);
+const editActionMenuItem = {
     group: '0_main',
     order: 0,
     command: {
         id: SubmitAction.ID,
-        title: ( localize(3072, "Send")),
+        title: ( localize(3076, "Edit Code")),
     },
     when: ( (ContextKeyExpr.and(
         CONTEXT_CHAT_INPUT_HAS_TEXT,
          (CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.toNegated()),
-        CTX_INLINE_CHAT_CONFIG_TXT_BTNS
+        CTX_INLINE_CHAT_EDITING
     ))),
 };
-MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_CONTENT_STATUS, sendActionMenuItem);
-MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_WIDGET_STATUS, sendActionMenuItem);
+const generateActionMenuItem = {
+    group: '0_main',
+    order: 0,
+    command: {
+        id: SubmitAction.ID,
+        title: ( localize(3077, "Generate")),
+    },
+    when: ( (ContextKeyExpr.and(
+        CONTEXT_CHAT_INPUT_HAS_TEXT,
+         (CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.toNegated()),
+         (CTX_INLINE_CHAT_EDITING.toNegated())
+    ))),
+};
+MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_CONTENT_STATUS, editActionMenuItem);
+MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_CONTENT_STATUS, generateActionMenuItem);
+MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_WIDGET_STATUS, editActionMenuItem);
+MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_WIDGET_STATUS, generateActionMenuItem);
 const cancelActionMenuItem = {
     group: '0_main',
     order: 0,
     command: {
         id: CancelAction.ID,
-        title: ( localize(3073, "Stop Request")),
-        shortTitle: ( localize(3074, "Stop")),
+        title: ( localize(3078, "Stop Request")),
+        shortTitle: ( localize(3079, "Stop")),
     },
     when: ( (ContextKeyExpr.and(CTX_INLINE_CHAT_REQUEST_IN_PROGRESS))),
 };
@@ -64,44 +79,8 @@ registerAction2(FocusInlineChat);
 registerAction2(ViewInChatAction);
 registerAction2(ToggleDiffForChange);
 registerAction2(AcceptChanges);
-registerAction2(CopyRecordings);
 const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
 workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatNotebookContribution, LifecyclePhase.Restored);
 registerWorkbenchContribution2(InlineChatEnabler.Id, InlineChatEnabler, WorkbenchPhase.AfterRestored);
 AccessibleViewRegistry.register(( (new InlineChatAccessibleView())));
 AccessibleViewRegistry.register(( (new InlineChatAccessibilityHelp())));
-let MenuCopier = class MenuCopier {
-    static { this.Id = 'inlineChat.menuCopier'; }
-    constructor(configService) {
-        const store = ( (new DisposableStore()));
-        function updateMenu() {
-            store.clear();
-            for (const item of MenuRegistry.getMenuItems(MenuId.ChatExecute)) {
-                if (configService.getValue(InlineChatConfigKeys.ExpTextButtons) && isIMenuItem(item) && (item.command.id === SubmitAction.ID || item.command.id === CancelAction.ID)) {
-                    continue;
-                }
-                store.add(MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_EXECUTE, item));
-            }
-        }
-        updateMenu();
-        const listener = MenuRegistry.onDidChangeMenu(e => {
-            if (( (e.has(MenuId.ChatExecute)))) {
-                updateMenu();
-            }
-        });
-        const listener2 = configService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(InlineChatConfigKeys.ExpTextButtons)) {
-                updateMenu();
-            }
-        });
-        this.dispose = () => {
-            listener.dispose();
-            listener2.dispose();
-            store.dispose();
-        };
-    }
-};
-MenuCopier = ( (__decorate([
-    ( (__param(0, IConfigurationService)))
-], MenuCopier)));
-registerWorkbenchContribution2(MenuCopier.Id, MenuCopier, WorkbenchPhase.AfterRestored);

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatCurrentLine.js

@@ -0,0 +1,130 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { CursorChangeReason } from 'vscode/vscode/vs/editor/common/cursorEvents';
+import { localize, localize2 } from 'vscode/vscode/vs/nls';
+import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { InlineChatController, State } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_HAS_AGENT } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { EditorAction2 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+import { AbstractInlineChatAction } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+
+const CTX_INLINE_CHAT_EXPANSION = ( (new RawContextKey('inlineChatExpansion', false, ( localize(
+    7200,
+    "Whether the inline chat expansion is enabled when at the end of a just-typed line"
+)))));
+let InlineChatExansionContextKey = class InlineChatExansionContextKey {
+    static { this.Id = 'editor.inlineChatExpansion'; }
+    constructor(editor, contextKeyService, chatAgentService) {
+        this._store = ( (new DisposableStore()));
+        this._editorListener = this._store.add(( (new MutableDisposable())));
+        this._ctxInlineChatExpansion = CTX_INLINE_CHAT_EXPANSION.bindTo(contextKeyService);
+        const update = () => {
+            if (editor.hasModel() && chatAgentService.getAgents().length > 0) {
+                this._install(editor);
+            }
+            else {
+                this._uninstall();
+            }
+        };
+        this._store.add(chatAgentService.onDidChangeAgents(update));
+        this._store.add(editor.onDidChangeModel(update));
+        update();
+    }
+    dispose() {
+        this._ctxInlineChatExpansion.reset();
+        this._store.dispose();
+    }
+    _install(editor) {
+        const store = ( (new DisposableStore()));
+        this._editorListener.value = store;
+        const model = editor.getModel();
+        const lastChangeEnds = [];
+        store.add(editor.onDidChangeCursorPosition(e => {
+            let enabled = false;
+            if (e.reason === CursorChangeReason.NotSet) {
+                const position = editor.getPosition();
+                const positionOffset = model.getOffsetAt(position);
+                const lineLength = model.getLineLength(position.lineNumber);
+                const firstNonWhitespace = model.getLineFirstNonWhitespaceColumn(position.lineNumber);
+                if (firstNonWhitespace !== 0 && position.column > lineLength && lastChangeEnds.includes(positionOffset)) {
+                    enabled = true;
+                }
+            }
+            lastChangeEnds.length = 0;
+            this._ctxInlineChatExpansion.set(enabled);
+        }));
+        store.add(editor.onDidChangeModelContent(e => {
+            lastChangeEnds.length = 0;
+            for (const change of e.changes) {
+                const changeEnd = change.rangeOffset + change.text.length;
+                lastChangeEnds.push(changeEnd);
+            }
+            queueMicrotask(() => {
+                if (lastChangeEnds.length > 0) {
+                    this._ctxInlineChatExpansion.set(false);
+                }
+            });
+        }));
+    }
+    _uninstall() {
+        this._editorListener.clear();
+    }
+};
+InlineChatExansionContextKey = ( (__decorate([
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, IChatAgentService)))
+], InlineChatExansionContextKey)));
+class InlineChatExpandLineAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlineChat.startWithCurrentLine',
+            category: AbstractInlineChatAction.category,
+            title: ( localize2(7201, "Start in Editor with Current Line")),
+            f1: true,
+            precondition: ( (ContextKeyExpr.and(
+                 (CTX_INLINE_CHAT_VISIBLE.negate()),
+                CTX_INLINE_CHAT_HAS_AGENT,
+                EditorContextKeys.writable
+            ))),
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        const ctrl = InlineChatController.get(editor);
+        if (!ctrl || !editor.hasModel()) {
+            return;
+        }
+        const model = editor.getModel();
+        const lineNumber = editor.getSelection().positionLineNumber;
+        const lineContent = model.getLineContent(lineNumber);
+        const startColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
+        const endColumn = model.getLineMaxColumn(lineNumber);
+        let undoEdits = [];
+        model.pushEditOperations(null, [EditOperation.replace(( (new Range(lineNumber, startColumn, lineNumber, endColumn))), '')], (edits) => {
+            undoEdits = edits;
+            return null;
+        });
+        let lastState;
+        const d = ctrl.onDidEnterState(e => lastState = e);
+        try {
+            await ctrl.run({
+                autoSend: true,
+                message: lineContent.trim(),
+                position: ( (new Position(lineNumber, startColumn)))
+            });
+        }
+        finally {
+            d.dispose();
+        }
+        if (lastState === State.CANCEL) {
+            model.pushEditOperations(null, undoEdits, () => null);
+        }
+    }
+}
+
+export { CTX_INLINE_CHAT_EXPANSION, InlineChatExansionContextKey, InlineChatExpandLineAction };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatNotebook.js

@@ -7,9 +7,12 @@ import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineC
 import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
 import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
 import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { NotebookTextDiffEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor';
+import { NotebookMultiTextDiffEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor';
 
 let InlineChatNotebookContribution = class InlineChatNotebookContribution {
-    constructor(sessionService, notebookEditorService) {
+    constructor(sessionService, editorService, notebookEditorService) {
         this._store = ( new DisposableStore());
         this._store.add(sessionService.registerSessionKeyComputer(Schemas.vscodeNotebookCell, {
             getComparisonKey: (editor, uri) => {
@@ -32,6 +35,10 @@ let InlineChatNotebookContribution = class InlineChatNotebookContribution {
                 if (fallback) {
                     return fallback;
                 }
+                const activeEditor = editorService.activeEditorPane;
+                if (activeEditor && (activeEditor.getId() === NotebookTextDiffEditor.ID || activeEditor.getId() === NotebookMultiTextDiffEditor.ID)) {
+                    return `<notebook>${editor.getId()}#${uri}`;
+                }
                 throw illegalState('Expected notebook editor');
             }
         }));
@@ -66,7 +73,8 @@ let InlineChatNotebookContribution = class InlineChatNotebookContribution {
 };
 InlineChatNotebookContribution = ( __decorate([
     ( __param(0, IInlineChatSessionService)),
-    ( __param(1, INotebookEditorService))
+    ( __param(1, IEditorService)),
+    ( __param(2, INotebookEditorService))
 ], InlineChatNotebookContribution));
 
 export { InlineChatNotebookContribution };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl.js

@@ -103,9 +103,9 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         }
         progress.report({
             message: sessions.size === 1
-                ? ( localize(3055, "Waiting for Inline Chat changes to be Accepted or Discarded..."))
+                ? ( localize(3058, "Waiting for Inline Chat changes to be Accepted or Discarded..."))
                 : ( localize(
-                3056,
+                3059,
                 "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
                 sessions.size
             ))