@codingame/monaco-vscode-chat-service-override 11.1.2 → 12.0.0

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

@@ -1,17 +1,19 @@
-import { InlineChatController } from '@codingame/monaco-vscode-chat-interactive-notebook-search-terminal-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED } from '@codingame/monaco-vscode-chat-interactive-notebook-search-terminal-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+
+import { InlineChatController } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { AccessibleContentProvider } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
+import { AccessibleViewType, AccessibleContentProvider, AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { renderMarkdownAsPlaintext } from 'vscode/vscode/vs/base/browser/markdownRenderer';
+import { AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 
 class InlineChatAccessibleView {
     constructor() {
         this.priority = 100;
         this.name = 'inlineChat';
         this.when = ( ContextKeyExpr.or(CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED));
-        this.type = "view" ;
+        this.type = AccessibleViewType.View;
     }
     getProvider(accessor) {
         const codeEditorService = accessor.get(ICodeEditorService);
@@ -28,11 +30,11 @@ class InlineChatAccessibleView {
             return;
         }
         return ( new AccessibleContentProvider(
-            "inlineChat" ,
-            { type: "view"  },
+            AccessibleViewProviderId.InlineChat,
+            { type: AccessibleViewType.View },
             () => renderMarkdownAsPlaintext(( new MarkdownString(responseContent)), true),
             () => controller.focus(),
-            "accessibility.verbosity.inlineChat"
+            AccessibilityVerbositySettingId.InlineChat
         ));
     }
 }

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatCurrentLine.d.ts

@@ -0,0 +1,44 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ICodeEditor } from "vscode/vscode/vs/editor/browser/editorBrowser";
+import { IEditorContribution } from "vscode/vscode/vs/editor/common/editorCommon";
+import { RawContextKey } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { EditorAction2, ServicesAccessor } from "vscode/vscode/vs/editor/browser/editorExtensions";
+import { IPosition } from "vscode/vscode/vs/editor/common/core/position";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IKeybindingService } from "vscode/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ICommandService } from "vscode/vscode/vs/platform/commands/common/commands.service";
+import { IChatAgentService } from "vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { IMarkerDecorationsService } from "vscode/vscode/vs/editor/common/services/markerDecorations";
+import { IContextMenuService } from "vscode/vscode/vs/platform/contextview/browser/contextView.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+export declare const CTX_INLINE_CHAT_SHOWING_HINT: RawContextKey<boolean>;
+export declare class InlineChatExpandLineAction extends EditorAction2 {
+    constructor();
+    runEditorCommand(_accessor: ServicesAccessor, editor: ICodeEditor): Promise<void>;
+}
+export declare class ShowInlineChatHintAction extends EditorAction2 {
+    constructor();
+    runEditorCommand(_accessor: ServicesAccessor, editor: ICodeEditor, ...args: [
+        uri: URI,
+        position: IPosition,
+        ...rest: any[]
+    ]): Promise<void>;
+}
+export declare class InlineChatHintsController extends Disposable implements IEditorContribution {
+    private readonly _contextMenuService;
+    private readonly _configurationService;
+    static readonly ID = "editor.contrib.inlineChatHints";
+    static get(editor: ICodeEditor): InlineChatHintsController | null;
+    private readonly _editor;
+    private readonly _ctxShowingHint;
+    private readonly _visibilityObs;
+    constructor(editor: ICodeEditor, contextKeyService: IContextKeyService, commandService: ICommandService, keybindingService: IKeybindingService, chatAgentService: IChatAgentService, markerDecorationService: IMarkerDecorationsService, _contextMenuService: IContextMenuService, _configurationService: IConfigurationService);
+    private _showContextMenu;
+    show(): void;
+    hide(): void;
+}
+export declare class HideInlineChatHintAction extends EditorAction2 {
+    constructor();
+    runEditorCommand(_accessor: ServicesAccessor, editor: ICodeEditor): Promise<void>;
+}

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

@@ -1,96 +1,65 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MouseTargetType } from 'vscode/vscode/vs/editor/browser/editorBrowser';
 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 } from '@codingame/monaco-vscode-chat-interactive-notebook-search-terminal-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_HAS_AGENT } from '@codingame/monaco-vscode-chat-interactive-notebook-search-terminal-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { InlineChatController, State } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_HAS_AGENT, ACTION_START, InlineChatConfigKeys } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/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 '@codingame/monaco-vscode-chat-notebook-terminal-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
+import { AbstractInlineChatAction } from '@codingame/monaco-vscode-4a36e358-d94d-55e0-86ee-3bcd543d9d3f-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
 import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { TrackedRangeStickiness } from 'vscode/vscode/vs/editor/common/model';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { StandardTokenType } from 'vscode/vscode/vs/editor/common/encodedTokenAttributes';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/arrays';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import 'vscode/vscode/vs/base/common/cancellation';
