@codingame/monaco-vscode-katex-common 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/common/widget/annotations.d.ts

@@ -3,6 +3,12 @@ import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/cor
 import { IChatProgressRenderableResponseContent, IChatProgressResponseContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 export declare const contentRefUrl = "http://_vscodecontentref_";
 export declare function annotateSpecialMarkdownContent(response: Iterable<IChatProgressResponseContent>): IChatProgressRenderableResponseContent[];
+/**
+ * Checks whether the end of a markdown string is inside a code context
+ * (fenced code block or inline code span) where markdown link syntax
+ * would be rendered as literal text.
+ */
+export declare function isInsideCodeContext(text: string): boolean;
 export interface IMarkdownVulnerability {
     readonly title: string;
     readonly description: string;
@@ -16,6 +22,7 @@ export declare function extractCodeblockUrisFromText(text: string): {
 } | undefined;
 export declare function extractSubAgentInvocationIdFromText(text: string): string | undefined;
 export declare function hasCodeblockUriTag(text: string): boolean;
+export declare function hasEditCodeblockUriTag(text: string): boolean;
 export declare function extractVulnerabilitiesFromText(text: string): {
     newText: string;
     vulnerabilities: IMarkdownVulnerability[];

package/vscode/src/vs/workbench/contrib/chat/common/widget/annotations.js

@@ -1,5 +1,4 @@
 
-import { findLastIdx } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -11,7 +10,7 @@ function annotateSpecialMarkdownContent(response) {
     let refIdPool = 0;
     const result = [];
     for (const item of response) {
-        const previousItemIndex = findLastIdx(result, p => p.kind !== "textEditGroup" && p.kind !== "undoStop");
+        const previousItemIndex = result.findLastIndex(p => p.kind !== "textEditGroup" && p.kind !== "undoStop");
         const previousItem = result[previousItemIndex];
         if (item.kind === "inlineReference") {
             let label = item.name;
@@ -24,30 +23,46 @@ function annotateSpecialMarkdownContent(response) {
                     label = item.inlineReference.name;
                 }
             }
-            const refId = refIdPool++;
-            const printUri = ( URI.parse(contentRefUrl)).with({
-                path: String(refId)
-            });
-            const markdownText = `[${label}](${( printUri.toString())})`;
-            const annotationMetadata = {
-                [refId]: item
-            };
-            if (previousItem?.kind === "markdownContent") {
-                const merged = appendMarkdownString(previousItem.content, ( new MarkdownString(markdownText)));
-                result[previousItemIndex] = {
-                    ...previousItem,
-                    content: merged,
-                    inlineReferences: {
-                        ...annotationMetadata,
-                        ...(previousItem.inlineReferences || {})
-                    }
-                };
+            const previousText = previousItem?.kind === "markdownContent" ? previousItem.content.value : "";
+            if (isInsideCodeContext(previousText)) {
+                if (previousItem?.kind === "markdownContent") {
+                    const merged = appendMarkdownString(previousItem.content, ( new MarkdownString(label)));
+                    result[previousItemIndex] = {
+                        ...previousItem,
+                        content: merged
+                    };
+                } else {
+                    result.push({
+                        content: ( new MarkdownString(label)),
+                        kind: "markdownContent"
+                    });
+                }
             } else {
-                result.push({
-                    content: ( new MarkdownString(markdownText)),
-                    inlineReferences: annotationMetadata,
-                    kind: "markdownContent"
+                const refId = refIdPool++;
+                const printUri = ( URI.parse(contentRefUrl)).with({
+                    path: String(refId)
                 });
+                const markdownText = `[${label}](${( printUri.toString())})`;
+                const annotationMetadata = {
+                    [refId]: item
+                };
+                if (previousItem?.kind === "markdownContent") {
+                    const merged = appendMarkdownString(previousItem.content, ( new MarkdownString(markdownText)));
+                    result[previousItemIndex] = {
+                        ...previousItem,
+                        content: merged,
+                        inlineReferences: {
+                            ...annotationMetadata,
+                            ...(previousItem.inlineReferences || {})
+                        }
+                    };
+                } else {
+                    result.push({
+                        content: ( new MarkdownString(markdownText)),
+                        inlineReferences: annotationMetadata,
+                        kind: "markdownContent"
+                    });
+                }
             }
         } else if (item.kind === "markdownContent" && previousItem?.kind === "markdownContent" && canMergeMarkdownStrings(previousItem.content, item.content)) {
             const merged = appendMarkdownString(previousItem.content, item.content);
@@ -88,6 +103,72 @@ function annotateSpecialMarkdownContent(response) {
     }
     return result;
 }
+function isInsideCodeContext(text) {
+    const lines = text.split("\n");
+    let inFencedBlock = false;
+    let fenceChar = "";
+    let fenceLength = 0;
+    const unfencedLines = [];
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (inFencedBlock) {
+            const closeLength = countLeadingChar(trimmed, fenceChar);
+            if (closeLength >= fenceLength && trimmed.substring(closeLength).trim() === "") {
+                inFencedBlock = false;
+                unfencedLines.length = 0;
+            }
+            continue;
+        }
+        const firstChar = trimmed[0];
+        if (firstChar === "`" || firstChar === "~") {
+            const openLength = countLeadingChar(trimmed, firstChar);
+            if (openLength >= 3 && (firstChar === "~" || !trimmed.substring(openLength).includes("`"))) {
+                inFencedBlock = true;
+                fenceChar = firstChar;
+                fenceLength = openLength;
+                unfencedLines.length = 0;
+                continue;
+            }
+        }
+        unfencedLines.push(line);
+    }
+    return inFencedBlock || hasUnclosedInlineCode(unfencedLines.join("\n"));
+}
+function countLeadingChar(text, char) {
+    let count = 0;
+    while (count < text.length && text[count] === char) {
+        count++;
+    }
+    return count;
+}
+function hasUnclosedInlineCode(text) {
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== "`") {
+            i++;
+            continue;
+        }
+        const openLen = countLeadingChar(text.substring(i), "`");
+        i += openLen;
+        let found = false;
+        while (i < text.length) {
+            if (text[i] !== "`") {
+                i++;
+                continue;
+            }
+            const closeLen = countLeadingChar(text.substring(i), "`");
+            i += closeLen;
+            if (closeLen === openLen) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            return true;
+        }
+    }
+    return false;
+}
 function extractCodeblockUrisFromText(text) {
     const match = /<vscode_codeblock_uri( isEdit)?( subAgentInvocationId="([^"]*)")?>([\s\S]*?)<\/vscode_codeblock_uri>/ms.exec(text);
     if (match) {
@@ -124,8 +205,8 @@ function extractSubAgentInvocationIdFromText(text) {
     }
     return undefined;
 }
-function hasCodeblockUriTag(text) {
-    return text.includes("<vscode_codeblock_uri");
+function hasEditCodeblockUriTag(text) {
+    return text.includes("<vscode_codeblock_uri isEdit");
 }
 function extractVulnerabilitiesFromText(text) {
     const vulnerabilities = [];
@@ -167,4 +248,4 @@ function extractVulnerabilitiesFromText(text) {
     };
 }
 
-export { annotateSpecialMarkdownContent, contentRefUrl, extractCodeblockUrisFromText, extractSubAgentInvocationIdFromText, extractVulnerabilitiesFromText, hasCodeblockUriTag };
+export { annotateSpecialMarkdownContent, contentRefUrl, extractCodeblockUrisFromText, extractSubAgentInvocationIdFromText, extractVulnerabilitiesFromText, hasEditCodeblockUriTag, isInsideCodeContext };

package/vscode/src/vs/workbench/contrib/chat/common/widget/chatColors.d.ts

@@ -1,3 +1,4 @@
+export declare const agentStatusIndicatorBackground: string;
 export declare const chatRequestBorder: string;
 export declare const chatRequestBackground: string;
 export declare const chatSlashCommandBackground: string;

package/vscode/src/vs/workbench/contrib/chat/common/widget/chatColors.js

@@ -13,44 +13,50 @@ import { badgeBackground, badgeForeground } from '@codingame/monaco-vscode-api/v
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
 
+registerColor("agentStatusIndicator.background", {
+    dark: ( Color.white.transparent(0.05)),
+    light: ( Color.black.transparent(0.05)),
+    hcDark: null,
+    hcLight: null
+}, ( localize(7222, "Background color of the agent status indicator in the titlebar.")));
 registerColor("chat.requestBorder", {
     dark: ( new Color(( new RGBA(255, 255, 255, 0.10)))),
     light: ( new Color(( new RGBA(0, 0, 0, 0.10)))),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(6616, "The border color of a chat request.")));
+}, ( localize(7223, "The border color of a chat request.")));
 const chatRequestBackground = registerColor("chat.requestBackground", {
     dark: ( transparent(editorBackground, 0.62)),
     light: ( transparent(editorBackground, 0.62)),
     hcDark: editorWidgetBackground,
     hcLight: null
-}, ( localize(6617, "The background color of a chat request.")));
+}, ( localize(7224, "The background color of a chat request.")));
 const chatSlashCommandBackground = registerColor("chat.slashCommandBackground", {
     dark: "#26477866",
     light: "#adceff7a",
     hcDark: Color.white,
     hcLight: badgeBackground
-}, ( localize(6618, "The background color of a chat slash command.")));
+}, ( localize(7225, "The background color of a chat slash command.")));
 const chatSlashCommandForeground = registerColor("chat.slashCommandForeground", {
     dark: "#85b6ff",
     light: "#26569e",
     hcDark: Color.black,
     hcLight: badgeForeground
-}, ( localize(6619, "The foreground color of a chat slash command.")));
+}, ( localize(7226, "The foreground color of a chat slash command.")));
 registerColor("chat.avatarBackground", {
     dark: "#1f1f1f",
     light: "#f2f2f2",
     hcDark: Color.black,
     hcLight: Color.white
-}, ( localize(6620, "The background color of a chat avatar.")));
-registerColor("chat.avatarForeground", foreground, ( localize(6621, "The foreground color of a chat avatar.")));
+}, ( localize(7227, "The background color of a chat avatar.")));
+registerColor("chat.avatarForeground", foreground, ( localize(7228, "The foreground color of a chat avatar.")));
 registerColor("chat.editedFileForeground", {
     light: "#895503",
     dark: "#E2C08D",
     hcDark: "#E2C08D",
     hcLight: "#895503"
 }, ( localize(
-    6622,
+    7229,
     "The foreground color of a chat edited file in the edited file list."
 )));
 registerColor("chat.requestCodeBorder", {
@@ -58,42 +64,42 @@ registerColor("chat.requestCodeBorder", {
     light: "#0e639c40",
     hcDark: null,
     hcLight: null
-}, ( localize(6623, "Border color of code blocks within the chat request bubble.")), true);
+}, ( localize(7230, "Border color of code blocks within the chat request bubble.")), true);
 registerColor("chat.requestBubbleBackground", {
     light: ( transparent(editorSelectionBackground, 0.3)),
     dark: ( transparent(editorSelectionBackground, 0.3)),
     hcDark: null,
     hcLight: null
-}, ( localize(6624, "Background color of the chat request bubble.")), true);
+}, ( localize(7231, "Background color of the chat request bubble.")), true);
 registerColor("chat.requestBubbleHoverBackground", {
     dark: ( transparent(editorSelectionBackground, 0.6)),
     light: ( transparent(editorSelectionBackground, 0.6)),
     hcDark: null,
     hcLight: null
-}, ( localize(6625, "Background color of the chat request bubble on hover.")), true);
+}, ( localize(7232, "Background color of the chat request bubble on hover.")), true);
 registerColor("chat.checkpointSeparator", {
     dark: "#585858",
     light: "#a9a9a9",
     hcDark: "#a9a9a9",
     hcLight: "#a5a5a5"
-}, ( localize(6626, "Chat checkpoint separator color.")));
+}, ( localize(7233, "Chat checkpoint separator color.")));
 registerColor("chat.linesAddedForeground", {
     dark: "#54B054",
     light: "#107C10",
     hcDark: "#54B054",
     hcLight: "#107C10"
-}, ( localize(6627, "Foreground color of lines added in chat code block pill.")), true);
+}, ( localize(7234, "Foreground color of lines added in chat code block pill.")), true);
 registerColor("chat.linesRemovedForeground", {
     dark: "#FC6A6A",
     light: "#BC2F32",
     hcDark: "#F48771",
     hcLight: "#B5200D"
-}, ( localize(6628, "Foreground color of lines removed in chat code block pill.")), true);
+}, ( localize(7235, "Foreground color of lines removed in chat code block pill.")), true);
 registerColor("chat.thinkingShimmer", {
     dark: "#ffffff",
     light: "#000000",
     hcDark: "#ffffff",
     hcLight: "#000000"
-}, ( localize(6629, "Shimmer highlight for thinking/working labels.")), true);
+}, ( localize(7236, "Shimmer highlight for thinking/working labels.")), true);
 
 export { chatRequestBackground, chatSlashCommandBackground, chatSlashCommandForeground };

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

