miladyai 2.0.0-alpha.27

package/dist/triggers/scheduling.js

@@ -0,0 +1,295 @@
+import { TRIGGER_SCHEMA_VERSION } from "./types.js";
+
+//#region src/triggers/scheduling.ts
+const MIN_TRIGGER_INTERVAL_MS = 6e4;
+const MAX_TRIGGER_INTERVAL_MS = 744 * 60 * 60 * 1e3;
+const DISABLED_TRIGGER_INTERVAL_MS = 365 * 24 * 60 * 60 * 1e3;
+const MAX_TRIGGER_RUN_HISTORY = 100;
+const CRON_FIELDS = 5;
+const CRON_SCAN_WINDOW_MS = 366 * 24 * 60 * 60 * 1e3;
+const CRON_MINUTE_MS = 6e4;
+const CRON_RANGES = [
+	{
+		min: 0,
+		max: 59
+	},
+	{
+		min: 0,
+		max: 23
+	},
+	{
+		min: 1,
+		max: 31
+	},
+	{
+		min: 1,
+		max: 12
+	},
+	{
+		min: 0,
+		max: 6
+	}
+];
+function parseInteger(raw) {
+	if (!/^-?\d+$/.test(raw)) return null;
+	const value = Number(raw);
+	if (!Number.isFinite(value)) return null;
+	return value;
+}
+function clamp(value, min, max) {
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+}
+function normalizeText(value) {
+	return value.trim().replace(/\s+/g, " ");
+}
+function parseCronPart(part, range) {
+	const output = /* @__PURE__ */ new Set();
+	const chunks = part.split(",");
+	for (const chunkRaw of chunks) {
+		const chunk = chunkRaw.trim();
+		if (!chunk) return null;
+		const stepParts = chunk.split("/");
+		if (stepParts.length > 2) return null;
+		const step = stepParts.length === 2 ? parseInteger(stepParts[1].trim()) : 1;
+		if (step === null || step <= 0) return null;
+		const base = stepParts[0].trim();
+		if (base === "*") {
+			for (let value = range.min; value <= range.max; value += step) output.add(value);
+			continue;
+		}
+		const rangeParts = base.split("-");
+		if (rangeParts.length === 1) {
+			const single = parseInteger(rangeParts[0].trim());
+			if (single === null) return null;
+			if (single < range.min || single > range.max) return null;
+			output.add(single);
+			continue;
+		}
+		if (rangeParts.length !== 2) return null;
+		const start = parseInteger(rangeParts[0].trim());
+		const end = parseInteger(rangeParts[1].trim());
+		if (start === null || end === null) return null;
+		if (start > end) return null;
+		if (start < range.min || end > range.max) return null;
+		for (let value = start; value <= end; value += step) output.add(value);
+	}
+	return output.size > 0 ? output : null;
+}
+function parseCronExpression(expression) {
+	const trimmed = expression.trim();
+	if (!trimmed) return null;
+	const parts = trimmed.split(/\s+/);
+	if (parts.length !== CRON_FIELDS) return null;
+	const minute = parseCronPart(parts[0], CRON_RANGES[0]);
+	const hour = parseCronPart(parts[1], CRON_RANGES[1]);
+	const dayOfMonth = parseCronPart(parts[2], CRON_RANGES[2]);
+	const month = parseCronPart(parts[3], CRON_RANGES[3]);
+	const dayOfWeek = parseCronPart(parts[4], CRON_RANGES[4]);
+	if (!minute || !hour || !dayOfMonth || !month || !dayOfWeek) return null;
+	return {
+		minute,
+		hour,
+		dayOfMonth,
+		month,
+		dayOfWeek
+	};
+}
+function cronMatchesUTC(schedule, candidateMs) {
+	const candidate = new Date(candidateMs);
+	return schedule.minute.has(candidate.getUTCMinutes()) && schedule.hour.has(candidate.getUTCHours()) && schedule.dayOfMonth.has(candidate.getUTCDate()) && schedule.month.has(candidate.getUTCMonth() + 1) && schedule.dayOfWeek.has(candidate.getUTCDay());
+}
+/**
+* Get the UTC offset in milliseconds for a given IANA timezone.
+* Returns 0 if the timezone is invalid or not provided.
+*/
+function getTimezoneOffsetMs(timezone, atMs) {
+	if (!timezone || timezone === "UTC") return 0;
+	try {
+		const parts = new Intl.DateTimeFormat("en-US", {
+			timeZone: timezone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			hour12: false
+		}).formatToParts(new Date(atMs));
+		const get = (type) => {
+			const part = parts.find((p) => p.type === type);
+			return part ? Number(part.value) : 0;
+		};
+		return Date.UTC(get("year"), get("month") - 1, get("day"), get("hour"), get("minute"), get("second")) - atMs;
+	} catch {
+		return 0;
+	}
+}
+function cronMatches(schedule, candidateMs, timezone) {
+	if (!timezone || timezone === "UTC") return cronMatchesUTC(schedule, candidateMs);
+	return cronMatchesUTC(schedule, candidateMs + getTimezoneOffsetMs(timezone, candidateMs));
+}
+function computeNextCronRunAtMs(expression, fromMs, timezone) {
+	const schedule = parseCronExpression(expression);
+	if (!schedule) return null;
+	const start = Math.floor(fromMs / CRON_MINUTE_MS) * CRON_MINUTE_MS;
+	const cutoff = start + CRON_SCAN_WINDOW_MS;
+	for (let candidate = start + CRON_MINUTE_MS; candidate <= cutoff; candidate += CRON_MINUTE_MS) if (cronMatches(schedule, candidate, timezone)) return candidate;
+	return null;
+}
+function parseScheduledAtIso(scheduledAtIso) {
+	const parsed = Date.parse(scheduledAtIso);
+	if (!Number.isFinite(parsed)) return null;
+	return parsed;
+}
+function normalizeTriggerIntervalMs(intervalMs) {
+	if (!Number.isFinite(intervalMs)) return MIN_TRIGGER_INTERVAL_MS;
+	return clamp(Math.floor(intervalMs), MIN_TRIGGER_INTERVAL_MS, MAX_TRIGGER_INTERVAL_MS);
+}
+function resolveTriggerTiming(trigger, nowMs) {
+	if (!trigger.enabled) return null;
+	if (trigger.triggerType === "interval") {
+		const intervalMs = normalizeTriggerIntervalMs(trigger.intervalMs ?? 0);
+		return {
+			updatedAt: nowMs,
+			updateIntervalMs: intervalMs,
+			nextRunAtMs: nowMs + intervalMs
+		};
+	}
+	if (trigger.triggerType === "once") {
+		const scheduledAt = trigger.scheduledAtIso ? parseScheduledAtIso(trigger.scheduledAtIso) : null;
+		if (scheduledAt === null) return null;
+		const nextRunAtMs = Math.max(nowMs, scheduledAt);
+		return {
+			updatedAt: nowMs,
+			updateIntervalMs: Math.max(0, nextRunAtMs - nowMs),
+			nextRunAtMs
+		};
+	}
+	const nextRunAtMs = trigger.cronExpression ? computeNextCronRunAtMs(trigger.cronExpression, nowMs, trigger.timezone) : null;
+	if (nextRunAtMs === null) return null;
+	return {
+		updatedAt: nowMs,
+		updateIntervalMs: Math.max(0, nextRunAtMs - nowMs),
+		nextRunAtMs
+	};
+}
+function buildTriggerMetadata(params) {
+	const timing = resolveTriggerTiming(params.trigger, params.nowMs);
+	if (!timing) return null;
+	return {
+		...params.existingMetadata ?? {},
+		blocking: true,
+		updatedAt: timing.updatedAt,
+		updateInterval: timing.updateIntervalMs,
+		trigger: {
+			...params.trigger,
+			nextRunAtMs: timing.nextRunAtMs
+		}
+	};
+}
+function buildTriggerDedupeKey(parts) {
+	const normalized = [
+		parts.triggerType,
+		normalizeText(parts.instructions).toLowerCase(),
+		String(parts.intervalMs ?? ""),
+		parts.scheduledAtIso ?? "",
+		parts.cronExpression ?? "",
+		parts.wakeMode
+	].join("|");
+	let hash = 5381;
+	for (const char of normalized) hash = hash * 33 ^ char.charCodeAt(0);
+	return `trigger-${Math.abs(hash >>> 0).toString(16)}`;
+}
+function buildTriggerConfig(params) {
+	const previous = params.previous;
+	return {
+		version: TRIGGER_SCHEMA_VERSION,
+		triggerId: params.triggerId,
+		displayName: params.draft.displayName,
+		instructions: params.draft.instructions,
+		triggerType: params.draft.triggerType,
+		enabled: params.draft.enabled,
+		wakeMode: params.draft.wakeMode,
+		createdBy: params.draft.createdBy,
+		timezone: params.draft.timezone,
+		intervalMs: params.draft.triggerType === "interval" ? normalizeTriggerIntervalMs(params.draft.intervalMs ?? 0) : void 0,
+		scheduledAtIso: params.draft.triggerType === "once" ? params.draft.scheduledAtIso : void 0,
+		cronExpression: params.draft.triggerType === "cron" ? params.draft.cronExpression : void 0,
+		maxRuns: params.draft.maxRuns,
+		runCount: previous?.runCount ?? 0,
+		dedupeKey: buildTriggerDedupeKey({
+			triggerType: params.draft.triggerType,
+			instructions: params.draft.instructions,
+			intervalMs: params.draft.intervalMs,
+			scheduledAtIso: params.draft.scheduledAtIso,
+			cronExpression: params.draft.cronExpression,
+			wakeMode: params.draft.wakeMode
+		}),
+		nextRunAtMs: previous?.nextRunAtMs,
+		lastRunAtIso: previous?.lastRunAtIso,
+		lastStatus: previous?.lastStatus,
+		lastError: previous?.lastError
+	};
+}
+function normalizeTriggerDraft(params) {
+	const displayName = normalizeText(params.input.displayName ?? "") || normalizeText(params.fallback.displayName);
+	const instructions = normalizeText(params.input.instructions ?? "") || normalizeText(params.fallback.instructions);
+	if (!displayName) return { error: "displayName is required" };
+	if (!instructions) return { error: "instructions is required" };
+	const triggerType = params.input.triggerType ?? params.fallback.triggerType ?? "interval";
+	const wakeMode = params.input.wakeMode ?? params.fallback.wakeMode;
+	const enabled = params.input.enabled ?? params.fallback.enabled;
+	const createdBy = params.input.createdBy ?? params.fallback.createdBy;
+	const timezone = params.input.timezone;
+	const intervalMsRaw = typeof params.input.intervalMs === "number" ? params.input.intervalMs : void 0;
+	const scheduledAtIso = params.input.scheduledAtIso?.trim();
+	const cronExpression = params.input.cronExpression?.trim();
+	const maxRuns = typeof params.input.maxRuns === "number" ? Math.floor(params.input.maxRuns) : void 0;
+	if (wakeMode !== "inject_now" && wakeMode !== "next_autonomy_cycle") return { error: "wakeMode must be inject_now or next_autonomy_cycle" };
+	if (maxRuns !== void 0 && maxRuns <= 0) return { error: "maxRuns must be a positive integer" };
+	if (triggerType === "interval") {
+		if (intervalMsRaw === void 0) return { error: "intervalMs is required for interval triggers" };
+		return { draft: {
+			displayName,
+			instructions,
+			triggerType,
+			wakeMode,
+			enabled,
+			createdBy,
+			timezone,
+			intervalMs: normalizeTriggerIntervalMs(intervalMsRaw),
+			maxRuns
+		} };
+	}
+	if (triggerType === "once") {
+		if (!scheduledAtIso || parseScheduledAtIso(scheduledAtIso) === null) return { error: "scheduledAtIso must be a valid ISO timestamp" };
+		return { draft: {
+			displayName,
+			instructions,
+			triggerType,
+			wakeMode,
+			enabled,
+			createdBy,
+			timezone,
+			scheduledAtIso,
+			maxRuns
+		} };
+	}
+	if (!cronExpression || !parseCronExpression(cronExpression)) return { error: "cronExpression must be a valid 5-field cron expression" };
+	return { draft: {
+		displayName,
+		instructions,
+		triggerType,
+		wakeMode,
+		enabled,
+		createdBy,
+		timezone,
+		cronExpression,
+		maxRuns
+	} };
+}
+
+//#endregion
+export { DISABLED_TRIGGER_INTERVAL_MS, MAX_TRIGGER_RUN_HISTORY, buildTriggerConfig, buildTriggerMetadata, normalizeTriggerDraft };

