@codingame/monaco-vscode-katex-common 28.4.1 → 29.1.0

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

@@ -1,440 +0,0 @@
-
-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 };