+import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { KeyMod, KeyCode, KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
+import { KeybindingWeight } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/browser/media/inlineChat.css';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { InlineCompletionsController } from 'vscode/vscode/vs/editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController';
+import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { IMarkerDecorationsService } from 'vscode/vscode/vs/editor/common/services/markerDecorations';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { toAction } from 'vscode/vscode/vs/base/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { observableCodeEditor } from 'vscode/vscode/vs/editor/browser/observableCodeEditor';
+import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { createStyleSheet2 } from 'vscode/vscode/vs/base/browser/domStylesheets';
+import { stringValue } from 'vscode/vscode/vs/base/browser/cssValue';
 
-const CTX_INLINE_CHAT_EXPANSION = ( (new RawContextKey('inlineChatExpansion', false, ( localize(
-    7698,
-    "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 === 0 ) {
-                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)));
+var InlineChatHintsController_1;
+const CTX_INLINE_CHAT_SHOWING_HINT = ( new RawContextKey('inlineChatShowingHint', false, ( localize(6767, "Whether inline chat shows a contextual hint"))));
+const _inlineChatActionId = 'inlineChat.startWithCurrentLine';
 class InlineChatExpandLineAction extends EditorAction2 {
     constructor() {
         super({
-            id: 'inlineChat.startWithCurrentLine',
+            id: _inlineChatActionId,
             category: AbstractInlineChatAction.category,
-            title: ( localize2(7699, "Start in Editor with Current Line")),
+            title: ( localize2(6768, "Start in Editor with Current Line")),
             f1: true,
-            precondition: ( (ContextKeyExpr.and(
-                 (CTX_INLINE_CHAT_VISIBLE.negate()),
-                CTX_INLINE_CHAT_HAS_AGENT,
-                EditorContextKeys.writable
-            ))),
+            precondition: ( ContextKeyExpr.and(( CTX_INLINE_CHAT_VISIBLE.negate()), CTX_INLINE_CHAT_HAS_AGENT, EditorContextKeys.writable)),
+            keybinding: [{
+                    when: CTX_INLINE_CHAT_SHOWING_HINT,
+                    weight: KeybindingWeight.WorkbenchContrib + 1,
+                    primary: KeyMod.CtrlCmd | KeyCode.KeyI
+                }, {
+                    weight: KeybindingWeight.WorkbenchContrib,
+                    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyI),
+                }]
         });
     }
     async runEditorCommand(_accessor, editor) {
@@ -104,7 +73,7 @@ class InlineChatExpandLineAction extends EditorAction2 {
         const startColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
         const endColumn = model.getLineMaxColumn(lineNumber);
         let undoEdits = [];
-        model.pushEditOperations(null, [EditOperation.replace(( (new Range(lineNumber, startColumn, lineNumber, endColumn))), '')], (edits) => {
+        model.pushEditOperations(null, [EditOperation.replace(( new Range(lineNumber, startColumn, lineNumber, endColumn)), '')], (edits) => {
             undoEdits = edits;
             return null;
         });
@@ -114,16 +83,211 @@ class InlineChatExpandLineAction extends EditorAction2 {
             await ctrl.run({
                 autoSend: true,
                 message: lineContent.trim(),
-                position: ( (new Position(lineNumber, startColumn)))
+                position: ( new Position(lineNumber, startColumn))
             });
         }
         finally {
             d.dispose();
         }
-        if (lastState === "CANCEL" ) {
+        if (lastState === State.CANCEL) {
             model.pushEditOperations(null, undoEdits, () => null);
         }
     }
 }
+class ShowInlineChatHintAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlineChat.showHint',
+            category: AbstractInlineChatAction.category,
+            title: ( localize2(6769, "Show Inline Chat Hint")),
+            f1: false,
+            precondition: ( ContextKeyExpr.and(( CTX_INLINE_CHAT_VISIBLE.negate()), CTX_INLINE_CHAT_HAS_AGENT, EditorContextKeys.writable)),
+        });
+    }
+    async runEditorCommand(_accessor, editor, ...args) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const ctrl = InlineChatHintsController.get(editor);
+        if (!ctrl) {
+            return;
+        }
+        const [uri, position] = args;
+        if (!URI.isUri(uri) || !Position.isIPosition(position)) {
+            ctrl.hide();
+            return;
+        }
+        const model = editor.getModel();
+        if (!isEqual(model.uri, uri)) {
+            ctrl.hide();
+            return;
+        }
+        model.tokenization.forceTokenization(position.lineNumber);
+        const tokens = model.tokenization.getLineTokens(position.lineNumber);
+        const tokenIndex = tokens.findTokenIndexAtOffset(position.column - 1);
+        const tokenType = tokens.getStandardTokenType(tokenIndex);
+        if (tokenType === StandardTokenType.Comment) {
+            ctrl.hide();
+        }
+        else {
+            ctrl.show();
+        }
+    }
+}
+let InlineChatHintsController = class InlineChatHintsController extends Disposable {
+    static { InlineChatHintsController_1 = this; }
+    static { this.ID = 'editor.contrib.inlineChatHints'; }
+    static get(editor) {
+        return editor.getContribution(InlineChatHintsController_1.ID);
+    }
+    constructor(editor, contextKeyService, commandService, keybindingService, chatAgentService, markerDecorationService, _contextMenuService, _configurationService) {
+        super();
+        this._contextMenuService = _contextMenuService;
+        this._configurationService = _configurationService;
+        this._visibilityObs = observableValue(this, false);
+        this._editor = editor;
+        this._ctxShowingHint = CTX_INLINE_CHAT_SHOWING_HINT.bindTo(contextKeyService);
+        const ghostCtrl = InlineCompletionsController.get(editor);
+        this._store.add(commandService.onWillExecuteCommand(e => {
+            if (e.commandId === _inlineChatActionId || e.commandId === ACTION_START) {
+                this.hide();
+            }
+        }));
+        this._store.add(this._editor.onMouseDown(e => {
+            if (e.target.type !== MouseTargetType.CONTENT_TEXT) {
+                return;
+            }
+            if (!e.target.element?.classList.contains('inline-chat-hint-text')) {
+                return;
+            }
+            if (e.event.leftButton) {
+                commandService.executeCommand(_inlineChatActionId);
+                this.hide();
+            }
+            else if (e.event.rightButton) {
+                e.event.preventDefault();
+                this._showContextMenu(e.event, e.target.element?.classList.contains('whitespace')
+                    ? InlineChatConfigKeys.LineEmptyHint
+                    : InlineChatConfigKeys.LineNLHint);
+            }
+        }));
+        const markerSuppression = this._store.add(( new MutableDisposable()));
+        const decos = this._editor.createDecorationsCollection();
+        const editorObs = observableCodeEditor(editor);
+        const keyObs = observableFromEvent(keybindingService.onDidUpdateKeybindings, _ => keybindingService.lookupKeybinding(ACTION_START)?.getLabel());
+        const configSignal = observableFromEvent(Event.filter(_configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(InlineChatConfigKeys.LineEmptyHint) || e.affectsConfiguration(InlineChatConfigKeys.LineNLHint)), () => undefined);
+        const showDataObs = derived(r => {
+            const ghostState = ghostCtrl?.model.read(r)?.state.read(r);
+            const textFocus = editorObs.isTextFocused.read(r);
+            const position = editorObs.cursorPosition.read(r);
+            const model = editorObs.model.read(r);
+            const kb = keyObs.read(r);
+            configSignal.read(r);
+            if (ghostState !== undefined || !kb || !position || !model || !textFocus) {
+                return undefined;
+            }
+            if (model.getLanguageId() === PLAINTEXT_LANGUAGE_ID || model.getLanguageId() === 'markdown') {
+                return undefined;
+            }
+            const visible = this._visibilityObs.read(r);
+            const isEol = model.getLineMaxColumn(position.lineNumber) === position.column;
+            const isWhitespace = model.getLineLastNonWhitespaceColumn(position.lineNumber) === 0 && model.getValueLength() > 0 && position.column > 1;
+            if (isWhitespace) {
+                return _configurationService.getValue(InlineChatConfigKeys.LineEmptyHint)
+                    ? { isEol, isWhitespace, kb, position, model }
+                    : undefined;
+            }
+            if (visible && isEol && _configurationService.getValue(InlineChatConfigKeys.LineNLHint)) {
+                return { isEol, isWhitespace, kb, position, model };
+            }
+            return undefined;
+        });
+        const style = createStyleSheet2();
+        this._store.add(style);
+        this._store.add(autorun(r => {
+            const showData = showDataObs.read(r);
+            if (!showData) {
+                decos.clear();
+                markerSuppression.clear();
+                this._ctxShowingHint.reset();
+                return;
+            }
+            const agentName = chatAgentService.getDefaultAgent(ChatAgentLocation.Editor)?.name ?? ( localize(6770, "Chat"));
+            const { position, isEol, isWhitespace, kb, model } = showData;
+            const inlineClassName = ['a' , 'inline-chat-hint', 'inline-chat-hint-text'];
+            let content;
+            if (isWhitespace) {
+                content = '\u00a0' + ( localize(6771, "{0} to edit with {1}", kb, agentName));
+            }
+            else if (isEol) {
+                content = '\u00a0' + ( localize(6772, "{0} to continue with {1}", kb, agentName));
+            }
+            else {
+                content = '\u200a' + kb + '\u200a';
+                inlineClassName.push('embedded');
+            }
+            style.setStyle(`.inline-chat-hint-text::after { content: ${stringValue(content)} }`);
+            if (isWhitespace) {
+                inlineClassName.push('whitespace');
+            }
+            this._ctxShowingHint.set(true);
+            decos.set([{
+                    range: Range.fromPositions(position),
+                    options: {
+                        description: 'inline-chat-hint-line',
+                        showIfCollapsed: true,
+                        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+                        afterContentClassName: inlineClassName.join(' '),
+                    }
+                }]);
+            markerSuppression.value = markerDecorationService.addMarkerSuppression(model.uri, model.validateRange(( new Range(position.lineNumber, 1, position.lineNumber, Number.MAX_SAFE_INTEGER))));
+        }));
+    }
+    _showContextMenu(event, setting) {
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => ({ x: event.posx, y: event.posy }),
+            getActions: () => [
+                toAction({
+                    id: 'inlineChat.disableHint',
+                    label: ( localize(6773, "Disable Inline Chat Hint")),
+                    run: async () => {
+                        await this._configurationService.updateValue(setting, false);
+                    }
+                })
+            ]
+        });
+    }
+    show() {
+        this._visibilityObs.set(true, undefined);
+    }
+    hide() {
+        this._visibilityObs.set(false, undefined);
+    }
+};
+InlineChatHintsController = InlineChatHintsController_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IChatAgentService)),
+    ( __param(5, IMarkerDecorationsService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IConfigurationService))
+], InlineChatHintsController));
+class HideInlineChatHintAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlineChat.hideHint',
+            title: ( localize2(6774, "Hide Inline Chat Hint")),
+            precondition: CTX_INLINE_CHAT_SHOWING_HINT,
+            keybinding: {
+                weight: KeybindingWeight.EditorContrib - 10,
+                primary: KeyCode.Escape
+            }
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        InlineChatHintsController.get(editor)?.hide();
+    }
+}
 
