@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

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

@@ -5,6 +5,7 @@ import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
 import { ICodeEditorViewState } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
 import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
 import { IAccessibleViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView.service";
 import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
@@ -43,18 +44,9 @@ export interface IInlineChatWidgetConstructionOptions {
     inZoneWidget?: boolean;
 }
 export declare class InlineChatWidget {
-    private readonly _options;
+    #private;
     protected readonly _instantiationService: IInstantiationService;
-    private readonly _contextKeyService;
-    private readonly _keybindingService;
-    private readonly _accessibilityService;
-    private readonly _configurationService;
-    private readonly _accessibleViewService;
     protected readonly _textModelResolverService: ITextModelService;
-    private readonly _chatService;
-    private readonly _hoverService;
-    private readonly _chatEntitlementService;
-    private readonly _markdownRendererService;
     protected readonly _elements: {
         root: HTMLDivElement;
         chatWidget: HTMLDivElement;
@@ -67,18 +59,11 @@ export declare class InlineChatWidget {
         status: HTMLDivElement;
     };
     protected readonly _store: DisposableStore;
-    private readonly _ctxInputEditorFocused;
-    private readonly _ctxResponseFocused;
-    private readonly _chatWidget;
     protected readonly _onDidChangeHeight: Emitter<void>;
     readonly onDidChangeHeight: Event<void>;
-    private readonly _requestInProgress;
     readonly requestInProgress: IObservable<boolean>;
-    private _isLayouting;
     readonly scopedContextKeyService: IContextKeyService;
-    constructor(location: IChatWidgetLocationOptions, _options: IInlineChatWidgetConstructionOptions, _instantiationService: IInstantiationService, _contextKeyService: IContextKeyService, _keybindingService: IKeybindingService, _accessibilityService: IAccessibilityService, _configurationService: IConfigurationService, _accessibleViewService: IAccessibleViewService, _textModelResolverService: ITextModelService, _chatService: IChatService, _hoverService: IHoverService, _chatEntitlementService: IChatEntitlementService, _markdownRendererService: IMarkdownRendererService);
-    private _updateAriaLabel;
-    private _setupDisclaimer;
+    constructor(location: IChatWidgetLocationOptions, options: IInlineChatWidgetConstructionOptions, _instantiationService: IInstantiationService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, accessibilityService: IAccessibilityService, configurationService: IConfigurationService, accessibleViewService: IAccessibleViewService, _textModelResolverService: ITextModelService, modelService: IModelService, chatService: IChatService, hoverService: IHoverService, chatEntitlementService: IChatEntitlementService, markdownRendererService: IMarkdownRendererService);
     dispose(): void;
     get domNode(): HTMLElement;
     get chatWidget(): ChatWidget;
@@ -113,7 +98,7 @@ export declare class InlineChatWidget {
     hasFocus(): boolean;
 }
 export declare class EditorBasedInlineChatWidget extends InlineChatWidget {
-    constructor(location: IChatWidgetLocationOptions, parentEditor: ICodeEditor, options: IInlineChatWidgetConstructionOptions, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, accessibilityService: IAccessibilityService, configurationService: IConfigurationService, accessibleViewService: IAccessibleViewService, textModelResolverService: ITextModelService, chatService: IChatService, hoverService: IHoverService, layoutService: ILayoutService, chatEntitlementService: IChatEntitlementService, markdownRendererService: IMarkdownRendererService);
+    constructor(location: IChatWidgetLocationOptions, parentEditor: ICodeEditor, options: IInlineChatWidgetConstructionOptions, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, accessibilityService: IAccessibilityService, configurationService: IConfigurationService, accessibleViewService: IAccessibleViewService, textModelResolverService: ITextModelService, modelService: IModelService, chatService: IChatService, hoverService: IHoverService, layoutService: ILayoutService, chatEntitlementService: IChatEntitlementService, markdownRendererService: IMarkdownRendererService);
     protected _doLayout(dimension: Dimension): void;
     reset(): void;
 }

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

@@ -10,6 +10,7 @@ import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vsco
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { Selection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IAccessibleViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView.service';
@@ -49,7 +50,6 @@ import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contr
 import { ChatAgentVoteDirection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
-import { walkTokens, lexer } from 'marked';
 import { inlineChatBackground, inlineChatForeground, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_FOCUSED } from '../common/inlineChat.js';
 import * as inlineChat from './media/inlineChat.css';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
@@ -57,33 +57,38 @@ import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 
 registerCss(inlineChat);
 let InlineChatWidget = class InlineChatWidget {
+    #ctxInputEditorFocused;
+    #ctxResponseFocused;
+    #chatWidget;
+    #requestInProgress;
+    #isLayouting;
+    #options;
+    #keybindingService;
+    #accessibilityService;
+    #configurationService;
+    #accessibleViewService;
+    #modelService;
+    #chatService;
+    #chatEntitlementService;
+    #markdownRendererService;
     constructor(
         location,
-        _options,
+        options,
         _instantiationService,
-        _contextKeyService,
-        _keybindingService,
-        _accessibilityService,
-        _configurationService,
-        _accessibleViewService,
+        contextKeyService,
+        keybindingService,
+        accessibilityService,
+        configurationService,
+        accessibleViewService,
         _textModelResolverService,
-        _chatService,
-        _hoverService,
-        _chatEntitlementService,
-        _markdownRendererService
+        modelService,
+        chatService,
+        hoverService,
+        chatEntitlementService,
+        markdownRendererService
     ) {
-        this._options = _options;
         this._instantiationService = _instantiationService;
-        this._contextKeyService = _contextKeyService;
-        this._keybindingService = _keybindingService;
-        this._accessibilityService = _accessibilityService;
-        this._configurationService = _configurationService;
-        this._accessibleViewService = _accessibleViewService;
         this._textModelResolverService = _textModelResolverService;
-        this._chatService = _chatService;
-        this._hoverService = _hoverService;
-        this._chatEntitlementService = _chatEntitlementService;
-        this._markdownRendererService = _markdownRendererService;
         this._elements = h("div.inline-chat@root", [
             h("div.chat-widget@chatWidget"),
             h("div.accessibleViewer@accessibleViewer"),
@@ -97,13 +102,22 @@ let InlineChatWidget = class InlineChatWidget {
         ]);
         this._store = ( new DisposableStore());
         this._onDidChangeHeight = this._store.add(( new Emitter()));
-        this.onDidChangeHeight = Event.filter(this._onDidChangeHeight.event, _ => !this._isLayouting);
-        this._requestInProgress = observableValue(this, false);
-        this.requestInProgress = this._requestInProgress;
-        this._isLayouting = false;
-        this.scopedContextKeyService = this._store.add(_contextKeyService.createScoped(this._elements.chatWidget));
+        this.onDidChangeHeight = Event.filter(this._onDidChangeHeight.event, _ => !this.#isLayouting);
+        this.#requestInProgress = observableValue(this, false);
+        this.requestInProgress = this.#requestInProgress;
+        this.#isLayouting = false;
+        this.#options = options;
+        this.#keybindingService = keybindingService;
+        this.#accessibilityService = accessibilityService;
+        this.#configurationService = configurationService;
+        this.#accessibleViewService = accessibleViewService;
+        this.#modelService = modelService;
+        this.#chatService = chatService;
+        this.#chatEntitlementService = chatEntitlementService;
+        this.#markdownRendererService = markdownRendererService;
+        this.scopedContextKeyService = this._store.add(contextKeyService.createScoped(this._elements.chatWidget));
         const scopedInstaService = _instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])), this._store);
-        this._chatWidget = scopedInstaService.createInstance(ChatWidget, location, {
+        this.#chatWidget = scopedInstaService.createInstance(ChatWidget, location, {
             isInlineChat: true
         }, {
             autoScroll: true,
@@ -121,7 +135,7 @@ let InlineChatWidget = class InlineChatWidget {
                     return false;
                 }
                 if (item.response.value.every(
-                    item => item.kind === "textEditGroup" && _options.chatWidgetViewOptions?.rendererOptions?.renderTextEditsAsSummary?.(item.uri)
+                    item => item.kind === "textEditGroup" && options.chatWidgetViewOptions?.rendererOptions?.renderTextEditsAsSummary?.(item.uri)
                 )) {
                     return false;
                 }
@@ -129,7 +143,7 @@ let InlineChatWidget = class InlineChatWidget {
             },
             dndContainer: this._elements.root,
             defaultMode: ChatMode.Ask,
-            ..._options.chatWidgetViewOptions
+            ...options.chatWidgetViewOptions
         }, {
             listForeground: inlineChatForeground,
             listBackground: inlineChatBackground,
@@ -137,23 +151,23 @@ let InlineChatWidget = class InlineChatWidget {
             inputEditorBackground: inputBackground,
             resultEditorBackground: editorBackground
         });
-        this._elements.root.classList.toggle("in-zone-widget", !!_options.inZoneWidget);
-        this._chatWidget.render(this._elements.chatWidget);
+        this._elements.root.classList.toggle("in-zone-widget", !!options.inZoneWidget);
+        this.#chatWidget.render(this._elements.chatWidget);
         this._elements.chatWidget.style.setProperty(
             asCssVariableName(chatRequestBackground),
             asCssVariable(inlineChatBackground)
         );
-        this._chatWidget.setVisible(true);
-        this._store.add(this._chatWidget);
+        this.#chatWidget.setVisible(true);
+        this._store.add(this.#chatWidget);
         const ctxResponse = ChatContextKeys.isResponse.bindTo(this.scopedContextKeyService);
         const ctxResponseVote = ChatContextKeys.responseVote.bindTo(this.scopedContextKeyService);
         const ctxResponseSupportIssues = ChatContextKeys.responseSupportsIssueReporting.bindTo(this.scopedContextKeyService);
         const ctxResponseError = ChatContextKeys.responseHasError.bindTo(this.scopedContextKeyService);
         const ctxResponseErrorFiltered = ChatContextKeys.responseIsFiltered.bindTo(this.scopedContextKeyService);
         const viewModelStore = this._store.add(( new DisposableStore()));
-        this._store.add(this._chatWidget.onDidChangeViewModel(() => {
+        this._store.add(this.#chatWidget.onDidChangeViewModel(() => {
             viewModelStore.clear();
-            const viewModel = this._chatWidget.viewModel;
+            const viewModel = this.#chatWidget.viewModel;
             if (!viewModel) {
                 return;
             }
@@ -166,7 +180,7 @@ let InlineChatWidget = class InlineChatWidget {
                 ctxResponseSupportIssues.reset();
             }));
             viewModelStore.add(viewModel.onDidChange(() => {
-                this._requestInProgress.set(viewModel.model.requestInProgress.get(), undefined);
+                this.#requestInProgress.set(viewModel.model.requestInProgress.get(), undefined);
                 const last = viewModel.getItems().at(-1);
                 toolbar2.context = last;
                 ctxResponse.set(isResponseVM(last));
@@ -185,24 +199,24 @@ let InlineChatWidget = class InlineChatWidget {
         this._store.add(this.chatWidget.onDidChangeContentHeight(() => {
             this._onDidChangeHeight.fire();
         }));
-        this._ctxResponseFocused = CTX_INLINE_CHAT_RESPONSE_FOCUSED.bindTo(this._contextKeyService);
+        this.#ctxResponseFocused = CTX_INLINE_CHAT_RESPONSE_FOCUSED.bindTo(contextKeyService);
         const tracker = this._store.add(trackFocus(this.domNode));
-        this._store.add(tracker.onDidBlur(() => this._ctxResponseFocused.set(false)));
-        this._store.add(tracker.onDidFocus(() => this._ctxResponseFocused.set(true)));
-        this._ctxInputEditorFocused = CTX_INLINE_CHAT_FOCUSED.bindTo(_contextKeyService);
+        this._store.add(tracker.onDidBlur(() => this.#ctxResponseFocused.set(false)));
+        this._store.add(tracker.onDidFocus(() => this.#ctxResponseFocused.set(true)));
+        this.#ctxInputEditorFocused = CTX_INLINE_CHAT_FOCUSED.bindTo(contextKeyService);
         this._store.add(
-            this._chatWidget.inputEditor.onDidFocusEditorWidget(() => this._ctxInputEditorFocused.set(true))
+            this.#chatWidget.inputEditor.onDidFocusEditorWidget(() => this.#ctxInputEditorFocused.set(true))
         );
         this._store.add(
-            this._chatWidget.inputEditor.onDidBlurEditorWidget(() => this._ctxInputEditorFocused.set(false))
+            this.#chatWidget.inputEditor.onDidBlurEditorWidget(() => this.#ctxInputEditorFocused.set(false))
         );
-        const statusMenuId = _options.statusMenuId instanceof MenuId ? _options.statusMenuId : _options.statusMenuId.menu;
-        const statusMenuOptions = _options.statusMenuId instanceof MenuId ? undefined : _options.statusMenuId.options;
+        const statusMenuId = options.statusMenuId instanceof MenuId ? options.statusMenuId : options.statusMenuId.menu;
+        const statusMenuOptions = options.statusMenuId instanceof MenuId ? undefined : options.statusMenuId.options;
         const statusButtonBar = scopedInstaService.createInstance(MenuWorkbenchButtonBar, this._elements.toolbar1, statusMenuId, {
             toolbarOptions: {
                 primaryGroup: "0_main"
             },
-            telemetrySource: _options.chatWidgetViewOptions?.menus?.telemetrySource,
+            telemetrySource: options.chatWidgetViewOptions?.menus?.telemetrySource,
             menuOptions: {
                 renderShortTitle: true
             },
@@ -213,9 +227,9 @@ let InlineChatWidget = class InlineChatWidget {
         const toolbar2 = scopedInstaService.createInstance(
             MenuWorkbenchToolBar,
             this._elements.toolbar2,
-            _options.secondaryMenuId ?? MenuId.for(""),
+            options.secondaryMenuId ?? MenuId.for(""),
             {
-                telemetrySource: _options.chatWidgetViewOptions?.menus?.telemetrySource,
+                telemetrySource: options.chatWidgetViewOptions?.menus?.telemetrySource,
                 menuOptions: {
                     renderShortTitle: true,
                     shouldForwardArgs: true
@@ -227,61 +241,61 @@ let InlineChatWidget = class InlineChatWidget {
         );
         this._store.add(toolbar2.onDidChangeMenuItems(() => this._onDidChangeHeight.fire()));
         this._store.add(toolbar2);
-        this._store.add(this._configurationService.onDidChangeConfiguration(e => {
+        this._store.add(this.#configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(AccessibilityVerbositySettingId.InlineChat)) {
-                this._updateAriaLabel();
+                this.#updateAriaLabel();
             }
         }));
         this._elements.root.tabIndex = 0;
         this._elements.statusLabel.tabIndex = 0;
-        this._updateAriaLabel();
-        this._setupDisclaimer();
+        this.#updateAriaLabel();
+        this.#setupDisclaimer();
         this._store.add(
-            this._hoverService.setupManagedHover(getDefaultHoverDelegate("element"), this._elements.statusLabel, () => {
+            hoverService.setupManagedHover(getDefaultHoverDelegate("element"), this._elements.statusLabel, () => {
                 return this._elements.statusLabel.dataset["title"];
             })
         );
-        this._store.add(this._chatService.onDidPerformUserAction(e => {
-            if (isEqual(e.sessionResource, this._chatWidget.viewModel?.model.sessionResource) && e.action.kind === "vote") {
-                this.updateStatus(( localize(9977, "Thank you for your feedback!")), {
+        this._store.add(this.#chatService.onDidPerformUserAction(e => {
+            if (isEqual(e.sessionResource, this.#chatWidget.viewModel?.model.sessionResource) && e.action.kind === "vote") {
+                this.updateStatus(( localize(10108, "Thank you for your feedback!")), {
                     resetAfter: 1250
                 });
             }
         }));
     }
-    _updateAriaLabel() {
-        this._elements.root.ariaLabel = this._accessibleViewService.getOpenAriaHint(AccessibilityVerbositySettingId.InlineChat);
-        if (this._accessibilityService.isScreenReaderOptimized()) {
+    #updateAriaLabel() {
+        this._elements.root.ariaLabel = this.#accessibleViewService.getOpenAriaHint(AccessibilityVerbositySettingId.InlineChat);
+        if (this.#accessibilityService.isScreenReaderOptimized()) {
             let label = defaultAriaLabel;
-            if (this._configurationService.getValue(AccessibilityVerbositySettingId.InlineChat)) {
-                const kbLabel = this._keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+            if (this.#configurationService.getValue(AccessibilityVerbositySettingId.InlineChat)) {
+                const kbLabel = this.#keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
                 label = kbLabel ? ( localize(
-                    9978,
+                    10109,
                     "Inline Chat Input, Use {0} for Inline Chat Accessibility Help.",
                     kbLabel
                 )) : ( localize(
-                    9979,
+                    10110,
                     "Inline Chat Input, Run the Inline Chat Accessibility Help command for more information."
                 ));
             }
-            this._chatWidget.inputEditor.updateOptions({
+            this.#chatWidget.inputEditor.updateOptions({
                 ariaLabel: label
             });
         }
     }
-    _setupDisclaimer() {
+    #setupDisclaimer() {
         const disposables = this._store.add(( new DisposableStore()));
         this._store.add(autorun(reader => {
             disposables.clear();
             reset(this._elements.disclaimerLabel);
-            const sentiment = this._chatEntitlementService.sentimentObs.read(reader);
-            const anonymous = this._chatEntitlementService.anonymousObs.read(reader);
-            const requestInProgress = this._chatService.requestInProgressObs.read(reader);
-            const showDisclaimer = !sentiment.installed && anonymous && !requestInProgress;
+            const sentiment = this.#chatEntitlementService.sentimentObs.read(reader);
+            const anonymous = this.#chatEntitlementService.anonymousObs.read(reader);
+            const requestInProgress = this.#chatService.requestInProgressObs.read(reader);
+            const showDisclaimer = !sentiment.completed && anonymous && !requestInProgress;
             this._elements.disclaimerLabel.classList.toggle("hidden", !showDisclaimer);
             if (showDisclaimer) {
-                const renderedMarkdown = disposables.add(this._markdownRendererService.render(( new MarkdownString(( localize(
-                    9980,
+                const renderedMarkdown = disposables.add(this.#markdownRendererService.render(( new MarkdownString(( localize(
+                    10111,
                     "By continuing with {0} Copilot, you agree to {1}'s [Terms]({2}) and [Privacy Statement]({3})",
                     product.defaultChatAgent?.provider?.default?.name ?? "",
                     product.defaultChatAgent?.provider?.default?.name ?? "",
@@ -302,18 +316,18 @@ let InlineChatWidget = class InlineChatWidget {
         return this._elements.root;
     }
     get chatWidget() {
-        return this._chatWidget;
+        return this.#chatWidget;
     }
     saveState() {
-        this._chatWidget.saveState();
+        this.#chatWidget.saveState();
     }
     layout(widgetDim) {
         const contentHeight = this.contentHeight;
-        this._isLayouting = true;
+        this.#isLayouting = true;
         try {
             this._doLayout(widgetDim);
         } finally {
-            this._isLayouting = false;
+            this.#isLayouting = false;
             if (this.contentHeight !== contentHeight) {
                 this._onDidChangeHeight.fire();
             }
@@ -324,11 +338,11 @@ let InlineChatWidget = class InlineChatWidget {
         const statusHeight = getTotalHeight(this._elements.status);
         this._elements.root.style.height = `${dimension.height - extraHeight}px`;
         this._elements.root.style.width = `${dimension.width}px`;
-        this._chatWidget.layout(dimension.height - statusHeight - extraHeight, dimension.width);
+        this.#chatWidget.layout(dimension.height - statusHeight - extraHeight, dimension.width);
     }
     get contentHeight() {
         const data = {
-            chatWidgetContentHeight: this._chatWidget.contentHeight,
+            chatWidgetContentHeight: this.#chatWidget.contentHeight,
             statusHeight: getTotalHeight(this._elements.status),
             extraHeight: this._getExtraHeight()
         };
@@ -337,34 +351,34 @@ let InlineChatWidget = class InlineChatWidget {
     }
     get minHeight() {
         let maxWidgetOutputHeight = 100;
-        for (const item of this._chatWidget.viewModel?.getItems() ?? []) {
+        for (const item of this.#chatWidget.viewModel?.getItems() ?? []) {
             if (isResponseVM(item) && ( item.response.value.some(r => r.kind === "textEditGroup" && !r.state?.applied))) {
                 maxWidgetOutputHeight = 270;
                 break;
             }
         }
         let value = this.contentHeight;
-        value -= this._chatWidget.contentHeight;
+        value -= this.#chatWidget.contentHeight;
         value += Math.min(
-            this._chatWidget.input.height.get() + maxWidgetOutputHeight,
-            this._chatWidget.contentHeight
+            this.#chatWidget.input.height.get() + maxWidgetOutputHeight,
+            this.#chatWidget.contentHeight
         );
         return value;
     }
     _getExtraHeight() {
-        return this._options.inZoneWidget ? 1 : (2  + 4) ;
+        return this.#options.inZoneWidget ? 1 : (2  + 4) ;
     }
     get value() {
-        return this._chatWidget.getInput();
+        return this.#chatWidget.getInput();
     }
     set value(value) {
-        this._chatWidget.setInput(value);
+        this.#chatWidget.setInput(value);
     }
     selectAll() {
-        this._chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
+        this.#chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
     }
     set placeholder(value) {
-        this._chatWidget.setInputPlaceholder(value);
+        this.#chatWidget.setInputPlaceholder(value);
     }
     toggleStatus(show) {
         this._elements.toolbar1.classList.toggle("hidden", !show);
@@ -384,7 +398,7 @@ let InlineChatWidget = class InlineChatWidget {
     async getCodeBlockInfo(codeBlockIndex) {
         const {
             viewModel
-        } = this._chatWidget;
+        } = this.#chatWidget;
         if (!viewModel) {
             return undefined;
         }
@@ -393,47 +407,45 @@ let InlineChatWidget = class InlineChatWidget {
         if (!item) {
             return;
         }
-        const existingEntry = viewModel.codeBlockModelCollection.get(viewModel.sessionResource, item, codeBlockIndex);
-        if (existingEntry) {
-            return existingEntry.model;
+        const codeBlocks = this.#chatWidget.getCodeBlockInfosForResponse(item);
+        const info = codeBlocks[codeBlockIndex];
+        if (info?.uri) {
+            return this.#modelService.getModel(info.uri) ?? undefined;
         }
         const markdown = item.response.getMarkdown();
         let currentCodeBlockIndex = 0;
-        let foundCodeBlock;
-        walkTokens(lexer(markdown), token => {
-            if (token.type === "code") {
+        let foundText;
+        for (const line of markdown.split("\n")) {
+            if (line.startsWith("```") && foundText === undefined) {
+                foundText = "";
+            } else if (line.startsWith("```") && foundText !== undefined) {
                 if (currentCodeBlockIndex === codeBlockIndex) {
-                    foundCodeBlock = {
-                        text: token.text,
-                        lang: token.lang || ""
-                    };
+                    break;
                 }
                 currentCodeBlockIndex++;
+                foundText = undefined;
+            } else if (foundText !== undefined) {
+                foundText += (foundText ? "\n" : "") + line;
             }
-        });
-        if (!foundCodeBlock) {
-            return undefined;
         }
-        const entry = viewModel.codeBlockModelCollection.updateSync(viewModel.sessionResource, item, codeBlockIndex, {
-            text: foundCodeBlock.text,
-            languageId: foundCodeBlock.lang,
-            isComplete: true
-        });
-        return entry.model;
+        if (foundText !== undefined && currentCodeBlockIndex === codeBlockIndex) {
+            return this.#modelService.createModel(foundText, null, undefined, true);
+        }
+        return undefined;
     }
     get responseContent() {
-        const requests = this._chatWidget.viewModel?.model.getRequests();
+        const requests = this.#chatWidget.viewModel?.model.getRequests();
         return requests?.at(-1)?.response?.response.toString();
     }
     getChatModel() {
-        return this._chatWidget.viewModel?.model;
+        return this.#chatWidget.viewModel?.model;
     }
     setChatModel(chatModel) {
         chatModel.inputModel.setState({
             inputText: "",
             selections: []
         });
-        this._chatWidget.setModel(chatModel);
+        this.#chatWidget.setModel(chatModel);
     }
     updateInfo(message) {
         this._elements.infoLabel.classList.toggle("hidden", !message);
@@ -472,8 +484,8 @@ let InlineChatWidget = class InlineChatWidget {
         this._onDidChangeHeight.fire();
     }
     reset() {
-        this._chatWidget.attachmentModel.clear(true);
-        this._chatWidget.saveState();
+        this.#chatWidget.attachmentModel.clear(true);
+        this.#chatWidget.saveState();
         reset(this._elements.statusLabel);
         this._elements.statusLabel.classList.toggle("hidden", true);
         this._elements.toolbar1.classList.add("hidden");
@@ -483,14 +495,14 @@ let InlineChatWidget = class InlineChatWidget {
         this._onDidChangeHeight.fire();
     }
     focus() {
-        this._chatWidget.focusInput();
+        this.#chatWidget.focusInput();
     }
     hasFocus() {
         return this.domNode.contains(getActiveElement());
     }
 };
-InlineChatWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IContextKeyService)), ( __param(4, IKeybindingService)), ( __param(5, IAccessibilityService)), ( __param(6, IConfigurationService)), ( __param(7, IAccessibleViewService)), ( __param(8, ITextModelService)), ( __param(9, IChatService)), ( __param(10, IHoverService)), ( __param(11, IChatEntitlementService)), ( __param(12, IMarkdownRendererService))], InlineChatWidget));
-const defaultAriaLabel = ( localize(9981, "Inline Chat Input"));
+InlineChatWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IContextKeyService)), ( __param(4, IKeybindingService)), ( __param(5, IAccessibilityService)), ( __param(6, IConfigurationService)), ( __param(7, IAccessibleViewService)), ( __param(8, ITextModelService)), ( __param(9, IModelService)), ( __param(10, IChatService)), ( __param(11, IHoverService)), ( __param(12, IChatEntitlementService)), ( __param(13, IMarkdownRendererService))], InlineChatWidget));
+const defaultAriaLabel = ( localize(10112, "Inline Chat Input"));
 let EditorBasedInlineChatWidget = class EditorBasedInlineChatWidget extends InlineChatWidget {
     constructor(
         location,
@@ -503,6 +515,7 @@ let EditorBasedInlineChatWidget = class EditorBasedInlineChatWidget extends Inli
         configurationService,
         accessibleViewService,
         textModelResolverService,
+        modelService,
         chatService,
         hoverService,
         layoutService,
@@ -516,7 +529,7 @@ let EditorBasedInlineChatWidget = class EditorBasedInlineChatWidget extends Inli
                 ...options.chatWidgetViewOptions,
                 editorOverflowWidgetsDomNode: overflowWidgetsNode
             }
-        }, instantiationService, contextKeyService, keybindingService, accessibilityService, configurationService, accessibleViewService, textModelResolverService, chatService, hoverService, chatEntitlementService, markdownRendererService);
+        }, instantiationService, contextKeyService, keybindingService, accessibilityService, configurationService, accessibleViewService, textModelResolverService, modelService, chatService, hoverService, chatEntitlementService, markdownRendererService);
         this._store.add(toDisposable(() => {
             overflowWidgetsNode.remove();
         }));
@@ -531,6 +544,6 @@ let EditorBasedInlineChatWidget = class EditorBasedInlineChatWidget extends Inli
         super.reset();
     }
 };
-EditorBasedInlineChatWidget = ( __decorate([( __param(3, IContextKeyService)), ( __param(4, IKeybindingService)), ( __param(5, IInstantiationService)), ( __param(6, IAccessibilityService)), ( __param(7, IConfigurationService)), ( __param(8, IAccessibleViewService)), ( __param(9, ITextModelService)), ( __param(10, IChatService)), ( __param(11, IHoverService)), ( __param(12, ILayoutService)), ( __param(13, IChatEntitlementService)), ( __param(14, IMarkdownRendererService))], EditorBasedInlineChatWidget));
+EditorBasedInlineChatWidget = ( __decorate([( __param(3, IContextKeyService)), ( __param(4, IKeybindingService)), ( __param(5, IInstantiationService)), ( __param(6, IAccessibilityService)), ( __param(7, IConfigurationService)), ( __param(8, IAccessibleViewService)), ( __param(9, ITextModelService)), ( __param(10, IModelService)), ( __param(11, IChatService)), ( __param(12, IHoverService)), ( __param(13, ILayoutService)), ( __param(14, IChatEntitlementService)), ( __param(15, IMarkdownRendererService))], EditorBasedInlineChatWidget));
 
 export { EditorBasedInlineChatWidget, InlineChatWidget };

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

@@ -1,3 +1,4 @@
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
 import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
 import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
@@ -10,32 +11,28 @@ import { IChatWidgetLocationOptions } from "../../chat/browser/widget/chatWidget
 import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
 import { EditorBasedInlineChatWidget } from "./inlineChatWidget.js";
 export declare class InlineChatZoneWidget extends ZoneWidget {
-    private readonly _instaService;
-    private _logService;
-    private static readonly _options;
+    #private;
     readonly widget: EditorBasedInlineChatWidget;
-    private readonly _ctxCursorPosition;
-    private _dimension?;
     private notebookEditor?;
     constructor(location: IChatWidgetLocationOptions, options: IChatWidgetViewOptions | undefined, editors: {
         editor: ICodeEditor;
         notebookEditor?: INotebookEditor;
     }, 
     /** @deprecated should go away with inline2 */
-    clearDelegate: () => Promise<void>, _instaService: IInstantiationService, _logService: ILogService, contextKeyService: IContextKeyService);
+    clearDelegate: () => Promise<void>, instaService: IInstantiationService, logService: ILogService, contextKeyService: IContextKeyService);
     protected _fillContainer(container: HTMLElement): void;
+    showTerminationCard(message: string | IMarkdownString, instaService: IInstantiationService): void;
+    hideTerminationCard(): void;
+    get isShowingTerminationCard(): boolean;
     protected _doLayout(heightInPixel: number): void;
-    private _computeHeight;
     protected _getResizeBounds(): {
         minLines: number;
         maxLines: number;
     };
     protected _onWidth(_widthInPixel: number): void;
     show(position: Position): void;
-    private _updatePadding;
     reveal(position: Position): void;
     updatePositionAndHeight(position: Position): void;
-    private _createZoneAndScrollRestoreFn;
     protected revealRange(range: Range, isLastLine: boolean): void;
     hide(): void;
 }