package/dist/triggers/types.js

@@ -0,0 +1,5 @@
+//#region src/triggers/types.ts
+const TRIGGER_SCHEMA_VERSION = 1;
+
+//#endregion
+export { TRIGGER_SCHEMA_VERSION };

package/dist/tui/components/assistant-message.js

@@ -0,0 +1,76 @@
+import { miladyMarkdownTheme, tuiTheme } from "../theme.js";
+import { Image, Markdown } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/assistant-message.ts
+const imageTheme = { fallbackColor: (s) => tuiTheme.dim(s) };
+/**
+* Assistant message — clean markdown, no prefix.
+* Renders exactly: 1 blank line + markdown content.
+* Thinking traces shown as italic/muted when enabled.
+* Supports inline image attachments.
+*/
+var AssistantMessageComponent = class {
+	constructor(showThinking = false, markdownTheme = miladyMarkdownTheme, _agentName) {
+		this.showThinking = showThinking;
+		this.markdownTheme = markdownTheme;
+		this.thinkingMarkdown = null;
+		this.images = [];
+		this.thinkingText = "";
+		this.responseText = "";
+		this.isStreaming = true;
+		this.markdown = new Markdown("", 1, 0, markdownTheme);
+	}
+	updateContent(text) {
+		this.responseText = text;
+		this.rebuildMarkdown();
+	}
+	updateThinking(text) {
+		this.thinkingText = text;
+		if (this.showThinking) this.rebuildMarkdown();
+	}
+	/** Attach an inline image to render below the message text. */
+	addImage(attachment) {
+		this.images.push(new Image(attachment.base64, attachment.mimeType, imageTheme, {
+			maxWidthCells: 60,
+			maxHeightCells: 20,
+			filename: attachment.filename
+		}));
+	}
+	finalize() {
+		this.isStreaming = false;
+		this.rebuildMarkdown();
+	}
+	render(width) {
+		const thinkingLines = this.showThinking && this.thinkingMarkdown ? this.thinkingMarkdown.render(width) : [];
+		const contentLines = this.markdown.render(width);
+		if (thinkingLines.length === 0 && contentLines.length === 0 && this.images.length === 0) return [];
+		const lines = [""];
+		if (thinkingLines.length > 0) {
+			lines.push(...thinkingLines);
+			if (contentLines.length > 0) lines.push("");
+		}
+		lines.push(...contentLines);
+		for (const img of this.images) {
+			lines.push("");
+			lines.push(...img.render(width));
+		}
+		return lines;
+	}
+	invalidate() {
+		this.markdown.invalidate();
+		this.thinkingMarkdown?.invalidate();
+		for (const img of this.images) img.invalidate();
+	}
+	rebuildMarkdown() {
+		if (this.showThinking && this.thinkingText.trim()) this.thinkingMarkdown = new Markdown(this.thinkingText.trim(), 1, 0, this.markdownTheme, {
+			color: (t) => tuiTheme.muted(t),
+			italic: true
+		});
+		else this.thinkingMarkdown = null;
+		const display = this.responseText + (this.isStreaming && this.responseText ? " ▊" : "");
+		this.markdown.setText(display.trimEnd());
+	}
+};
+
+//#endregion
+export { AssistantMessageComponent };

