@sns-myagent/cli 0.3.8 → 0.3.9

package/src/modes/components/welcome.ts

@@ -11,7 +11,7 @@ import { theme } from "../../modes/theme/theme";
 import tipsText from "./tips.txt" with { type: "text" };
 
 // Local override — upstream APP_NAME still reports "omp"/"pi-utils" identity.
-const APP_NAME = "SnsAgent";
+const APP_NAME = "snsagent";
 
 /** Tips embedded at build time, one per line; blanks dropped. */
 const TIPS: readonly string[] = tipsText
@@ -236,160 +236,66 @@ export class WelcomeComponent implements Component {
 	}
 
 	#renderLines(termWidth: number): string[] {
-		// Box dimensions - responsive with max width and small-terminal support
-		const maxWidth = 100;
-		const boxWidth = Math.min(maxWidth, Math.max(0, termWidth - 2));
-		if (boxWidth < 4) {
-			return [];
-		}
-		const dualContentWidth = boxWidth - 3; // 3 = │ + │ + │
-		const preferredLeftCol = 26;
-		const minLeftCol = 12; // logo width
-		const minRightCol = 20;
-		const leftMinContentWidth = Math.max(
-			minLeftCol,
-			visibleWidth("Welcome back!"),
-			visibleWidth(this.modelName),
-			visibleWidth(this.providerName),
-		);
-		const desiredLeftCol = Math.min(preferredLeftCol, Math.max(minLeftCol, Math.floor(dualContentWidth * 0.35)));
-		const dualLeftCol =
-			dualContentWidth >= minRightCol + 1
-				? Math.min(desiredLeftCol, dualContentWidth - minRightCol)
-				: Math.max(1, dualContentWidth - 1);
-		const dualRightCol = Math.max(1, dualContentWidth - dualLeftCol);
-		const showRightColumn = dualLeftCol >= leftMinContentWidth && dualRightCol >= minRightCol;
-		const leftCol = showRightColumn ? dualLeftCol : boxWidth - 2;
-		const rightCol = showRightColumn ? dualRightCol : 0;
-
-		// Logo: pick a frame from the intro animation if active, else the resting frame.
+		const width = Math.min(100, Math.max(0, termWidth - 4));
+		if (width < 4) return [];
+
 		const logoColored = this.#currentLogoFrame();
+		const dot = theme.fg("accent", "●");
 
