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

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListWidget.d.ts

@@ -144,6 +144,7 @@ export declare class ChatListWidget extends Disposable {
     private _lastItem;
     private _mostRecentlyFocusedItemIndex;
     private _scrollLock;
+    private _suppressAutoScroll;
     private _settingChangeCounter;
     private _visibleChangeCount;
     private readonly _container;
@@ -240,6 +241,11 @@ export declare class ChatListWidget extends Disposable {
      * Scroll the list to reveal the last item.
      */
     scrollToEnd(): void;
+    /**
+     * Suppress auto-scroll behavior temporarily. While suppressed,
+     * _withPersistedAutoScroll will not scroll to bottom after operations.
+     */
+    set suppressAutoScroll(value: boolean);
     private _withPersistedAutoScroll;
     /**
      * Focus the list.

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListWidget.js

@@ -105,6 +105,7 @@ let ChatListWidget = class ChatListWidget extends Disposable {
         this._visible = true;
         this._mostRecentlyFocusedItemIndex = -1;
         this._scrollLock = true;
+        this._suppressAutoScroll = false;
         this._settingChangeCounter = 0;
         this._visibleChangeCount = 0;
         this._bodyDimension = null;
@@ -310,19 +311,19 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             collapsible: false
         })));
         const editing = this._viewModel.editing;
-        const checkpoint = this._viewModel.model?.checkpoint;
         this._withPersistedAutoScroll(() => {
             this._tree.setChildren(null, treeItems, {
                 diffIdentityProvider: {
                     getId: element => {
                         const baseId = (isRequestVM(element) || isResponseVM(element)) ? element.dataId : element.id;
                         const disablement = (isRequestVM(element) || isResponseVM(element)) ? element.shouldBeRemovedOnSend : undefined;
+                        const isEditTarget = isRequestVM(element) && editing?.id === element.id;
+                        const isBlocked = (isRequestVM(element) || isResponseVM(element)) ? element.shouldBeBlocked.get() : false;
                         return (
                             baseId +
                             `${isResponseVM(element) && element.renderData ? `_${this._visibleChangeCount}` : ""}` + (isResponseVM(element) ? `_${element.contentReferences.length}` : "") +
                             `_${disablement ? `${disablement.afterUndoStop || "1"}` : "0"}` +
-                            `_${editing ? "1" : "0"}` +
-                            `_${checkpoint ? "1" : "0"}` +
+                            `_${isEditTarget ? "edit" : ""}` + `_${isBlocked ? "blocked" : ""}` + (isRequestVM(element) ? `_${editing ? "1" : "0"}` : "") +
                             `_setting${this._settingChangeCounter}` + (isRequestVM(element) && element.contentReferences ? `_${element.contentReferences?.length}` : "")
                         );
                     }
@@ -417,7 +418,14 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             }
         }
     }
+    set suppressAutoScroll(value) {
+        this._suppressAutoScroll = value;
+    }
     _withPersistedAutoScroll(fn) {
+        if (this._suppressAutoScroll) {
+            fn();
+            return;
+        }
         const wasScrolledToBottom = this.isScrolledToBottom;
         fn();
         if (wasScrolledToBottom) {
@@ -473,9 +481,10 @@ let ChatListWidget = class ChatListWidget extends Disposable {
             this._container.style.removeProperty("--chat-current-response-min-height");
         } else {
             const secondToLastItem = this._viewModel?.getItems().at(-2);
+            const maxRequestShownHeight = 200;
             const secondToLastItemHeight = Math.min(
                 (isRequestVM(secondToLastItem) || isResponseVM(secondToLastItem)) ? secondToLastItem.currentRenderedHeight ?? 150 : 150,
-                150
+                maxRequestShownHeight
             );
             const lastItemMinHeight = Math.max(contentHeight - (secondToLastItemHeight + 10), 0);
             this._container.style.setProperty("--chat-current-response-min-height", lastItemMinHeight + "px");

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatQuestionCarouselAutoReply.d.ts

@@ -0,0 +1,35 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatQuestionCarousel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+/**
+ * Encapsulates the logic for automatically replying to question carousels,
+ * including opt-in state management, LLM-based answer resolution, fallback
+ * answer generation, and answer parsing/merging.
+ */
+export declare class ChatQuestionCarouselAutoReply extends Disposable {
+    private readonly configService;
+    private readonly dialogService;
+    private readonly logService;
+    private readonly storageService;
+    private readonly languageModelsService;
+    constructor(configService: IConfigurationService, dialogService: IDialogService, logService: ILogService, storageService: IStorageService, languageModelsService: ILanguageModelsService);
+    shouldAutoReply(): Promise<boolean>;
+    autoReply(carousel: IChatQuestionCarousel, submit: (answers: Map<string, unknown> | undefined) => Promise<void>, modelName: string | undefined, requestMessageText: string | undefined, token: CancellationToken): Promise<void>;
+    private checkOptIn;
+    private getModelId;
+    private buildPrompt;
+    private requestAnswers;
+    private parseAnswers;
+    private mergeAnswers;
+    private hasDefaultValue;
+    private resolveAnswerFromRaw;
+    private matchQuestionOption;
+    buildFallbackCarouselAnswers(carousel: IChatQuestionCarousel, requestMessageText: string | undefined): Map<string, unknown>;
+    private getFallbackAnswerForQuestion;
+    private tryParseJsonObject;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatQuestionCarouselAutoReply.js

@@ -0,0 +1,440 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatMessageRole, getTextResponseFromStream } 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 { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+
+var AutoReplyStorageKeys;
+(function(AutoReplyStorageKeys) {
+    AutoReplyStorageKeys["AutoReplyOptIn"] = "chat.autoReply.optIn";
+})(AutoReplyStorageKeys || (AutoReplyStorageKeys = {}));
+let ChatQuestionCarouselAutoReply = class ChatQuestionCarouselAutoReply extends Disposable {
+    constructor(
+        configService,
+        dialogService,
+        logService,
+        storageService,
+        languageModelsService
+    ) {
+        super();
+        this.configService = configService;
+        this.dialogService = dialogService;
+        this.logService = logService;
+        this.storageService = storageService;
+        this.languageModelsService = languageModelsService;
+        this._register(Event.runAndSubscribe(this.configService.onDidChangeConfiguration, e => {
+            if (!e || e.affectsConfiguration(ChatConfiguration.AutoReply)) {
+                if (this.configService.getValue(ChatConfiguration.AutoReply) !== true) {
+                    this.storageService.remove(AutoReplyStorageKeys.AutoReplyOptIn, StorageScope.APPLICATION);
+                }
+            }
+        }));
+    }
+    async shouldAutoReply() {
+        if (!this.configService.getValue(ChatConfiguration.AutoReply)) {
+            return false;
+        }
+        return this.checkOptIn();
+    }
+    async autoReply(carousel, submit, modelName, requestMessageText, token) {
+        if (token.isCancellationRequested || carousel.isUsed || carousel.questions.length === 0) {
+            return;
+        }
+        const fallbackAnswers = this.buildFallbackCarouselAnswers(carousel, requestMessageText);
+        let resolvedAnswers = fallbackAnswers;
+        const modelId = await this.getModelId(modelName);
+        if (modelId && !token.isCancellationRequested) {
+            try {
+                const parsedAnswers = await this.requestAnswers(modelId, carousel, requestMessageText, token);
+                if (parsedAnswers.size > 0) {
+                    resolvedAnswers = this.mergeAnswers(carousel, parsedAnswers, fallbackAnswers);
+                }
+            } catch (err) {
+                this.logService.debug("#ChatQuestionCarousel: Failed to resolve auto reply", toErrorMessage(err));
+            }
+        }
+        if (token.isCancellationRequested || carousel.isUsed) {
+            return;
+        }
+        await submit(resolvedAnswers);
+    }
+    async checkOptIn() {
+        const optedIn = this.storageService.getBoolean(AutoReplyStorageKeys.AutoReplyOptIn, StorageScope.APPLICATION, false);
+        if (optedIn) {
+            return true;
+        }
+        const promptResult = await this.dialogService.prompt({
+            type: Severity.Warning,
+            message: ( localize(6755, "Enable chat auto reply?")),
+            buttons: [{
+                label: ( localize(6756, "Enable")),
+                run: () => true
+            }, {
+                label: ( localize(6757, "Disable")),
+                run: () => false
+            }],
+            custom: {
+                icon: Codicon.warning,
+                disableCloseAction: true,
+                markdownDetails: [{
+                    markdown: ( new MarkdownString(( localize(
+                        6758,
+                        "Chat auto reply answers question carousels using the current model and may make unintended choices. Review your settings and outputs carefully."
+                    ))))
+                }]
+            }
+        });
+        if (promptResult.result !== true) {
+            await this.configService.updateValue(ChatConfiguration.AutoReply, false);
+            return false;
+        }
+        this.storageService.store(
+            AutoReplyStorageKeys.AutoReplyOptIn,
+            true,
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
+        return true;
+    }
+    async getModelId(modelName) {
+        if (!modelName) {
+            return undefined;
+        }
+        let models = await this.languageModelsService.selectLanguageModels({
+            id: modelName
+        });
+        if (models.length > 0) {
+            return models[0];
+        }
+        if (modelName.startsWith("copilot/")) {
+            models = await this.languageModelsService.selectLanguageModels({
+                vendor: "copilot",
+                family: modelName.replace(/^copilot\//, "")
+            });
+            return models[0];
+        }
+        return undefined;
+    }
+    buildPrompt(carousel, requestMessageText, strict) {
+        const questions = ( carousel.questions.map(question => ({
+            id: question.id,
+            type: question.type,
+            title: question.title,
+            message: typeof question.message === "string" ? question.message : question.message?.value,
+            options: question.options?.map(option => ({
+                id: option.id,
+                label: option.label
+            })) ?? [],
+            allowFreeformInput: question.allowFreeformInput ?? false
+        })));
+        const contextLines = [];
+        if (requestMessageText) {
+            contextLines.push(`Original user request: ${JSON.stringify(requestMessageText)}`);
+        }
+        return [
+            "Choose default answers for the following questions.",
+            "Return a JSON object keyed by question id.",
+            "For text questions, the value should be a string.",
+            "For singleSelect questions, the value should be { \"selectedId\": string } or { \"freeform\": string }.",
+            "For multiSelect questions, the value should be { \"selectedIds\": string[] } and may include { \"freeform\": string }.",
+            "If a question allows freeform input and has no options, return a freeform answer based on the user request when possible.",
+            "Use option ids from the provided options.",
+            ...contextLines,
+            "Questions:",
+            JSON.stringify(questions),
+            strict ? "Return ONLY valid JSON. Do not include markdown or explanations." : undefined
+        ].filter(Boolean).join("\n");
+    }
+    async requestAnswers(modelId, carousel, requestMessageText, token) {
+        const prompt = this.buildPrompt(carousel, requestMessageText, false);
+        const response = await this.languageModelsService.sendChatRequest(modelId, undefined, [{
+            role: ChatMessageRole.User,
+            content: [{
+                type: "text",
+                value: prompt
+            }]
+        }], {}, token);
+        const responseText = await getTextResponseFromStream(response);
+        const parsedAnswers = this.parseAnswers(responseText, carousel);
+        if (parsedAnswers.size > 0 || token.isCancellationRequested) {
+            return parsedAnswers;
+        }
+        const retryPrompt = this.buildPrompt(carousel, requestMessageText, true);
+        const retryResponse = await this.languageModelsService.sendChatRequest(modelId, undefined, [{
+            role: ChatMessageRole.User,
+            content: [{
+                type: "text",
+                value: retryPrompt
+            }]
+        }], {}, token);
+        const retryText = await getTextResponseFromStream(retryResponse);
+        return this.parseAnswers(retryText, carousel);
+    }
+    parseAnswers(responseText, carousel) {
+        const parsed = this.tryParseJsonObject(responseText);
+        if (!parsed) {
+            return ( new Map());
+        }
+        const answers = ( new Map());
+        for (const question of carousel.questions) {
+            const rawAnswer = parsed[question.id];
+            const resolved = this.resolveAnswerFromRaw(question, rawAnswer);
+            if (resolved !== undefined) {
+                answers.set(question.id, resolved);
+            }
+        }
+        return answers;
+    }
+    mergeAnswers(carousel, resolvedAnswers, fallbackAnswers) {
+        const merged = ( new Map());
+        for (const question of carousel.questions) {
+            const fallback = fallbackAnswers.get(question.id);
+            if (this.hasDefaultValue(question) && fallback !== undefined) {
+                merged.set(question.id, fallback);
+                continue;
+            }
+            if (( resolvedAnswers.has(question.id))) {
+                merged.set(question.id, resolvedAnswers.get(question.id));
+                continue;
+            }
+            if (fallback !== undefined) {
+                merged.set(question.id, fallback);
+            }
+        }
+        return merged;
+    }
+    hasDefaultValue(question) {
+        switch (question.type) {
+        case "text":
+            return question.defaultValue !== undefined;
+        case "singleSelect":
+            return typeof question.defaultValue === "string";
+        case "multiSelect":
+            return Array.isArray(question.defaultValue) ? question.defaultValue.length > 0 : typeof question.defaultValue === "string";
+        }
+    }
+    resolveAnswerFromRaw(question, raw) {
+        switch (question.type) {
+        case "text":
+            {
+                if (typeof raw === "string") {
+                    const value = raw.trim();
+                    return value.length > 0 ? value : undefined;
+                }
+                if (raw && typeof raw === "object" && hasKey(raw, {
+                    value: true
+                }) && typeof raw.value === "string") {
+                    const value = raw.value.trim();
+                    return value.length > 0 ? value : undefined;
+                }
+                return undefined;
+            }
+        case "singleSelect":
+            {
+                let selectedInput;
+                let freeformInput;
+                if (typeof raw === "string") {
+                    selectedInput = raw;
+                } else if (raw && typeof raw === "object") {
+                    if (hasKey(raw, {
+                        selectedId: true
+                    }) && typeof raw.selectedId === "string") {
+                        selectedInput = raw.selectedId;
+                    } else if (hasKey(raw, {
+                        selectedLabel: true
+                    }) && typeof raw.selectedLabel === "string") {
+                        selectedInput = raw.selectedLabel;
+                    }
+                    if (hasKey(raw, {
+                        freeform: true
+                    }) && typeof raw.freeform === "string") {
+                        freeformInput = raw.freeform;
+                    }
+                }
+                if (freeformInput && freeformInput.trim().length > 0) {
+                    return {
+                        selectedValue: undefined,
+                        freeformValue: freeformInput.trim()
+                    };
+                }
+                const match = selectedInput ? this.matchQuestionOption(question, selectedInput) : undefined;
+                if (match) {
+                    return {
+                        selectedValue: match.value,
+                        freeformValue: undefined
+                    };
+                }
+                return undefined;
+            }
+        case "multiSelect":
+            {
+                let selectedInputs = [];
+                let freeformInput;
+                if (Array.isArray(raw)) {
+                    selectedInputs = raw.filter(item => typeof item === "string");
+                } else if (typeof raw === "string") {
+                    selectedInputs = ( raw.split(",").map(item => item.trim())).filter(item => item.length > 0);
+                } else if (raw && typeof raw === "object") {
+                    if (hasKey(raw, {
+                        selectedIds: true
+                    })) {
+                        const selectedIdsValue = raw.selectedIds;
+                        if (Array.isArray(selectedIdsValue)) {
+                            selectedInputs = selectedIdsValue.filter(item => typeof item === "string");
+                        }
+                    }
+                    if (hasKey(raw, {
+                        freeform: true
+                    }) && typeof raw.freeform === "string") {
+                        freeformInput = raw.freeform;
+                    }
+                }
+                const selectedValues = ( selectedInputs.map(input => this.matchQuestionOption(question, input)?.value)).filter(value => value !== undefined);
+                const freeformValue = freeformInput?.trim();
+                if (selectedValues.length > 0 || (freeformValue && freeformValue.length > 0)) {
+                    return {
+                        selectedValues,
+                        freeformValue
+                    };
+                }
+                return undefined;
+            }
+        }
+    }
+    matchQuestionOption(question, rawInput) {
+        const options = question.options ?? [];
+        if (!options.length) {
+            return undefined;
+        }
+        const normalized = rawInput.trim().toLowerCase();
+        const numeric = Number.parseInt(normalized, 10);
+        if (!Number.isNaN(numeric) && numeric > 0 && numeric <= options.length) {
+            const option = options[numeric - 1];
+            return {
+                id: option.id,
+                value: option.value
+            };
+        }
+        const exactId = options.find(option => option.id.toLowerCase() === normalized);
+        if (exactId) {
+            return {
+                id: exactId.id,
+                value: exactId.value
+            };
+        }
+        const exactLabel = options.find(option => option.label.toLowerCase() === normalized);
+        if (exactLabel) {
+            return {
+                id: exactLabel.id,
+                value: exactLabel.value
+            };
+        }
+        const partialLabel = options.find(option => option.label.toLowerCase().includes(normalized));
+        if (partialLabel) {
+            return {
+                id: partialLabel.id,
+                value: partialLabel.value
+            };
+        }
+        return undefined;
+    }
+    buildFallbackCarouselAnswers(carousel, requestMessageText) {
+        const answers = ( new Map());
+        for (const question of carousel.questions) {
+            const answer = this.getFallbackAnswerForQuestion(question, requestMessageText);
+            if (answer !== undefined) {
+                answers.set(question.id, answer);
+            }
+        }
+        return answers;
+    }
+    getFallbackAnswerForQuestion(question, requestMessageText) {
+        const fallbackFreeform = requestMessageText?.trim() || ( localize(6759, "OK"));
+        switch (question.type) {
+        case "text":
+            return question.defaultValue ?? fallbackFreeform;
+        case "singleSelect":
+            {
+                const defaultOptionId = typeof question.defaultValue === "string" ? question.defaultValue : undefined;
+                const defaultOption = defaultOptionId ? question.options?.find(opt => opt.id === defaultOptionId) : undefined;
+                if (defaultOption) {
+                    return {
+                        selectedValue: defaultOption.value,
+                        freeformValue: undefined
+                    };
+                }
+                if (question.options && question.options.length > 0) {
+                    return {
+                        selectedValue: question.options[0].value,
+                        freeformValue: undefined
+                    };
+                }
+                if (question.allowFreeformInput) {
+                    return {
+                        selectedValue: undefined,
+                        freeformValue: fallbackFreeform
+                    };
+                }
+                return undefined;
+            }
+        case "multiSelect":
+            {
+                const defaultIds = Array.isArray(question.defaultValue) ? question.defaultValue : (typeof question.defaultValue === "string" ? [question.defaultValue] : []);
+                const selectedValues = question.options?.filter(opt => defaultIds.includes(opt.id)).map(opt => opt.value).filter(value => value !== undefined) ?? [];
+                if (selectedValues.length > 0) {
+                    return {
+                        selectedValues,
+                        freeformValue: undefined
+                    };
+                }
+                if (question.options && question.options.length > 0) {
+                    return {
+                        selectedValues: [question.options[0].value],
+                        freeformValue: undefined
+                    };
+                }
+                if (question.allowFreeformInput) {
+                    return {
+                        selectedValues: [],
+                        freeformValue: fallbackFreeform
+                    };
+                }
+                return undefined;
+            }
+        }
+    }
+    tryParseJsonObject(text) {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const start = trimmed.indexOf("{");
+        const end = trimmed.lastIndexOf("}");
+        const candidate = start >= 0 && end > start ? trimmed.slice(start, end + 1) : trimmed;
+        try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        } catch {
+            return undefined;
+        }
+        return undefined;
+    }
+};
+ChatQuestionCarouselAutoReply = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IDialogService)), ( __param(2, ILogService)), ( __param(3, IStorageService)), ( __param(4, ILanguageModelsService))], ChatQuestionCarouselAutoReply));
+
+export { ChatQuestionCarouselAutoReply };