package/dist/tui/components/chat-editor.js

@@ -0,0 +1,34 @@
+import { Editor, matchesKey } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/chat-editor.ts
+/**
+* Small wrapper around @mariozechner/pi-tui's Editor to support Milady-wide keybindings.
+*/
+var ChatEditor = class extends Editor {
+	handleInput(data) {
+		if (matchesKey(data, "ctrl+c")) {
+			this.onCtrlC?.();
+			return;
+		}
+		if (matchesKey(data, "ctrl+p")) {
+			this.onCtrlP?.();
+			return;
+		}
+		if (matchesKey(data, "ctrl+e")) {
+			this.onCtrlE?.();
+			return;
+		}
+		if (matchesKey(data, "alt+u")) {
+			this.onAltU?.();
+			return;
+		}
+		if (matchesKey(data, "ctrl+g")) {
+			this.onCtrlG?.();
+			return;
+		}
+		super.handleInput(data);
+	}
+};
+
+//#endregion
+export { ChatEditor };

package/dist/tui/components/embeddings-overlay.js

@@ -0,0 +1,46 @@
+import { tuiTheme } from "../theme.js";
+import { ModalFrame } from "./modal-frame.js";
+import { SelectList, getEditorKeybindings } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/embeddings-overlay.ts
+/**
+* Embedding preset selector shown as a popup overlay.
+*/
+var EmbeddingsOverlayComponent = class {
+	constructor(options) {
+		this.focused = false;
+		this.frame = new ModalFrame({
+			title: "Embedding models",
+			hint: "↑↓ navigate • Enter select • Esc cancel"
+		});
+		this.selectList = new SelectList(options.options.map((opt) => {
+			const status = opt.active ? "active" : opt.downloaded ? "downloaded" : "not downloaded";
+			return {
+				value: opt.tier,
+				label: `${opt.tier.padEnd(12)} ${opt.label}`,
+				description: `${opt.dimensions} dims • ${status}`
+			};
+		}), 8, tuiTheme.selectList);
+		const selectedIndex = options.options.findIndex((o) => o.active);
+		if (selectedIndex >= 0) this.selectList.setSelectedIndex(selectedIndex);
+		this.selectList.onSelect = (item) => {
+			options.onSelectTier(item.value);
+		};
+		this.selectList.onCancel = () => {
+			options.onCancel();
+		};
+	}
+	handleInput(data) {
+		const kb = getEditorKeybindings();
+		if (kb.matches(data, "selectUp") || kb.matches(data, "selectDown") || kb.matches(data, "selectConfirm") || kb.matches(data, "selectCancel")) this.selectList.handleInput(data);
+	}
+	render(width) {
+		return this.frame.render(width, this.selectList.render(width));
+	}
+	invalidate() {
+		this.selectList.invalidate();
+	}
+};
+
+//#endregion
+export { EmbeddingsOverlayComponent };