-export { CTX_INLINE_CHAT_EXPANSION, InlineChatExansionContextKey, InlineChatExpandLineAction };
+export { CTX_INLINE_CHAT_SHOWING_HINT, HideInlineChatHintAction, InlineChatExpandLineAction, InlineChatHintsController, ShowInlineChatHintAction };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatNotebook.d.ts

@@ -0,0 +1,8 @@
+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 { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+export declare class InlineChatNotebookContribution {
+    private readonly _store;
+    constructor(sessionService: IInlineChatSessionService, editorService: IEditorService, notebookEditorService: INotebookEditorService);
+    dispose(): void;
+}

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

@@ -1,15 +1,16 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { illegalState } from 'vscode/vscode/vs/base/common/errors';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { InlineChatController } from '@codingame/monaco-vscode-chat-interactive-notebook-search-terminal-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { InlineChatController } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 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 '@codingame/monaco-vscode-chat-notebook-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor';
-import { NotebookMultiTextDiffEditor } from '@codingame/monaco-vscode-chat-notebook-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor';
+import { NotebookTextDiffEditor } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor';
+import { NotebookMultiTextDiffEditor } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor';
 
 let InlineChatNotebookContribution = class InlineChatNotebookContribution {
     constructor(sessionService, editorService, notebookEditorService) {

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl.d.ts

@@ -0,0 +1,29 @@
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { Session } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession";
+import { IInlineChatSessionService } from "vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
+import { IEditorGroupsService } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IFilesConfigurationService } from "vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { ITextFileService } from "vscode/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { IInlineChatSavingService } from "vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSavingService.service";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+export declare class InlineChatSavingServiceImpl implements IInlineChatSavingService {
+    private readonly _fileConfigService;
+    private readonly _editorGroupService;
+    private readonly _textFileService;
+    private readonly _configService;
+    private readonly _workingCopyFileService;
+    private readonly _dialogService;
+    private readonly _labelService;
+    readonly _serviceBrand: undefined;
+    private readonly _store;
+    private readonly _saveParticipant;
+    private readonly _sessionData;
+    constructor(_fileConfigService: IFilesConfigurationService, _editorGroupService: IEditorGroupsService, _textFileService: ITextFileService, _inlineChatSessionService: IInlineChatSessionService, _configService: IConfigurationService, _workingCopyFileService: IWorkingCopyFileService, _dialogService: IDialogService, _labelService: ILabelService);
+    dispose(): void;
+    markChanged(session: Session): void;
+    private _installSaveParticpant;
+    private _participate;
+    private _isDisabled;
+}