@@ -5,11 +5,9 @@ import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
 import { InlineChatInputWidget } from "./inlineChatOverlayWidget.js";
 import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 export declare class InlineChatAffordance extends Disposable {
-    private readonly _editor;
-    private readonly _inputWidget;
-    private readonly _instantiationService;
-    private _menuData;
-    constructor(_editor: ICodeEditor, _inputWidget: InlineChatInputWidget, _instantiationService: IInstantiationService, configurationService: IConfigurationService, chatEntiteldService: IChatEntitlementService, inlineChatSessionService: IInlineChatSessionService);
-    showMenuAtSelection(): Promise<void>;
+    #private;
+    constructor(editor: ICodeEditor, inputWidget: InlineChatInputWidget, instantiationService: IInstantiationService, configurationService: IConfigurationService, chatEntiteldService: IChatEntitlementService, inlineChatSessionService: IInlineChatSessionService, telemetryService: ITelemetryService);
+    showMenuAtSelection(placeholder: string): Promise<void>;
 }

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

@@ -15,6 +15,10 @@ import { SelectionDirection } from '@codingame/monaco-vscode-api/vscode/vs/edito
 import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { CursorChangeReason } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/cursorEvents';
 import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
+import { CodeActionController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/codeAction/browser/codeActionController';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { debouncedObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
 import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
@@ -24,24 +28,29 @@ import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/v
 import { waitForState } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utilsCancellation';
 
 let InlineChatAffordance = class InlineChatAffordance extends Disposable {
+    #editor;
+    #inputWidget;
+    #instantiationService;
+    #menuData = observableValue(this, undefined);
     constructor(
-        _editor,
-        _inputWidget,
-        _instantiationService,
+        editor,
+        inputWidget,
+        instantiationService,
         configurationService,
         chatEntiteldService,
-        inlineChatSessionService
+        inlineChatSessionService,
+        telemetryService
     ) {
         super();
-        this._editor = _editor;
-        this._inputWidget = _inputWidget;
-        this._instantiationService = _instantiationService;
-        this._menuData = observableValue(this, undefined);
-        const editorObs = observableCodeEditor(this._editor);
+        this.#editor = editor;
+        this.#inputWidget = inputWidget;
+        this.#instantiationService = instantiationService;
+        const editorObs = observableCodeEditor(this.#editor);
         const affordance = observableConfigValue(InlineChatConfigKeys.Affordance, "off", configurationService);
         const debouncedSelection = debouncedObservable(editorObs.cursorSelection, 500);
         const selectionData = observableValue(this, undefined);
         let explicitSelection = false;
+        let affordanceId;
         this._store.add(runOnChange(editorObs.selections, (value, _prev, events) => {
             explicitSelection = events.every(e => e.reason === CursorChangeReason.Explicit);
             if (!value || value.length !== 1 || value[0].isEmpty() || !explicitSelection) {
@@ -50,10 +59,20 @@ let InlineChatAffordance = class InlineChatAffordance extends Disposable {
         }));
         this._store.add(autorun(r => {
             const value = debouncedSelection.read(r);
-            if (!value || value.isEmpty() || !explicitSelection || _editor.getModel()?.getValueInRange(value).match(/^\s+$/)) {
+            if (!value || value.isEmpty() || !explicitSelection || this.#editor.getModel()?.getValueInRange(value).match(/^\s+$/)) {
                 selectionData.set(undefined, undefined);
+                affordanceId = undefined;
                 return;
             }
+            affordanceId = generateUuid();
+            const mode = affordance.read(undefined);
+            if (mode === "gutter" || mode === "editor") {
+                telemetryService.publicLog2("inlineChatAffordance/shown", {
+                    mode,
+                    id: affordanceId,
+                    commandId: ""
+                });
+            }
             selectionData.set(value, undefined);
         }));
         this._store.add(autorun(r => {
@@ -71,52 +90,75 @@ let InlineChatAffordance = class InlineChatAffordance extends Disposable {
                 selectionData.set(undefined, undefined);
             }
         }));
-        this._store.add(this._instantiationService.createInstance(
+        this._store.add(this.#editor.onContextMenu(() => {
+            selectionData.set(undefined, undefined);
+        }));
+        const gutterAffordance = this._store.add(this.#instantiationService.createInstance(
             InlineChatGutterAffordance,
             editorObs,
-            derived(r => affordance.read(r) === "gutter" ? selectionData.read(r) : undefined),
-            this._menuData
+            derived(r => affordance.read(r) === "gutter" ? selectionData.read(r) : undefined)
         ));
-        this._store.add(this._instantiationService.createInstance(
+        const editorAffordance = this.#instantiationService.createInstance(
             InlineChatEditorAffordance,
-            this._editor,
+            this.#editor,
             derived(r => affordance.read(r) === "editor" ? selectionData.read(r) : undefined)
-        ));
+        );
+        this._store.add(editorAffordance);
+        this._store.add(
+            Event.any(editorAffordance.onDidRunAction, gutterAffordance.onDidRunAction)(commandId => {
+                if (affordanceId) {
+                    telemetryService.publicLog2("inlineChatAffordance/selected", {
+                        mode: affordance.get(),
+                        id: affordanceId,
+                        commandId
+                    });
+                }
+            })
+        );
+        this._store.add(autorun(r => {
+            const mode = affordance.read(r);
+            const hideWithSelection = mode === "editor" || mode === "gutter";
+            const controller = CodeActionController.get(this.#editor);
+            if (controller) {
+                controller.onlyLightBulbWithEmptySelection = hideWithSelection;
+            }
+        }));
         this._store.add(autorun(r => {
-            const data = this._menuData.read(r);
+            const data = this.#menuData.read(r);
             if (!data) {
                 return;
             }
-            this._editor.revealLineInCenterIfOutsideViewport(data.lineNumber, ScrollType.Immediate);
-            const editorDomNode = this._editor.getDomNode();
+            this.#editor.revealLineInCenterIfOutsideViewport(data.lineNumber, ScrollType.Immediate);
+            const editorDomNode = this.#editor.getDomNode();
             const editorRect = editorDomNode.getBoundingClientRect();
             const left = data.rect.left - editorRect.left;
-            this._inputWidget.show(data.lineNumber, left, data.above);
+            this.#inputWidget.show(data.lineNumber, left, data.above, data.placeholder);
         }));
         this._store.add(autorun(r => {
-            const pos = this._inputWidget.position.read(r);
+            const pos = this.#inputWidget.position.read(r);
             if (pos === null) {
-                this._menuData.set(undefined, undefined);
+                this.#menuData.set(undefined, undefined);
             }
         }));
     }
-    async showMenuAtSelection() {
-        assertType(this._editor.hasModel());
-        const direction = this._editor.getSelection().getDirection();
-        const position = this._editor.getPosition();
-        const editorDomNode = this._editor.getDomNode();
-        const scrolledPosition = this._editor.getScrolledVisiblePosition(position);
+    async showMenuAtSelection(placeholder) {
+        assertType(this.#editor.hasModel());
+        const direction = this.#editor.getSelection().getDirection();
+        const position = this.#editor.getPosition();
+        const editorDomNode = this.#editor.getDomNode();
+        const scrolledPosition = this.#editor.getScrolledVisiblePosition(position);
         const editorRect = editorDomNode.getBoundingClientRect();
         const x = editorRect.left + scrolledPosition.left;
         const y = editorRect.top + scrolledPosition.top;
-        this._menuData.set({
+        this.#menuData.set({
             rect: ( new DOMRect(x, y, 0, scrolledPosition.height)),
             above: direction === SelectionDirection.RTL,
-            lineNumber: position.lineNumber
+            lineNumber: position.lineNumber,
+            placeholder
         }, undefined);
-        await waitForState(this._inputWidget.position, pos => pos === null);
+        await waitForState(this.#inputWidget.position, pos => pos === null);
     }
 };
-InlineChatAffordance = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IConfigurationService)), ( __param(4, IChatEntitlementService)), ( __param(5, IInlineChatSessionService))], InlineChatAffordance));
+InlineChatAffordance = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IConfigurationService)), ( __param(4, IChatEntitlementService)), ( __param(5, IInlineChatSessionService)), ( __param(6, ITelemetryService))], InlineChatAffordance));
 
 export { InlineChatAffordance };

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