package/dist/tui/components/footer.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import { visibleWidth } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/footer.ts
+var FooterComponent = class {
+	constructor() {
+		this.hints = [
+			{
+				key: "Enter",
+				label: "send"
+			},
+			{
+				key: "Shift+Enter",
+				label: "newline"
+			},
+			{
+				key: "Ctrl+P",
+				label: "model"
+			},
+			{
+				key: "Ctrl+E",
+				label: "expand"
+			},
+			{
+				key: "Ctrl+C",
+				label: "cancel/quit"
+			}
+		];
+	}
+	setHints(hints) {
+		this.hints = hints;
+	}
+	render(width) {
+		const parts = this.hints.map((h) => `${chalk.bold(h.key)} ${chalk.dim(h.label)}`);
+		const separator = chalk.dim(" │ ");
+		const joined = parts.join(separator);
+		if (visibleWidth(joined) <= width) return [joined];
+		let result = "";
+		for (const part of parts) {
+			const candidate = result ? result + separator + part : part;
+			if (visibleWidth(candidate) > width) break;
+			result = candidate;
+		}
+		if (!result && parts.length > 0) {
+			const first = parts[0];
+			let truncated = "";
+			for (const ch of first) {
+				const next = truncated + ch;
+				if (visibleWidth(next) > width) break;
+				truncated = next;
+			}
+			return [truncated];
+		}
+		return [result];
+	}
+	invalidate() {}
+};
+
+//#endregion
+export { FooterComponent };

