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

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

@@ -0,0 +1,664 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, addDisposableListener, EventType, EventHelper, getActiveElement, isHTMLElement, isHTMLInputElement, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { renderIcon, renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ActionListItemKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { TelemetryTrustedValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { MANAGE_CHAT_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { isProUser, ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { semverExports } from '@codingame/monaco-vscode-api/_virtual/semver';
+import { StateType } from '@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update';
+import { IUpdateService } from '@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+function isVersionAtLeast(current, required) {
+    const currentSemver = semverExports.coerce(current);
+    if (!currentSemver) {
+        return false;
+    }
+    return semverExports.gte(currentSemver, required);
+}
+function getUpdateHoverContent(updateState) {
+    const hoverContent = ( new MarkdownString("", {
+        isTrusted: true,
+        supportThemeIcons: true
+    }));
+    switch (updateState) {
+    case StateType.AvailableForDownload:
+        hoverContent.appendMarkdown(( localize(
+            6788,
+            "This model requires a newer version of VS Code. [Download Update](command:update.downloadUpdate) to access it."
+        )));
+        break;
+    case StateType.Downloaded:
+    case StateType.Ready:
+        hoverContent.appendMarkdown(( localize(
+            6789,
+            "This model requires a newer version of VS Code. [Restart to Update](command:update.restartToUpdate) to access it."
+        )));
+        break;
+    default:
+        hoverContent.appendMarkdown(( localize(
+            6790,
+            "This model requires a newer version of VS Code. [Update VS Code](command:update.checkForUpdate) to access it."
+        )));
+        break;
+    }
+    return hoverContent;
+}
+const ModelPickerSection = {
+    Other: "other"
+};
+function createModelItem(action, model) {
+    return {
+        item: action,
+        kind: ActionListItemKind.Action,
+        label: action.label,
+        description: action.description,
+        group: {
+            title: "",
+            icon: action.icon ?? ThemeIcon.fromId(action.checked ? Codicon.check.id : Codicon.blank.id)
+        },
+        hideIcon: false,
+        section: action.section,
+        hover: model ? {
+            content: getModelHoverContent(model)
+        } : undefined
+    };
+}
+function createModelAction(model, selectedModelId, onSelect, section) {
+    return {
+        id: model.identifier,
+        enabled: true,
+        icon: model.metadata.statusIcon,
+        checked: model.identifier === selectedModelId,
+        class: undefined,
+        description: model.metadata.multiplier ?? model.metadata.detail,
+        tooltip: model.metadata.name,
+        label: model.metadata.name,
+        section,
+        run: () => onSelect(model)
+    };
+}
+function buildModelPickerItems(
+    models,
+    selectedModelId,
+    recentModelIds,
+    controlModels,
+    currentVSCodeVersion,
+    updateStateType,
+    onSelect,
+    manageSettingsUrl,
+    canManageModels,
+    commandService,
+    chatEntitlementService
+) {
+    const items = [];
+    if (models.length === 0) {
+        items.push(createModelItem({
+            id: "auto",
+            enabled: true,
+            checked: true,
+            class: undefined,
+            tooltip: ( localize(6791, "Auto")),
+            label: ( localize(6791, "Auto")),
+            run: () => {}
+        }));
+    }
+    if (!canManageModels) {
+        const autoModel = models.find(m => m.metadata.id === "auto" && m.metadata.vendor === "copilot");
+        if (autoModel) {
+            items.push(
+                createModelItem(createModelAction(autoModel, selectedModelId, onSelect), autoModel)
+            );
+        }
+        const sortedModels = models.filter(m => m !== autoModel).sort((a, b) => {
+            const vendorCmp = a.metadata.vendor.localeCompare(b.metadata.vendor);
+            return vendorCmp !== 0 ? vendorCmp : a.metadata.name.localeCompare(b.metadata.name);
+        });
+        for (const model of sortedModels) {
+            items.push(
+                createModelItem(createModelAction(model, selectedModelId, onSelect), model)
+            );
+        }
+        return items;
+    }
+    const isPro = isProUser(chatEntitlementService.entitlement);
+    let otherModels = [];
+    if (models.length) {
+        const allModelsMap = ( new Map());
+        const modelsByMetadataId = ( new Map());
+        for (const model of models) {
+            allModelsMap.set(model.identifier, model);
+            modelsByMetadataId.set(model.metadata.id, model);
+        }
+        const placed = ( new Set());
+        const markPlaced = (identifierOrId, metadataId) => {
+            placed.add(identifierOrId);
+            if (metadataId) {
+                placed.add(metadataId);
+            }
+        };
+        const resolveModel = id => allModelsMap.get(id) ?? modelsByMetadataId.get(id);
+        const getUnavailableReason = entry => {
+            if (!isPro) {
+                return "upgrade";
+            }
+            if (entry.minVSCodeVersion && !isVersionAtLeast(currentVSCodeVersion, entry.minVSCodeVersion)) {
+                return "update";
+            }
+            return "admin";
+        };
+        const autoModel = models.find(m => m.metadata.id === "auto" && m.metadata.vendor === "copilot");
+        if (autoModel) {
+            markPlaced(autoModel.identifier, autoModel.metadata.id);
+            items.push(
+                createModelItem(createModelAction(autoModel, selectedModelId, onSelect), autoModel)
+            );
+        }
+        const promotedItems = [];
+        const tryPlaceModel = id => {
+            if (( placed.has(id))) {
+                return false;
+            }
+            const model = resolveModel(id);
+            if (model && !( placed.has(model.identifier))) {
+                markPlaced(model.identifier, model.metadata.id);
+                const entry = controlModels[model.metadata.id];
+                if (entry?.minVSCodeVersion && !isVersionAtLeast(currentVSCodeVersion, entry.minVSCodeVersion)) {
+                    promotedItems.push({
+                        kind: "unavailable",
+                        id: model.metadata.id,
+                        entry,
+                        reason: "update"
+                    });
+                } else {
+                    promotedItems.push({
+                        kind: "available",
+                        model
+                    });
+                }
+                return true;
+            }
+            if (!model) {
+                const entry = controlModels[id];
+                if (entry && !entry.exists) {
+                    markPlaced(id);
+                    promotedItems.push({
+                        kind: "unavailable",
+                        id,
+                        entry,
+                        reason: getUnavailableReason(entry)
+                    });
+                    return true;
+                }
+            }
+            return false;
+        };
+        if (selectedModelId && selectedModelId !== autoModel?.identifier) {
+            tryPlaceModel(selectedModelId);
+        }
+        for (const id of recentModelIds) {
+            tryPlaceModel(id);
+        }
+        for (const [entryId, entry] of Object.entries(controlModels)) {
+            if (!entry.featured || ( placed.has(entryId))) {
+                continue;
+            }
+            const model = resolveModel(entryId);
+            if (model && !( placed.has(model.identifier))) {
+                markPlaced(model.identifier, model.metadata.id);
+                if (entry.minVSCodeVersion && !isVersionAtLeast(currentVSCodeVersion, entry.minVSCodeVersion)) {
+                    promotedItems.push({
+                        kind: "unavailable",
+                        id: entryId,
+                        entry,
+                        reason: "update"
+                    });
+                } else {
+                    promotedItems.push({
+                        kind: "available",
+                        model
+                    });
+                }
+            } else if (!model && !entry.exists) {
+                markPlaced(entryId);
+                promotedItems.push({
+                    kind: "unavailable",
+                    id: entryId,
+                    entry,
+                    reason: getUnavailableReason(entry)
+                });
+            }
+        }
+        if (promotedItems.length > 0) {
+            promotedItems.sort((a, b) => {
+                const aAvail = a.kind === "available" ? 0 : 1;
+                const bAvail = b.kind === "available" ? 0 : 1;
+                if (aAvail !== bAvail) {
+                    return aAvail - bAvail;
+                }
+                const aName = a.kind === "available" ? a.model.metadata.name : a.entry.label;
+                const bName = b.kind === "available" ? b.model.metadata.name : b.entry.label;
+                return aName.localeCompare(bName);
+            });
+            for (const item of promotedItems) {
+                if (item.kind === "available") {
+                    items.push(
+                        createModelItem(createModelAction(item.model, selectedModelId, onSelect), item.model)
+                    );
+                } else {
+                    items.push(
+                        createUnavailableModelItem(item.id, item.entry, item.reason, manageSettingsUrl, updateStateType)
+                    );
+                }
+            }
+        }
+        otherModels = models.filter(m => !( placed.has(m.identifier)) && !( placed.has(m.metadata.id))).sort((a, b) => {
+            const aEntry = controlModels[a.metadata.id] ?? controlModels[a.identifier];
+            const bEntry = controlModels[b.metadata.id] ?? controlModels[b.identifier];
+            const aAvail = aEntry?.minVSCodeVersion && !isVersionAtLeast(currentVSCodeVersion, aEntry.minVSCodeVersion) ? 1 : 0;
+            const bAvail = bEntry?.minVSCodeVersion && !isVersionAtLeast(currentVSCodeVersion, bEntry.minVSCodeVersion) ? 1 : 0;
+            if (aAvail !== bAvail) {
+                return aAvail - bAvail;
+            }
+            const aCopilot = a.metadata.vendor === "copilot" ? 0 : 1;
+            const bCopilot = b.metadata.vendor === "copilot" ? 0 : 1;
+            if (aCopilot !== bCopilot) {
+                return aCopilot - bCopilot;
+            }
+            const vendorCmp = a.metadata.vendor.localeCompare(b.metadata.vendor);
+            return vendorCmp !== 0 ? vendorCmp : a.metadata.name.localeCompare(b.metadata.name);
+        });
+        if (otherModels.length > 0) {
+            if (items.length > 0) {
+                items.push({
+                    kind: ActionListItemKind.Separator
+                });
+            }
+            items.push({
+                item: {
+                    id: "otherModels",
+                    enabled: true,
+                    checked: false,
+                    class: undefined,
+                    tooltip: ( localize(6792, "Other Models")),
+                    label: ( localize(6792, "Other Models")),
+                    run: () => {}
+                },
+                kind: ActionListItemKind.Action,
+                label: ( localize(6792, "Other Models")),
+                group: {
+                    title: "",
+                    icon: Codicon.chevronDown
+                },
+                hideIcon: false,
+                section: ModelPickerSection.Other,
+                isSectionToggle: true
+            });
+            for (const model of otherModels) {
+                const entry = controlModels[model.metadata.id] ?? controlModels[model.identifier];
+                if (entry?.minVSCodeVersion && !isVersionAtLeast(currentVSCodeVersion, entry.minVSCodeVersion)) {
+                    items.push(createUnavailableModelItem(
+                        model.metadata.id,
+                        entry,
+                        "update",
+                        manageSettingsUrl,
+                        updateStateType,
+                        ModelPickerSection.Other
+                    ));
+                } else {
+                    items.push(createModelItem(
+                        createModelAction(model, selectedModelId, onSelect, ModelPickerSection.Other),
+                        model
+                    ));
+                }
+            }
+        }
+    }
+    if (chatEntitlementService.entitlement === ChatEntitlement.Free || chatEntitlementService.entitlement === ChatEntitlement.Pro || chatEntitlementService.entitlement === ChatEntitlement.ProPlus || chatEntitlementService.entitlement === ChatEntitlement.Business || chatEntitlementService.entitlement === ChatEntitlement.Enterprise || chatEntitlementService.isInternal) {
+        items.push({
+            kind: ActionListItemKind.Separator,
+            section: otherModels.length ? ModelPickerSection.Other : undefined
+        });
+        items.push({
+            item: {
+                id: "manageModels",
+                enabled: true,
+                checked: false,
+                class: undefined,
+                tooltip: ( localize(6793, "Manage Language Models")),
+                label: ( localize(6794, "Manage Models...")),
+                run: () => {
+                    commandService.executeCommand(MANAGE_CHAT_COMMAND_ID);
+                }
+            },
+            kind: ActionListItemKind.Action,
+            label: ( localize(6794, "Manage Models...")),
+            group: {
+                title: "",
+                icon: Codicon.blank
+            },
+            hideIcon: false,
+            section: otherModels.length ? ModelPickerSection.Other : undefined,
+            showAlways: true
+        });
+    }
+    return items;
+}
+function getModelPickerAccessibilityProvider() {
+    return {
+        isChecked(element) {
+            return element.kind === ActionListItemKind.Action ? !!element?.item?.checked : undefined;
+        },
+        getRole: element => {
+            switch (element.kind) {
+            case ActionListItemKind.Action:
+                return "menuitemradio";
+            case ActionListItemKind.Separator:
+                return "separator";
+            default:
+                return "separator";
+            }
+        },
+        getWidgetRole: () => "menu"
+    };
+}
+function createUnavailableModelItem(id, entry, reason, manageSettingsUrl, updateStateType, section) {
+    let description;
+    if (reason === "upgrade") {
+        description = ( new MarkdownString(( localize(6795, "[Upgrade](command:workbench.action.chat.upgradePlan \" \")")), {
+            isTrusted: true
+        }));
+    } else if (reason === "update") {
+        description = ( localize(6796, "Update VS Code"));
+    } else {
+        description = manageSettingsUrl ? ( new MarkdownString(( localize(6797, "[Contact your admin]({0})", manageSettingsUrl)), {
+            isTrusted: true
+        })) : ( localize(6798, "Contact your admin"));
+    }
+    let hoverContent;
+    if (reason === "upgrade") {
+        hoverContent = ( new MarkdownString("", {
+            isTrusted: true,
+            supportThemeIcons: true
+        }));
+        hoverContent.appendMarkdown(( localize(
+            6799,
+            "[Upgrade to GitHub Copilot Pro](command:workbench.action.chat.upgradePlan \" \") with a free 30-day trial to use the best models."
+        )));
+    } else if (reason === "update") {
+        hoverContent = getUpdateHoverContent(updateStateType);
+    } else {
+        hoverContent = ( new MarkdownString("", {
+            isTrusted: true,
+            supportThemeIcons: true
+        }));
+        hoverContent.appendMarkdown(( localize(
+            6800,
+            "This model is not available. Contact your administrator to enable it."
+        )));
+    }
+    return {
+        item: {
+            id,
+            enabled: false,
+            checked: false,
+            class: undefined,
+            tooltip: entry.label,
+            label: entry.label,
+            description: typeof description === "string" ? description : undefined,
+            run: () => {}
+        },
+        kind: ActionListItemKind.Action,
+        label: entry.label,
+        description,
+        group: {
+            title: "",
+            icon: ThemeIcon.fromId(Codicon.blank.id)
+        },
+        disabled: true,
+        hideIcon: false,
+        className: "chat-model-picker-unavailable",
+        section,
+        hover: {
+            content: hoverContent
+        }
+    };
+}
+let ModelPickerWidget = class ModelPickerWidget extends Disposable {
+    get selectedModel() {
+        return this._selectedModel;
+    }
+    get domNode() {
+        return this._domNode;
+    }
+    constructor(
+        _delegate,
+        _actionWidgetService,
+        _commandService,
+        _telemetryService,
+        _languageModelsService,
+        _productService,
+        _entitlementService,
+        _updateService
+    ) {
+        super();
+        this._delegate = _delegate;
+        this._actionWidgetService = _actionWidgetService;
+        this._commandService = _commandService;
+        this._telemetryService = _telemetryService;
+        this._languageModelsService = _languageModelsService;
+        this._productService = _productService;
+        this._entitlementService = _entitlementService;
+        this._updateService = _updateService;
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+    }
+    setHideChevrons(hideChevrons) {
+        this._hideChevrons = hideChevrons;
+        this._register(autorun(reader => {
+            const hide = hideChevrons.read(reader);
+            if (this._domNode) {
+                this._domNode.classList.toggle("hide-chevrons", hide);
+            }
+            this._renderLabel();
+        }));
+    }
+    setSelectedModel(model) {
+        this._selectedModel = model;
+        this._renderLabel();
+    }
+    setBadge(badge) {
+        this._badge = badge;
+        this._updateBadge();
+    }
+    render(container) {
+        this._domNode = append(container, $("a.action-label"));
+        this._domNode.tabIndex = 0;
+        this._domNode.setAttribute("role", "button");
+        this._domNode.setAttribute("aria-haspopup", "true");
+        this._domNode.setAttribute("aria-expanded", "false");
+        if (this._hideChevrons?.get()) {
+            this._domNode.classList.toggle("hide-chevrons", true);
+        }
+        this._badgeIcon = append(this._domNode, $("span.model-picker-badge"));
+        this._updateBadge();
+        this._renderLabel();
+        this._register(addDisposableListener(this._domNode, EventType.MOUSE_DOWN, e => {
+            if (e.button !== 0) {
+                return;
+            }
+            EventHelper.stop(e, true);
+            this.show();
+        }));
+        this._register(addDisposableListener(this._domNode, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(e, true);
+                this.show();
+            }
+        }));
+    }
+    show(anchor) {
+        const anchorElement = anchor ?? this._domNode;
+        if (!anchorElement) {
+            return;
+        }
+        const previousModel = this._selectedModel;
+        const onSelect = model => {
+            this._telemetryService.publicLog2("chat.modelChange", {
+                fromModel: previousModel?.metadata.vendor === "copilot" ? ( new TelemetryTrustedValue(previousModel.identifier)) : "unknown",
+                toModel: model.metadata.vendor === "copilot" ? ( new TelemetryTrustedValue(model.identifier)) : "unknown"
+            });
+            this._selectedModel = model;
+            this._renderLabel();
+            this._onDidChangeSelection.fire(model);
+        };
+        const models = this._delegate.getModels();
+        const isPro = isProUser(this._entitlementService.entitlement);
+        const manifest = this._languageModelsService.getModelsControlManifest();
+        const controlModelsForTier = isPro ? manifest.paid : manifest.free;
+        const items = buildModelPickerItems(
+            models,
+            this._selectedModel?.identifier,
+            this._languageModelsService.getRecentlyUsedModelIds(),
+            controlModelsForTier,
+            this._productService.version,
+            this._updateService.state.type,
+            onSelect,
+            this._productService.defaultChatAgent?.manageSettingsUrl,
+            this._delegate.canManageModels(),
+            this._commandService,
+            this._entitlementService
+        );
+        const listOptions = {
+            showFilter: models.length >= 10,
+            filterPlaceholder: ( localize(6801, "Search models")),
+            focusFilterOnOpen: true,
+            collapsedByDefault: ( new Set([ModelPickerSection.Other])),
+            minWidth: 200
+        };
+        const previouslyFocusedElement = getActiveElement();
+        const delegate = {
+            onSelect: action => {
+                this._actionWidgetService.hide();
+                action.run();
+            },
+            onHide: () => {
+                this._domNode?.setAttribute("aria-expanded", "false");
+                if (isHTMLElement(previouslyFocusedElement)) {
+                    previouslyFocusedElement.focus();
+                }
+            }
+        };
+        this._domNode?.setAttribute("aria-expanded", "true");
+        this._actionWidgetService.show(
+            "ChatModelPicker",
+            false,
+            items,
+            delegate,
+            anchorElement,
+            undefined,
+            [],
+            getModelPickerAccessibilityProvider(),
+            listOptions
+        );
+        const activeElement = getActiveElement();
+        if (isHTMLInputElement(activeElement) && activeElement.classList.contains("action-list-filter-input")) {
+            activeElement.classList.add("chat-model-picker-filter-input");
+        }
+    }
+    _updateBadge() {
+        if (this._badgeIcon) {
+            if (this._badge) {
+                const icon = this._badge === "info" ? Codicon.info : Codicon.warning;
+                reset(this._badgeIcon, renderIcon(icon));
+                this._badgeIcon.style.display = "";
+                this._badgeIcon.classList.toggle("info", this._badge === "info");
+                this._badgeIcon.classList.toggle("warning", this._badge === "warning");
+            } else {
+                this._badgeIcon.style.display = "none";
+            }
+        }
+    }
+    _renderLabel() {
+        if (!this._domNode) {
+            return;
+        }
+        const {
+            name,
+            statusIcon
+        } = this._selectedModel?.metadata || {};
+        const domChildren = [];
+        if (statusIcon) {
+            const iconElement = renderIcon(statusIcon);
+            domChildren.push(iconElement);
+        }
+        domChildren.push($("span.chat-input-picker-label", undefined, name ?? ( localize(6791, "Auto"))));
+        if (this._badgeIcon) {
+            domChildren.push(this._badgeIcon);
+        }
+        domChildren.push(...renderLabelWithIcons(`$(chevron-down)`));
+        reset(this._domNode, ...domChildren);
+        const modelName = this._selectedModel?.metadata.name ?? ( localize(6791, "Auto"));
+        this._domNode.ariaLabel = ( localize(6802, "Pick Model, {0}", modelName));
+    }
+};
+ModelPickerWidget = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, ICommandService)), ( __param(3, ITelemetryService)), ( __param(4, ILanguageModelsService)), ( __param(5, IProductService)), ( __param(6, IChatEntitlementService)), ( __param(7, IUpdateService))], ModelPickerWidget));
+function getModelHoverContent(model) {
+    const isAuto = model.metadata.id === "auto" && model.metadata.vendor === "copilot";
+    const markdown = ( new MarkdownString("", {
+        isTrusted: true,
+        supportThemeIcons: true
+    }));
+    markdown.appendMarkdown(`**${model.metadata.name}**`);
+    markdown.appendText(`\n`);
+    if (model.metadata.statusIcon && model.metadata.tooltip) {
+        if (model.metadata.statusIcon) {
+            markdown.appendMarkdown(`$(${model.metadata.statusIcon.id}) `);
+        }
+        markdown.appendMarkdown(`${model.metadata.tooltip}`);
+        markdown.appendText(`\n`);
+    }
+    if (model.metadata.multiplier) {
+        markdown.appendMarkdown(`${( localize(
+            6803,
+            "Each chat message counts {0} toward your premium request quota",
+            model.metadata.multiplier
+        ))}`);
+        markdown.appendText(`\n`);
+    }
+    if (!isAuto && (model.metadata.maxInputTokens || model.metadata.maxOutputTokens)) {
+        const totalTokens = (model.metadata.maxInputTokens ?? 0) + (model.metadata.maxOutputTokens ?? 0);
+        markdown.appendMarkdown(`${( localize(6804, "Context Size"))}: `);
+        markdown.appendMarkdown(`${formatTokenCount(totalTokens)}`);
+        markdown.appendText(`\n`);
+    }
+    return markdown;
+}
+function formatTokenCount(count) {
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1)}M`;
+    } else if (count >= 1000) {
+        return `${(count / 1000).toFixed(0)}K`;
+    }
+    return ( count.toString());
+}
+
+export { ModelPickerWidget, buildModelPickerItems, getModelPickerAccessibilityProvider };