@@ -17,11 +17,15 @@ import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { ISharedWebContentExtractorService } from "@codingame/monaco-vscode-api/vscode/vs/platform/webContentExtractor/common/webContentExtractor.service";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IChatAttachmentResolveService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatAttachmentResolveService.service";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
 import { ILanguageModelChatSelector } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
 import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
 import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { InlineChatAffordance } from "./inlineChatAffordance.js";
+import { InlineChatInputWidget } from "./inlineChatOverlayWidget.js";
 import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
 import { EditorBasedInlineChatWidget } from "./inlineChatWidget.js";
 export declare abstract class InlineChatRunOptions {
@@ -33,6 +37,7 @@ export declare abstract class InlineChatRunOptions {
     position?: IPosition;
     modelSelector?: ILanguageModelChatSelector;
     resolveOnResponse?: boolean;
+    attachDiagnostics?: boolean;
     static isInlineChatRunOptions(options: unknown): options is InlineChatRunOptions;
 }
 export declare class InlineChatController implements IEditorContribution {
@@ -48,6 +53,8 @@ export declare class InlineChatController implements IEditorContribution {
     private readonly _markerDecorationsService;
     private readonly _languageModelService;
     private readonly _logService;
+    private readonly _chatEditingService;
+    private readonly _chatService;
     static readonly ID = "editor.contrib.inlineChatController";
     static get(editor: ICodeEditor): InlineChatController | undefined;
     /**
@@ -59,11 +66,13 @@ export declare class InlineChatController implements IEditorContribution {
     private readonly _isActiveController;
     private readonly _renderMode;
     private readonly _zone;
-    private readonly _gutterIndicator;
+    readonly inputOverlayWidget: InlineChatAffordance;
+    private readonly _inputWidget;
     private readonly _currentSession;
     get widget(): EditorBasedInlineChatWidget;
     get isActive(): boolean;
-    constructor(_editor: ICodeEditor, _instaService: IInstantiationService, _notebookEditorService: INotebookEditorService, _inlineChatSessionService: IInlineChatSessionService, codeEditorService: ICodeEditorService, contextKeyService: IContextKeyService, _configurationService: IConfigurationService, _webContentExtractorService: ISharedWebContentExtractorService, _fileService: IFileService, _chatAttachmentResolveService: IChatAttachmentResolveService, _editorService: IEditorService, _markerDecorationsService: IMarkerDecorationsService, _languageModelService: ILanguageModelsService, _logService: ILogService);
+    get inputWidget(): InlineChatInputWidget;
+    constructor(_editor: ICodeEditor, _instaService: IInstantiationService, _notebookEditorService: INotebookEditorService, _inlineChatSessionService: IInlineChatSessionService, codeEditorService: ICodeEditorService, contextKeyService: IContextKeyService, _configurationService: IConfigurationService, _webContentExtractorService: ISharedWebContentExtractorService, _fileService: IFileService, _chatAttachmentResolveService: IChatAttachmentResolveService, _editorService: IEditorService, _markerDecorationsService: IMarkerDecorationsService, _languageModelService: ILanguageModelsService, _logService: ILogService, _chatEditingService: IChatEditingService, _chatService: IChatService);
     dispose(): void;
     getWidgetPosition(): Position | undefined;
     focus(): void;