package/dist/tui/components/index.js

@@ -0,0 +1,15 @@
+import { AssistantMessageComponent } from "./assistant-message.js";
+import { ChatEditor } from "./chat-editor.js";
+import { renderModalHeader } from "./modal-style.js";
+import { ModalFrame } from "./modal-frame.js";
+import { EmbeddingsOverlayComponent } from "./embeddings-overlay.js";
+import { FooterComponent } from "./footer.js";
+import { ModelSelectorComponent } from "./model-selector.js";
+import { PinnedChatLayout } from "./pinned-chat-layout.js";
+import { PluginsOverlayComponent } from "./plugins-overlay.js";
+import { SettingsOverlayComponent } from "./settings-overlay.js";
+import { StatusBar } from "./status-bar.js";
+import { ToolExecutionComponent } from "./tool-execution.js";
+import { UserMessageComponent } from "./user-message.js";
+
+export {  };

package/dist/tui/components/modal-frame.js

@@ -0,0 +1,45 @@
+import { tuiTheme } from "../theme.js";
+import { renderModalHeader } from "./modal-style.js";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/modal-frame.ts
+/**
+* Lightweight frame helper for popup overlays.
+*
+* Keeps header/hints/footer styling consistent while allowing each overlay
+* component to keep its own input/state logic.
+*/
+var ModalFrame = class {
+	constructor(options) {
+		this.options = options;
+	}
+	render(width, bodyLines) {
+		const lines = renderModalHeader({
+			title: this.options.title,
+			hint: this.options.hint
+		});
+		const indent = this.options.bodyIndent ?? 0;
+		const prefix = indent > 0 ? " ".repeat(indent) : "";
+		const body = indent > 0 ? bodyLines.map((l) => `${prefix}${l}`) : bodyLines;
+		lines.push(...body);
+		if (this.options.footerHint) {
+			lines.push("");
+			lines.push(tuiTheme.dim(` ${this.options.footerHint}`));
+		}
+		const contentWidth = Math.max(10, width - 2);
+		const top = tuiTheme.dim(`╭${"─".repeat(contentWidth)}╮`);
+		const bottom = tuiTheme.dim(`╰${"─".repeat(contentWidth)}╯`);
+		return [
+			top,
+			...lines.map((line) => {
+				const clipped = truncateToWidth(line, contentWidth, "");
+				const pad = Math.max(0, contentWidth - visibleWidth(clipped));
+				return `${tuiTheme.dim("│")}${clipped}${" ".repeat(pad)}${tuiTheme.dim("│")}`;
+			}),
+			bottom
+		];
+	}
+};
+
+//#endregion
+export { ModalFrame };