-		// Left column - centered content
-		const leftLines = [
-			"",
-			this.#centerText(theme.bold("Welcome back!"), leftCol),
-			"",
-			...logoColored.map(l => this.#centerText(l, leftCol)),
-			"",
-			this.#centerText(theme.fg("muted", this.modelName), leftCol),
-			this.#centerText(theme.fg("borderMuted", this.providerName), leftCol),
-		];
-
-		// Right column separator
-		const separatorWidth = Math.max(0, rightCol - 2); // padding on each side
-		const separator = ` ${theme.fg("dim", theme.boxRound.horizontal.repeat(separatorWidth))}`;
-
-		// Recent sessions content
-		const sessionLines: string[] = [];
-		if (this.recentSessions.length === 0) {
-			sessionLines.push(` ${theme.fg("dim", "No recent sessions")}`);
-		} else {
-			// Reserve width for the bullet prefix (" • ") and the trailing " (timeAgo)"
-			// so the relative time is never the part that gets truncated. The name
-			// absorbs whatever space is left.
-			const bulletPrefix = ` ${theme.md.bullet} `;
-			const prefixWidth = visibleWidth(bulletPrefix);
+		const lines: string[] = [];
+
+		// Logo
+		lines.push("");
+		for (const l of logoColored) {
+			lines.push(this.#centerText(l, width));
+		}
+		lines.push("");
+
+		// Brand + version
+		lines.push(this.#centerText(`${dot} ${theme.bold(APP_NAME)} ${theme.fg("dim", `v${this.version}`)}`, width));
+		lines.push("");
+
+		// Model info
+		lines.push(this.#centerText(theme.fg("muted", `${this.providerName} / ${this.modelName}`), width));
+		lines.push("");
+
+		// Divider
+		lines.push(theme.fg("dim", "─".repeat(width)));
+		lines.push("");
+
+		// Tips
+		lines.push(` ${theme.bold(theme.fg("accent", "●"))} ${theme.bold("Shortcuts")}`);
+		lines.push(` ${theme.fg("dim", "?")} ${theme.fg("muted", "keyboard shortcuts")}`);
+		lines.push(` ${theme.fg("dim", "/")} ${theme.fg("muted", "slash commands")}`);
+		lines.push(` ${theme.fg("dim", "!")} ${theme.fg("muted", "run bash")}`);
+		lines.push(` ${theme.fg("dim", "$")} ${theme.fg("muted", "run python")}`);
+		lines.push("");
+
+		// Recent sessions (if any)
+		if (this.recentSessions.length > 0) {
+			lines.push(` ${theme.bold(theme.fg("accent", "●"))} ${theme.bold("Recent")}`);
 			for (const session of this.recentSessions.slice(0, WELCOME_SESSION_SLOTS)) {
-				const timeSuffixRaw = ` (${session.timeAgo})`;
-				const timeWidth = visibleWidth(timeSuffixRaw);
-				const nameBudget = Math.max(1, rightCol - prefixWidth - timeWidth);
-				const nameVis = visibleWidth(session.name);
-				const name = nameVis > nameBudget ? truncateToWidth(session.name, nameBudget) : session.name;
-				sessionLines.push(
-					`${theme.fg("dim", bulletPrefix)}${theme.fg("muted", name)}${theme.fg("dim", timeSuffixRaw)}`,
-				);
+				const time = `(${session.timeAgo})`;
+				lines.push(` ${theme.fg("dim", "·")} ${theme.fg("muted", session.name)} ${theme.fg("dim", time)}`);
 			}
-		}
-		// Pad to the fixed slot count so the box height doesn't depend on session count.
-		while (sessionLines.length < WELCOME_SESSION_SLOTS) {
-			sessionLines.push("");
+			lines.push("");
 		}
 
-		// LSP servers content
-		const lspLines: string[] = [];
-		if (this.lspServers.length === 0) {
-			lspLines.push(` ${theme.fg("dim", "No LSP servers")}`);
-		} else {
+		// LSP (if any)
+		if (this.lspServers.length > 0) {
+			lines.push(` ${theme.bold(theme.fg("accent", "●"))} ${theme.bold("LSP")}`);
 			for (const server of this.lspServers.slice(0, WELCOME_LSP_SLOTS)) {
-				const icon =
-					server.status === "ready"
-						? theme.styledSymbol("status.enabled", "success")
-						: server.status === "available"
-							? theme.styledSymbol("status.enabled", "dim")
-							: server.status === "connecting"
-								? theme.styledSymbol("status.pending", "muted")
-								: theme.styledSymbol("status.error", "error");
-				const exts = server.fileTypes.slice(0, 3).join(" ");
-				lspLines.push(` ${icon} ${theme.fg("muted", server.name)} ${theme.fg("dim", exts)}`);
+				const icon = server.status === "ready"
+					? theme.styledSymbol("status.enabled", "success")
+					: theme.styledSymbol("status.pending", "dim");
+				lines.push(` ${icon} ${theme.fg("muted", server.name)}`);
 			}
-		}
-		// Pad to the fixed slot count so the box height doesn't depend on server count.
-		while (lspLines.length < WELCOME_LSP_SLOTS) {
-			lspLines.push("");
-		}
-
-		// Right column
-		const rightLines = [
-			` ${theme.bold(theme.fg("accent", "Tips"))}`,
-			` ${theme.fg("dim", "?")}${theme.fg("muted", " for keyboard shortcuts")}`,
-			` ${theme.fg("dim", "#")}${theme.fg("muted", " for prompt actions")}`,
-			` ${theme.fg("dim", "/")}${theme.fg("muted", " for commands")}`,
-			` ${theme.fg("dim", "!")}${theme.fg("muted", " to run bash")}`,
-			` ${theme.fg("dim", "$")}${theme.fg("muted", " to run python")}`,
-			separator,
-			` ${theme.bold(theme.fg("accent", "LSP Servers"))}`,
-			...lspLines,
-			separator,
-			` ${theme.bold(theme.fg("accent", "Recent sessions"))}`,
-			...sessionLines,
-			"",
-		];
-
-		// Border characters (dim)
-		const hChar = theme.boxRound.horizontal;
-		const h = theme.fg("dim", hChar);
-		const v = theme.fg("dim", theme.boxRound.vertical);
-		const tl = theme.fg("dim", theme.boxRound.topLeft);
-		const tr = theme.fg("dim", theme.boxRound.topRight);
-		const bl = theme.fg("dim", theme.boxRound.bottomLeft);
-		const br = theme.fg("dim", theme.boxRound.bottomRight);
-
-		const lines: string[] = [];
-
-		// Top border with embedded title
-		const title = ` ${APP_NAME} v${this.version} `;
-		const titlePrefixRaw = hChar.repeat(3);
-		const titleStyled = theme.fg("dim", titlePrefixRaw) + theme.fg("muted", title);
-		const titleVisLen = visibleWidth(titlePrefixRaw) + visibleWidth(title);
-		const titleSpace = boxWidth - 2;
-		if (titleVisLen >= titleSpace) {
-			lines.push(tl + truncateToWidth(titleStyled, titleSpace) + tr);
-		} else {
-			const afterTitle = titleSpace - titleVisLen;
-			lines.push(tl + titleStyled + theme.fg("dim", hChar.repeat(afterTitle)) + tr);
-		}
-
-		// Content rows
-		const maxRows = showRightColumn ? Math.max(leftLines.length, rightLines.length) : leftLines.length;
-		for (let i = 0; i < maxRows; i++) {
-			const left = this.#fitToWidth(leftLines[i] ?? "", leftCol);
-			if (showRightColumn) {
-				const right = this.#fitToWidth(rightLines[i] ?? "", rightCol);
-				lines.push(v + left + v + right + v);
-			} else {
-				lines.push(v + left + v);
-			}
-		}
-		// Bottom border
-		if (showRightColumn) {
-			lines.push(bl + h.repeat(leftCol) + theme.fg("dim", theme.boxRound.teeUp) + h.repeat(rightCol) + br);
-		} else {
-			lines.push(bl + h.repeat(leftCol) + br);
+			lines.push("");
 		}
 
-		// Randomly picked tip, rendered directly beneath the box.
-		lines.push(...this.#renderTip(boxWidth));
+		// Bottom divider + tip
+		lines.push(theme.fg("dim", "─".repeat(width)));
+		lines.push(...this.#renderTip(width));
 
 		return lines;
 	}
@@ -455,26 +361,26 @@ export class WelcomeComponent implements Component {
 	}
 }
 
-export const PI_LOGO = [
-	"██████╗███╗   ██╗███████╗ █████╗  ██████╗ ███████╗███╗   ██╗████████╗",
-	"██╔════╝████╗  ██║██╔════╝██╔══██╗██╔═══██╗██╔════╝████╗  ██║╚══██╔══╝",
-	"██████╗ ██╔██╗ ██║███████╗███████║██║   ██║█████╗  ██╔██╗ ██║   ██║   ",
-	"╚════██║██║╚██╗██║╚════██║██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ",
-	"██████║██║ ╚████║███████║██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ",
-	"╚═════╝╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ",
+export const SNS_LOGO = [
+	"████████╗███████╗██████╗ ███╗   ███╗",
+	"╚══██╔══╝██╔════╝██╔══██╗████╗ ████║",
+	"   ██║   █████╗  ██████╔╝██╔████╔██║",
+	"   ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║",
+	"   ██║   ███████╗██║  ██║██║ ╚═╝ ██║",
+	"   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝",
 ];
 
 /** Multi-stop palette for the diagonal gradient. */
 const GRADIENT_STOPS: ReadonlyArray<readonly [number, number, number]> = [
-	[0, 210, 255],    // #00d2ff — SNS cyan
-	[80, 150, 255],   // transitional blue
-	[123, 47, 247],   // #7b2ff7 — SNS purple
-	[200, 70, 180],   // transitional pink-purple
-	[255, 107, 157],  // #ff6b9d — SNS pink
+	[249, 115, 22],   // #F97316 — orange-500
+	[234, 88, 12],    // #EA580C — orange-600
+	[255, 140, 50],   // transitional warm orange
+	[220, 100, 20],   // transitional deep orange
+	[245, 130, 30],   // transitional amber
 ];
 
 /** 256-color ramp fallback when truecolor isn't available. */
-const GRADIENT_RAMP_256 = [199, 171, 135, 99, 75, 51, 87];
+const GRADIENT_RAMP_256 = [208, 209, 214, 172, 166, 130, 178];
 
 /** Half-width of the shine highlight band, expressed in gradient-t units. */
 const SHINE_HALF_WIDTH = 0.18;
@@ -583,8 +489,8 @@ function introLogoFrame(progress: number): string[] {
 	const phase = ((((1 - eased) * INTRO_SWEEPS) % 1) + 1) % 1;
 	const shinePos = (((progress * INTRO_SHINE_TRAVERSALS) % 1) + 1) % 1;
 	const shineStrength = (1 - eased) ** 1.5;
-	return gradientLogo(PI_LOGO, phase, { strength: shineStrength, pos: shinePos });
+	return gradientLogo(SNS_LOGO, phase, { strength: shineStrength, pos: shinePos });
 }
 
 /** Resting gradient frame, cached for re-renders outside of the intro. */
-const REST_FRAME = gradientLogo(PI_LOGO, 0);
+const REST_FRAME = gradientLogo(SNS_LOGO, 0);

package/src/modes/interactive-mode.ts

@@ -853,7 +853,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		// Load initial todos
 		await this.#loadTodoList();
 
-		// Start the UI. Cold `omp` launch opts into clearing on the first paint so
+		// Start the UI. Cold `snsagent` launch opts into clearing on the first paint so
 		// the initial welcome frame does not append over the previous run's scrollback.
 		this.ui.start({ clearScrollback: options.clearInitialTerminalHistory === true });
 		pushTerminalTitle();
@@ -876,7 +876,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		// custom messages, branch summaries, and compaction summaries) and the user
 		// set no explicit `mode_change` (which #reconcileModeFromSession just
 		// restored). SDK startup metadata and extension `custom` state entries are
-		// ignored. This way `omp --continue` (or auto-resume) that finds no recent
+		// ignored. This way `snsagent --continue` (or auto-resume) that finds no recent
 		// session and creates a fresh one still honors the default, while a session
 		// with restored context or an explicit mode keeps its reconciled mode. Scoped
 		// to launch (not the switch reconciler above) so /new and the plan-approval →

package/src/modes/print-mode.ts

@@ -2,8 +2,8 @@
  * Print mode (single-shot): Send prompts, output result, exit.
  *
  * Used for:
- * - `omp -p "prompt"` - text output
- * - `omp --mode json "prompt"` - JSON event stream
+ * - `snsagent -p "prompt"` - text output
+ * - `snsagent --mode json "prompt"` - JSON event stream
  */
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import { logger, sanitizeText } from "@oh-my-pi/pi-utils";

package/src/modes/setup-version.ts

@@ -8,4 +8,4 @@
  * the overlay component and their TUI deps. MUST equal `max(scene.minVersion)`
  * across `ALL_SCENES`; the `setup-wizard` barrel and test suite guard it.
  */
-export const CURRENT_SETUP_VERSION = 1;
+export const CURRENT_SETUP_VERSION = 2;

package/src/modes/setup-wizard/scenes/byok-setup.ts

@@ -0,0 +1,354 @@
+/**
+ * BYOK (Bring Your Own Key) setup tab.
+ *
+ * Quick-connect tab in the providers scene. User enters Base URL + API Key +
+ * selects API type → auto-detects models → saves to models.yml.
+ */
+import { type Component, type Focusable, Input, type SgrMouseEvent } from "@oh-my-pi/pi-tui";
+import { YAML } from "bun";
+import { getAgentDir, logger } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { theme } from "../../theme/theme";
+import type { SetupSceneHost, SetupTab } from "./types";
+
+// ─── API type options ───────────────────────────────────────────────
+const API_TYPE_OPTIONS = [
+	{ value: "openai-completions", label: "OpenAI Compatible" },
+	{ value: "openai-responses", label: "OpenAI Responses" },
+	{ value: "anthropic-messages", label: "Anthropic" },
+	{ value: "google-generative-ai", label: "Google Gemini" },
+	{ value: "azure-openai-responses", label: "Azure OpenAI" },
+] as const;
+
+type ApiType = (typeof API_TYPE_OPTIONS)[number]["value"];
+
+// ─── Focusable input wrapper ────────────────────────────────────────
+class FieldInput implements Component, Focusable {
+	#input: Input;
+	#label: string;
+	#masked: boolean;
+
+	constructor(label: string, masked = false) {
+		this.#input = new Input();
+		this.#input.prompt = "";
+		this.#label = label;
+		this.#masked = masked;
+	}
+
+	get focused(): boolean {
+		return this.#input.focused;
+	}
+	set focused(value: boolean) {
+		this.#input.focused = value;
+	}
+	setUseTerminalCursor(v: boolean): void {
+		this.#input.setUseTerminalCursor(v);
+	}
+	getValue(): string {
+		return this.#input.getValue();
+	}
+	setValue(v: string): void {
+		this.#input.setValue(v);
+	}
+
+	handleInput(data: string): void {
+		this.#input.handleInput(data);
+	}
+	invalidate(): void {
+		this.#input.invalidate();
+	}
+
+	render(width: number): readonly string[] {
+		const val = this.#input.getValue();
+		const display = this.#masked ? "*".repeat(Math.min(val.length, 40)) : val;
+		const prefix = theme.fg("accent", "● ");
+		const label = theme.bold(this.#label);
+		const sep = theme.fg("dim", ": ");
+		const field = this.#input.focused
+			? theme.fg("muted", display + "█")
+			: theme.fg("dim", display || "(empty)");
+		return [prefix + label + sep + field];
+	}
+}
+
+// ─── State machine ─────────────────────────────────────────────────
+type ByokState = "input" | "detecting" | "success" | "error";
+
+// ─── BYOK Tab ───────────────────────────────────────────────────────
+export class ByokSetupTab implements SetupTab {
+	readonly id = "byok";
+	readonly label = "BYOK";
+	get modal(): boolean { return this.#detecting; }
+
+	#baseUrl: FieldInput;
+	#apiKey: FieldInput;
+	#apiTypeIndex = 0;
+	#fields: FieldInput[];
+	#focusIndex = 0; // 0=baseUrl, 1=apiKey, 2=apiType
+	#state: ByokState = "input";
+	#statusLines: string[] = [];
+	#modelCount = 0;
+	#disposed = false;
+	#detecting = false;
+
+	constructor(private readonly host: SetupSceneHost) {
+		this.#baseUrl = new FieldInput("Base URL");
+		this.#apiKey = new FieldInput("API Key", true);
+		this.#fields = [this.#baseUrl, this.#apiKey];
+		this.#baseUrl.setValue("https://api.openai.com/v1");
+		this.#focusInput();
+	}
+
+	onActivate(): void {
+		this.#focusInput();
+		this.host.requestRender();
+	}
+
+	handleInput(data: string): void {
+		if (this.#state === "detecting") return; // block input during detection
+
+		// Escape key — finish/exit tab
+		if (data === "\x1b" || data === "\x1b\x1b") {
+			this.host.finish("skipped");
+			return;
+		}
+
+		if (data === "\x1b[A" || data === "\x1b[B") {
+			// Up/Down in api type selector
+			if (this.#focusIndex === 2) {
+				const dir = data === "\x1b[A" ? -1 : 1;
+				this.#apiTypeIndex = (this.#apiTypeIndex + dir + API_TYPE_OPTIONS.length) % API_TYPE_OPTIONS.length;
+				this.host.requestRender();
+				return;
+			}
+		}
+
+		if (data === "\t" || (data === "\x1b[B" && this.#focusIndex < 2)) {
+			this.#focusIndex = Math.min(2, this.#focusIndex + 1);
+			this.#focusInput();
+			this.host.requestRender();
+			return;
+		}
+
+		if (data === "\x1b[Z") { // Shift+Tab
+			this.#focusIndex = Math.max(0, this.#focusIndex - 1);
+			this.#focusInput();
+			this.host.requestRender();
+			return;
+		}
+
+		if (data === "\r" || data === "\n") {
+			if (this.#focusIndex < 2) {
+				// Move to next field on Enter
+				this.#focusIndex = Math.min(2, this.#focusIndex + 1);
+				this.#focusInput();
+			} else {
+				// Submit on Enter from api type
+				void this.#submit();
+			}
+			this.host.requestRender();
+			return;
+		}
+
+		// Forward to focused input field
+		if (this.#focusIndex < 2) {
+			this.#fields[this.#focusIndex].handleInput(data);
+		}
+		this.host.requestRender();
+	}
+
+	routeMouse(_event: SgrMouseEvent, _line: number, _col: number): void {
+		// No mouse routing needed for simple fields
+	}
+
+	invalidate(): void {
+		for (const f of this.#fields) f.invalidate();
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+	}
+
+	render(width: number): readonly string[] {
+		const lines: string[] = [];
+		lines.push(theme.fg("muted", "Enter your provider details. Tab between fields, Enter to connect."));
+		lines.push(theme.fg("dim", "⚠ API Key stored in agent config directory"));
+		lines.push("");
+
+		// Base URL field
+		lines.push(...this.#baseUrl.render(width));
+
+		// API Key field
+		lines.push(...this.#apiKey.render(width));
+
+		// API Type selector
+		const selected = API_TYPE_OPTIONS[this.#apiTypeIndex];
+		const prefix = theme.fg("accent", "● ");
+		const label = theme.bold("API Type");
+		const sep = theme.fg("dim", ": ");
+		const value = this.#focusIndex === 2
+			? theme.fg("muted", `◀ ${selected.label} ▶`)
+			: theme.fg("dim", selected.label);
+		const hint = this.#focusIndex === 2
+			? theme.fg("dim", "  ↑↓ to change")
+			: "";
+		lines.push(prefix + label + sep + value + hint);
+
+		// Status lines
+		if (this.#statusLines.length > 0) {
+			lines.push("");
+			lines.push(...this.#statusLines);
+		}
+
+		return lines;
+	}
+
+	#focusInput(): void {
+		for (const f of this.#fields) f.focused = false;
+		if (this.#focusIndex < 2) {
+			this.#fields[this.#focusIndex].focused = true;
+			this.host.setFocus(this.#fields[this.#focusIndex]);
+		} else {
+			this.host.setFocus(null);
+		}
+	}
+
+	async #submit(): Promise<void> {
+		const baseUrl = this.#baseUrl.getValue().trim().replace(/\/+$/, "");
+		const apiKey = this.#apiKey.getValue().trim();
+		const apiType = API_TYPE_OPTIONS[this.#apiTypeIndex].value as ApiType;
+
+		// Validate
+		if (!baseUrl) {
+			this.#statusLines = [theme.fg("error", `${theme.status.error} Base URL is required`)];
+			this.host.requestRender();
+			return;
+		}
+
+		// Determine auth mode — no API key + localhost = auth "none"
+		const isNoAuth = !apiKey;
+		if (!isNoAuth || baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1")) {
+			// proceed
+		} else if (!apiKey && !baseUrl.includes("localhost")) {
+			this.#statusLines = [theme.fg("error", `${theme.status.error} API Key is required (or use localhost for local providers)`)];
+			this.host.requestRender();
+			return;
+		}
+
+		this.#state = "detecting";
+		this.#detecting = true;
+		this.#statusLines = [theme.fg("dim", "Detecting models…")];
+		this.host.requestRender();
+
+		try {
+			// Auto-detect models for OpenAI-compatible providers
+			const models = (!isNoAuth && (apiType === "openai-completions" || apiType === "openai-responses"))
+				? await this.#detectModels(baseUrl, apiKey)
+				: [];
+
+			this.#modelCount = models.length;
+
+			// Write models.yml
+			await this.#saveProvider(baseUrl, apiKey, apiType, models, isNoAuth);
+
+			this.#state = "success";
+			this.#detecting = false;
+			const modelInfo = models.length > 0
+				? `${models.length} model${models.length !== 1 ? "s" : ""} detected`
+				: "connected (manual model config needed)";
+			this.#statusLines = [
+				theme.fg("success", `${theme.status.success} ${modelInfo}`),
+				theme.fg("dim", `Provider saved to ${path.join(getAgentDir(), "models.yml")}`),
+			];
+		} catch (err) {
+			this.#state = "error";
+			this.#detecting = false;
+			const msg = err instanceof Error ? err.message : String(err);
+			this.#statusLines = [
+				theme.fg("error", `${theme.status.error} ${msg}`),
+				theme.fg("dim", "Check your Base URL and API Key, then try again."),
+			];
+		}
+
+		this.host.requestRender();
+	}
+
+	async #detectModels(baseUrl: string, apiKey: string): Promise<string[]> {
+		const url = `${baseUrl}/models`;
+		const headers: Record<string, string> = {};
+		if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+
+		const response = await fetch(url, { headers, signal: AbortSignal.timeout(10_000) });
+		if (!response.ok) {
+			if (response.status === 401 || response.status === 403) {
+				throw new Error("API Key rejected — check your credentials");
+			}
+			throw new Error(`Provider returned HTTP ${response.status}`);
+		}
+
+		const data = await response.json() as { data?: { id: string }[] };
+		if (!data.data || !Array.isArray(data.data)) {
+			return [];
+		}
+		return data.data.map((m) => m.id).filter(Boolean).sort();
+	}
+
+	async #saveProvider(baseUrl: string, apiKey: string, apiType: ApiType, models: string[], isNoAuth = false): Promise<void> {
+		const agentDir = getAgentDir();
+		const configPath = path.join(agentDir, "models.yml");
+
+		// Read existing config
+		let existing: Record<string, unknown> = {};
+		if (fs.existsSync(configPath)) {
+			try {
+				const content = fs.readFileSync(configPath, "utf-8");
+				existing = YAML.parse(content) as Record<string, unknown> ?? {};
+			} catch {
+				existing = {};
+			}
+		}
+
+		const providers = (existing.providers ?? {}) as Record<string, unknown>;
+
+		// Generate provider name from base URL
+		const providerName = this.#deriveProviderName(baseUrl);
+
+		const providerConfig: Record<string, unknown> = {
+			baseUrl,
+			api: apiType,
+			auth: isNoAuth ? "none" : "apiKey",
+		};
+		if (apiKey) providerConfig.apiKey = apiKey;
+
+		if (models.length > 0) {
+			providerConfig.models = models.map((id) => ({
+				id,
+				api: apiType,
+				contextWindow: 128000,
+				supportsTools: true,
+			}));
+		}
+
+		providers[providerName] = providerConfig;
+		existing.providers = providers;
+
+		// Ensure directory exists
+		if (!fs.existsSync(agentDir)) {
+			fs.mkdirSync(agentDir, { recursive: true });
+		}
+
+		fs.writeFileSync(configPath, YAML.stringify(existing), "utf-8");
+		logger.info(`BYOK: provider "${providerName}" saved to ${configPath}`);
+	}
+
+	#deriveProviderName(baseUrl: string): string {
+		try {
+			const url = new URL(baseUrl);
+			const host = url.hostname.replace(/^api\./, "").replace(/\./g, "-");
+			return host || "custom-provider";
+		} catch {
+			return "custom-provider";
+		}
+	}
+}