package/dist/tui/components/modal-style.js

@@ -0,0 +1,15 @@
+import { tuiTheme } from "../theme.js";
+
+//#region src/tui/components/modal-style.ts
+/**
+* Shared modal header chrome so popup overlays feel consistent.
+*/
+function renderModalHeader(options) {
+	const lines = [tuiTheme.bold(` ${options.title}`)];
+	if (options.hint) lines.push(tuiTheme.dim(` ${options.hint}`));
+	if (options.spacerAfterHeader !== false) lines.push("");
+	return lines;
+}
+
+//#endregion
+export { renderModalHeader };

package/dist/tui/components/model-selector.js

@@ -0,0 +1,70 @@
+import { tuiTheme } from "../theme.js";
+import { ModalFrame } from "./modal-frame.js";
+import { getEnvApiKey, getModels, getProviders } from "@mariozechner/pi-ai";
+import { Input, SelectList, getEditorKeybindings } from "@mariozechner/pi-tui";
+
+//#region src/tui/components/model-selector.ts
+/**
+* Pi-style model selector with a filter input + a scrollable list.
+*/
+var ModelSelectorComponent = class {
+	constructor(options) {
+		this.focused = false;
+		this.filterInput = new Input();
+		this.modelByKey = /* @__PURE__ */ new Map();
+		this.frame = new ModalFrame({
+			title: "Select model",
+			hint: "type to filter • ↑↓ navigate • Enter select • Esc cancel"
+		});
+		const items = [];
+		for (const provider of getProviders()) for (const model of getModels(provider)) {
+			const key = `${model.provider}/${model.id}`;
+			this.modelByKey.set(key, model);
+			const keyHint = options.hasCredentials?.(model.provider) ?? Boolean(getEnvApiKey(model.provider)) ? "" : " (no key)";
+			items.push({
+				value: key,
+				label: key,
+				description: `${model.api}${keyHint}`
+			});
+		}
+		this.selectList = new SelectList(items, 12, tuiTheme.selectList);
+		this.selectList.onSelect = (item) => {
+			const model = this.modelByKey.get(item.value);
+			if (model) options.onSelect(model);
+		};
+		this.selectList.onCancel = () => {
+			options.onCancel();
+		};
+		const currentKey = `${options.currentModel.provider}/${options.currentModel.id}`;
+		const currentIndex = items.findIndex((i) => i.value === currentKey);
+		if (currentIndex >= 0) this.selectList.setSelectedIndex(currentIndex);
+		this.filterInput.setValue("");
+	}
+	handleInput(data) {
+		const kb = getEditorKeybindings();
+		if (kb.matches(data, "selectUp") || kb.matches(data, "selectDown") || kb.matches(data, "selectConfirm") || kb.matches(data, "selectCancel")) {
+			this.selectList.handleInput(data);
+			return;
+		}
+		const before = this.filterInput.getValue();
+		this.filterInput.handleInput(data);
+		const after = this.filterInput.getValue();
+		if (after !== before) this.selectList.setFilter(after);
+	}
+	render(width) {
+		this.filterInput.focused = this.focused;
+		const body = [
+			...this.filterInput.render(width).map((l) => `  ${l}`),
+			"",
+			...this.selectList.render(width)
+		];
+		return this.frame.render(width, body);
+	}
+	invalidate() {
+		this.filterInput.invalidate();
+		this.selectList.invalidate();
+	}
+};
+
+//#endregion
+export { ModelSelectorComponent };