zidane 4.1.3 → 4.1.5

package/dist/tui.js

@@ -1,12 +1,14 @@
 import { d as createAgent } from "./tools-DpeWKzP1.js";
 import { n as toolResultToText } from "./types-Bx_F8jet.js";
 import { r as basic_default } from "./presets-Cs7_CsMk.js";
-import { i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-CX-R-Oy-.js";
+import { i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-CCDvIXGJ.js";
 import { n as loadSession, t as createSession } from "./session-Cn68UASv.js";
 import { createSqliteStore } from "./session/sqlite.js";
+import { spawn } from "node:child_process";
 import { dirname, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { anthropicOAuthProvider, openaiCodexOAuthProvider } from "@mariozechner/pi-ai/oauth";
 import { getModel, getModels } from "@mariozechner/pi-ai";
 import { RGBA, SyntaxStyle, createCliRenderer, defaultTextareaKeyBindings } from "@opentui/core";
 import { createRoot, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/react";
@@ -480,103 +482,277 @@ function ToolResultBlock({ text, indent }) {
 	});
 }
 //#endregion
-//#region src/tui/auth.ts
-const ENV_KEYS = {
-	anthropic: "ANTHROPIC_API_KEY",
-	openai: "OPENAI_CODEX_API_KEY",
-	openrouter: "OPENROUTER_API_KEY",
-	cerebras: "CEREBRAS_API_KEY"
+//#region src/tui/providers.ts
+/** Convenience accessor — returns `credentialFileKey ?? key`. */
+function credKeyOf(desc) {
+	return desc.credentialFileKey ?? desc.key;
+}
+/** Convenience accessor — returns `piProviderId ?? key`. */
+function piIdOf(desc) {
+	return desc.piProviderId ?? desc.key;
+}
+const anthropicDescriptor = {
+	key: "anthropic",
+	label: "Anthropic",
+	factory: anthropic,
+	defaultModel: "claude-opus-4-7",
+	envKey: "ANTHROPIC_API_KEY",
+	apiKeyPlaceholder: "sk-ant-…",
+	oauthProvider: anthropicOAuthProvider,
+	oauthHint: "Claude Pro/Max subscription"
+};
+const openaiDescriptor = {
+	key: "openai",
+	label: "OpenAI Codex",
+	factory: openai,
+	defaultModel: "gpt-5.4",
+	envKey: "OPENAI_CODEX_API_KEY",
+	credentialFileKey: "openai-codex",
+	piProviderId: "openai-codex",
+	apiKeyPlaceholder: "sk-… or eyJ… (Codex)",
+	oauthProvider: openaiCodexOAuthProvider
 };
-/** Maps a provider to the credentials.json key written by `bun run auth`. */
-const OAUTH_KEYS = {
-	anthropic: "anthropic",
-	openai: "openai-codex"
+const openrouterDescriptor = {
+	key: "openrouter",
+	label: "OpenRouter",
+	factory: openrouter,
+	defaultModel: "anthropic/claude-sonnet-4-6",
+	envKey: "OPENROUTER_API_KEY",
+	apiKeyPlaceholder: "sk-or-…"
 };
-const LABELS = {
-	anthropic: "Anthropic",
-	openai: "OpenAI Codex",
-	openrouter: "OpenRouter",
-	cerebras: "Cerebras"
+const cerebrasDescriptor = {
+	key: "cerebras",
+	label: "Cerebras",
+	factory: cerebras,
+	defaultModel: "zai-glm-4.7",
+	envKey: "CEREBRAS_API_KEY",
+	apiKeyPlaceholder: "csk-…"
+};
+/**
+* Default provider registry. Passed verbatim when `runTui` is invoked without
+* an explicit `providers` option. Hosts that want to override per-provider
+* metadata can spread this and replace specific entries:
+*
+* ```ts
+* runTui({ providers: { ...BUILTIN_PROVIDERS, anthropic: myOwnAnthropicDescriptor } })
+* ```
+*/
+const BUILTIN_PROVIDERS = {
+	anthropic: anthropicDescriptor,
+	openai: openaiDescriptor,
+	openrouter: openrouterDescriptor,
+	cerebras: cerebrasDescriptor
 };
-function envKeyFor(key) {
-	return ENV_KEYS[key];
+/**
+* Resolve the model list for a given provider. Honors `descriptor.models`
+* when set; otherwise queries pi-ai via `descriptor.piProviderId`. Returns
+* `[]` for descriptors with no known mapping (custom providers without a
+* model list) — callers should hide the model picker in that case.
+*/
+function modelsForDescriptor(descriptor) {
+	if (descriptor.models) return descriptor.models;
+	try {
+		return getModels(piIdOf(descriptor));
+	} catch {
+		return [];
+	}
+}
+/**
+* Look up the model's max context window via the descriptor's model source.
+* Returns `null` when the model isn't known (custom slugs, providers without
+* a registry); callers should hide the context indicator in that case.
+*/
+function getContextWindow(descriptor, modelId) {
+	if (descriptor.models) return descriptor.models.find((m) => m.id === modelId)?.contextWindow ?? null;
+	try {
+		return getModel(piIdOf(descriptor), modelId)?.contextWindow ?? null;
+	} catch {
+		return null;
+	}
 }
+//#endregion
+//#region src/tui/credentials.ts
+/** POSIX mode for the credentials file. Ignored on Windows. */
+const FILE_MODE = 384;
 /**
-* Detect available auth across the providers the harness ships with.
+* Resolve the credentials file path given the resolved TUI data directory
+* (typically `~/.zidane`, i.e. `config.paths.dir`).
 *
-* Mirrors the resolution order used by the providers at runtime:
-*   - explicit env var (highest)
-*   - OAuth credentials in `.credentials.json` (anthropic + openai-codex only)
+* Matches the convention used elsewhere in the TUI (sessions.db, state.json)
+* so a single `ZIDANE_STORAGE_DIR` override moves the entire data root.
+*/
+function credentialsPath(dataDir) {
+	return resolve(dataDir, "credentials.json");
+}
+/**
+* Read credentials from disk.
 *
-* Pure read — never refreshes or rewrites the credentials file.
+* Returns `{}` when the file is missing or corrupt (last-ditch tolerance —
+* a hand-edit gone wrong shouldn't lock the user out of re-authing). On first
+* call with no file present, attempts a migration from `cwd/.credentials.json`
+* (the legacy location used by `bun run auth`).
 */
-function detectAuth(env = process.env) {
-	const credsPath = resolve(process.cwd(), ".credentials.json");
-	let creds = {};
-	if (existsSync(credsPath)) try {
-		const parsed = JSON.parse(readFileSync(credsPath, "utf-8"));
-		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) creds = parsed;
-	} catch {}
-	return Object.keys(LABELS).map((key) => {
-		const methods = [];
-		const envKey = ENV_KEYS[key];
-		if (env[envKey]) methods.push({
-			source: "env",
-			detail: envKey
-		});
-		const oauthKey = OAUTH_KEYS[key];
-		if (oauthKey) {
-			const entry = creds[oauthKey];
-			if (entry?.access && entry.refresh) {
-				const detail = entry.expires ? `oauth · expires ${new Date(entry.expires).toLocaleString()}` : "oauth · .credentials.json";
-				methods.push({
-					source: "oauth",
-					detail
-				});
-			}
-		}
-		return {
-			key,
-			label: LABELS[key],
-			available: methods.length > 0,
-			methods
-		};
-	});
+function readCredentials(dataDir) {
+	const path = credentialsPath(dataDir);
+	if (!existsSync(path)) {
+		const migrated = migrateLegacyFile(path);
+		if (migrated) return migrated;
+		return {};
+	}
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		return parsed;
+	} catch {
+		return {};
+	}
+}
+/** Read a single provider's credential (translating via the descriptor). */
+function readProviderCredential(dataDir, descriptor) {
+	return readCredentials(dataDir)[credKeyOf(descriptor)];
 }
-//#endregion
-//#region src/tui/providers.ts
 /**
-* Construct a fresh provider instance for a given key.
+* Write credentials atomically (write-then-rename) with mode 0o600.
 *
-* Providers are cheap to build — credentials are resolved lazily at first
-* stream call — so we instantiate on demand rather than caching a singleton.
-* This also avoids leaking state across session/provider switches.
+* Atomic on the same filesystem — readers either see the previous file or the
+* new one, never a half-written intermediate. Creates the parent dir if needed
+* (first launch on a fresh machine: `~/.zidane/` may not exist yet).
 */
-const FACTORIES = {
-	anthropic,
-	openai,
-	openrouter,
-	cerebras
-};
-/** zidane provider key → pi-ai provider id (some don't match 1:1). */
-const PI_PROVIDER_ID = {
-	anthropic: "anthropic",
-	openai: "openai-codex",
-	openrouter: "openrouter",
-	cerebras: "cerebras"
-};
+function writeCredentials(dataDir, creds) {
+	const path = credentialsPath(dataDir);
+	mkdirSync(dirname(path), { recursive: true });
+	const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(creds, null, 2)}\n`, { mode: FILE_MODE });
+	renameSync(tmp, path);
+}
+function setProviderCredential(dataDir, descriptor, cred) {
+	const all = readCredentials(dataDir);
+	all[credKeyOf(descriptor)] = cred;
+	writeCredentials(dataDir, all);
+}
+function removeProviderCredential(dataDir, descriptor) {
+	const all = readCredentials(dataDir);
+	const fileKey = credKeyOf(descriptor);
+	if (!(fileKey in all)) return;
+	delete all[fileKey];
+	writeCredentials(dataDir, all);
+}
+/**
+* Inject API-key credentials into `process.env` so the harness providers pick
+* them up via their existing env-var resolution. Called once at TUI launch
+* after the credentials file has been resolved. OAuth credentials are NOT
+* injected — those reach providers via `ZIDANE_CREDENTIALS_PATH` + the file
+* reader in `src/providers/oauth.ts`.
+*
+* Does not overwrite env vars that are already set — explicit user-provided
+* env values win over stored API keys.
+*
+* Descriptors without an `envKey` (OAuth-only providers, custom providers
+* that bypass env-var resolution) are skipped silently.
+*/
+function applyApiKeyEnv(dataDir, registry) {
+	const creds = readCredentials(dataDir);
+	for (const descriptor of Object.values(registry)) {
+		if (!descriptor.envKey || process.env[descriptor.envKey]) continue;
+		const cred = creds[credKeyOf(descriptor)];
+		if (cred?.kind === "apikey" && cred.value) process.env[descriptor.envKey] = cred.value;
+	}
+}
 /**
-* Look up the model's max context window via pi-ai's model registry.
-* Returns `null` when the model isn't known (e.g. a custom openrouter slug);
-* callers should hide the context indicator in that case.
+* `bun run auth` (pre-TUI) wrote `cwd/.credentials.json` with an entry per
+* provider mapping directly to an OAuthCredentials payload, e.g.:
+*
+*   {
+*     "anthropic":    { "access": "...", "refresh": "...", "expires": 123 },
+*     "openai-codex": { "access": "...", "refresh": "...", "expires": 123, "accountId": "..." }
+*   }
+*
+* We don't delete the legacy file — it might still be used by a host that
+* imports the harness directly. We just copy its contents into the new
+* location under the kind-tagged shape so the TUI picks them up.
+*
+* Migration is provider-agnostic: any top-level entry with an `access` field
+* is preserved verbatim (extras included), under the same key. The TUI's
+* detection then looks them up via the matching descriptor's `credentialFileKey`.
+*
+* Returns the migrated credentials when the migration ran, or `null` when
+* there's no legacy file to migrate.
 */
-function getContextWindow(key, modelId) {
+function migrateLegacyFile(targetPath) {
+	const legacyPath = resolve(process.cwd(), ".credentials.json");
+	if (!existsSync(legacyPath)) return null;
+	let legacy;
 	try {
-		const providerId = PI_PROVIDER_ID[key];
-		return getModel(providerId, modelId)?.contextWindow ?? null;
+		legacy = JSON.parse(readFileSync(legacyPath, "utf-8"));
 	} catch {
 		return null;
 	}
+	if (!legacy || typeof legacy !== "object" || Array.isArray(legacy)) return null;
+	const migrated = {};
+	for (const [fileKey, value] of Object.entries(legacy)) {
+		if (!isOAuthLegacy(value)) continue;
+		const { access, refresh, expires, ...extras } = value;
+		migrated[fileKey] = {
+			kind: "oauth",
+			access,
+			...typeof refresh === "string" ? { refresh } : {},
+			...typeof expires === "number" ? { expires } : {},
+			...extras
+		};
+	}
+	if (Object.keys(migrated).length === 0) return null;
+	mkdirSync(dirname(targetPath), { recursive: true });
+	const tmp = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(migrated, null, 2)}\n`, { mode: FILE_MODE });
+	renameSync(tmp, targetPath);
+	return migrated;
+}
+function isOAuthLegacy(value) {
+	return typeof value === "object" && value !== null && "access" in value && typeof value.access === "string";
+}
+//#endregion
+//#region src/tui/auth.ts
+/**
+* Detect available auth for every registered provider.
+*
+* Resolution order per provider (a method appears in `methods` for each
+* layer that has a credential — the agent itself resolves them in the same
+* order via its provider factories):
+*
+*   1. `kind: 'apikey'` from `credentials.json` (injected into env at TUI launch)
+*   2. explicit env var (descriptor's `envKey`)
+*   3. `kind: 'oauth'` from `credentials.json` (or legacy `cwd/.credentials.json`)
+*
+* Pure read — never refreshes or rewrites the credentials file.
+*/
+function detectAuth(dataDir, registry, env = process.env) {
+	const creds = readCredentials(dataDir);
+	return Object.values(registry).map((descriptor) => {
+		const methods = [];
+		const fileEntry = creds[credKeyOf(descriptor)];
+		if (fileEntry?.kind === "apikey" && fileEntry.value) methods.push({
+			source: "apikey",
+			detail: "credentials.json"
+		});
+		if (descriptor.envKey && env[descriptor.envKey]) methods.push({
+			source: "env",
+			detail: descriptor.envKey
+		});
+		if (fileEntry?.kind === "oauth" && fileEntry.access) {
+			const detail = typeof fileEntry.expires === "number" ? `oauth · expires ${new Date(fileEntry.expires).toLocaleString()}` : "oauth · credentials.json";
+			methods.push({
+				source: "oauth",
+				detail
+			});
+		}
+		return {
+			key: descriptor.key,
+			label: descriptor.label,
+			available: methods.length > 0,
+			methods
+		};
+	});
 }
 //#endregion
 //#region src/tui/store.ts
@@ -714,13 +890,12 @@ function resolveConfig(options = {}) {
 	const store = options.store ?? createTuiStore(paths.db);
 	const stateStore = createStateStore(paths.state);
 	const initialState = stateStore.load();
-	const providers = {
-		...FACTORIES,
-		...options.providers ?? {}
-	};
+	const providers = options.providers ?? BUILTIN_PROVIDERS;
 	const preset = options.preset ?? basic_default;
-	const modelsFor = makeModelsResolver(options.models);
-	const resumeProvider = resolveResumeProvider(initialState, providers);
+	process.env.ZIDANE_CREDENTIALS_PATH = credentialsPath(dir);
+	applyApiKeyEnv(dir, providers);
+	const modelsFor = makeModelsResolver(providers);
+	const resumeProvider = resolveResumeProvider(initialState, providers, dir);
 	const initialPicked = resumeProvider ? pickInitial(resumeProvider, providers, initialState) : null;
 	return {
 		prefix,
@@ -737,31 +912,32 @@ function resolveConfig(options = {}) {
 		initialPicked
 	};
 }
-function makeModelsResolver(custom) {
+function makeModelsResolver(registry) {
 	return (key) => {
-		const overridden = custom?.[key];
-		if (overridden) return overridden;
-		try {
-			const piId = PI_PROVIDER_ID[key];
-			return getModels(piId);
-		} catch {
-			return [];
-		}
+		const descriptor = registry[key];
+		return descriptor ? modelsForDescriptor(descriptor) : [];
 	};
 }
-function resolveResumeProvider(state, providers) {
+function resolveResumeProvider(state, providers, storageDir) {
 	if (!state.lastProvider) return null;
 	if (!providers[state.lastProvider]) return null;
-	return detectAuth().find((p) => p.key === state.lastProvider && p.available) ?? null;
+	return detectAuth(storageDir, providers).find((p) => p.key === state.lastProvider && p.available) ?? null;
 }
 function pickInitial(auth, providers, state) {
-	const factory = providers[auth.key];
-	if (!factory) return null;
-	const provider = factory();
-	return {
+	const descriptor = providers[auth.key];
+	if (!descriptor) return null;
+	const model = state.lastModelByProvider?.[auth.key] ?? descriptor.defaultModel ?? safeFactoryDefault(descriptor);
+	return model ? {
 		provider: auth,
-		model: state.lastModelByProvider?.[auth.key] ?? provider.meta.defaultModel
-	};
+		model
+	} : null;
+}
+function safeFactoryDefault(descriptor) {
+	try {
+		return descriptor.factory().meta.defaultModel;
+	} catch {
+		return;
+	}
 }
 const ConfigContext = createContext(null);
 function ConfigProvider({ config, children }) {
@@ -868,9 +1044,10 @@ function Modal({ title, onClose, children, maxWidth = 92, minWidth = 44, horizon
 /** Cap the visible scroll window so a 30-model list doesn't push the modal off-screen. */
 const VISIBLE_ROW_CAP = 12;
 /**
-* Modal that lists the available models for the current provider and lets the
-* user pick one. Options come from `runTui({ models })` if supplied, otherwise
-* from pi-ai's built-in registry.
+* Modal that lists the available models for the current provider and lets
+* the user pick one. Options come from the active `ProviderDescriptor` —
+* either its declared `models` list or, when absent, pi-ai's built-in
+* registry looked up via `piProviderId`.
 *
 * Each row shows: `● selected · name (ctx N · reasoning · vision)`.
 */
@@ -933,9 +1110,21 @@ function EmptyState() {
 		children: [/* @__PURE__ */ jsx("text", {
 			fg: COLOR.dim,
 			children: "No models available for this provider."
-		}), /* @__PURE__ */ jsx("text", {
+		}), /* @__PURE__ */ jsxs("text", {
 			fg: COLOR.mute,
-			children: "Pass a `models` registry to `runTui()` to populate this list."
+			children: [
+				"Set",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.model,
+					children: " models "
+				}),
+				"on the provider descriptor (or a",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.model,
+					children: " piProviderId "
+				}),
+				"that pi-ai recognizes) to populate this list."
+			]
 		})]
 	});
 }
@@ -947,35 +1136,140 @@ function describeModel(m) {
 	return parts.join(" · ");
 }
 //#endregion
+//#region src/tui/oauth.ts
+function supportsOAuth(descriptor) {
+	return descriptor.oauthProvider !== void 0;
+}
+/**
+* Run the OAuth login flow for a provider.
+*
+* Returns the OAuth credentials on success; caller persists them via
+* `setProviderCredential(dataDir, descriptor, { kind: 'oauth', ...credentials })`.
+* Throws when the descriptor has no `oauthProvider` configured.
+*/
+async function runOAuthLogin(descriptor, options) {
+	if (!descriptor.oauthProvider) throw new Error(`OAuth not supported for ${descriptor.label} (${descriptor.key}) — use an API key instead.`);
+	const callbacks = {
+		onAuth: (info) => {
+			options.onUrl(info.url, info.instructions);
+			tryOpenBrowser(info.url);
+		},
+		onPrompt: async () => {
+			if (!options.onCodeRequest) throw new Error("OAuth flow requires manual code input but no handler is wired.");
+			return options.onCodeRequest();
+		},
+		onProgress: options.onProgress,
+		signal: options.signal
+	};
+	return descriptor.oauthProvider.login(callbacks);
+}
+/**
+* Best-effort cross-platform browser open. macOS uses `open`, Linux uses
+* `xdg-open`, Windows uses `start`. Failures are swallowed — the callback
+* server is already listening, and the URL is displayed in the TUI for
+* manual click.
+*
+* Uses `spawn` (not `exec`) so the URL is passed as an argv element rather
+* than interpolated into a shell command — no need to think about quoting
+* URLs that contain `&`, `?`, `"` or other shell metacharacters.
+*/
+function tryOpenBrowser(url) {
+	const [cmd, ...args] = (() => {
+		if (process.platform === "darwin") return ["open", url];
+		if (process.platform === "win32") return [
+			"cmd",
+			"/c",
+			"start",
+			"",
+			url
+		];
+		return ["xdg-open", url];
+	})();
+	try {
+		const child = spawn(cmd, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+//#endregion
 //#region src/tui/screens.tsx
 /**
-* Textarea bindings: plain `enter` submits; `shift+enter` inserts a newline.
-* All `return` defaults are stripped and replaced so the user's preferred
-* binding wins regardless of modifier state.
+* Build a key-binding set for the prompt textarea / API-key input. Strips the
+* default `return` action and reinstalls it with our preferred meaning, so the
+* binding wins regardless of modifier state. Pass `allowShiftReturnNewline`
+* to enable `shift+enter` → newline (multi-line input).
 */
-const TEXTAREA_BINDINGS = [
-	...defaultTextareaKeyBindings.filter((b) => b.name !== "return"),
-	{
+function makeSubmitBindings(allowShiftReturnNewline) {
+	const base = defaultTextareaKeyBindings.filter((b) => b.name !== "return");
+	return allowShiftReturnNewline ? [
+		...base,
+		{
+			name: "return",
+			action: "submit"
+		},
+		{
+			name: "return",
+			shift: true,
+			action: "newline"
+		}
+	] : [...base, {
 		name: "return",
 		action: "submit"
-	},
-	{
-		name: "return",
-		shift: true,
-		action: "newline"
-	}
-];
+	}];
+}
+const TEXTAREA_BINDINGS = makeSubmitBindings(true);
+const API_KEY_INPUT_BINDINGS = makeSubmitBindings(false);
+/**
+* Look up a `{ key }` item by the value of a `<select>` option. Used by every
+* screen that mixes keyed-entry rows with sentinel "+ new" / "← back" rows —
+* sentinel handling stays explicit at the call site, this helper just trims
+* the boilerplate `.find(i => i.key === ...)` typing.
+*/
+function findByKey(items, value) {
+	return typeof value === "string" ? items.find((i) => i.key === value) : void 0;
+}
+/**
+* Sentinel value used by the picker's "+ add / re-configure" option. Lives
+* outside the provider key namespace (key strings are at least one char, no
+* leading `__`) so we can't collide with a real registry entry.
+*/
+const WIZARD_OPTION_VALUE = "__wizard__";
 function AuthScreen({ onPick }) {
-	const { providers: registry } = useConfig();
+	const config = useConfig();
+	const { providers: registry } = config;
 	const focused = useModalAwareFocus();
-	const providers = useMemo(() => detectAuth().filter((p) => p.key in registry), [registry]);
+	const [providers, setProviders] = useState([]);
+	const refresh = useCallback(() => setProviders(detectAuth(config.paths.dir, registry)), [config.paths.dir, registry]);
+	useEffect(() => {
+		refresh();
+	}, [refresh]);
+	const [forceWizard, setForceWizard] = useState(false);
 	const available = useMemo(() => providers.filter((p) => p.available), [providers]);
-	if (available.length === 0) return /* @__PURE__ */ jsx(NoAuthScreen, { providers });
-	const options = available.map((p) => ({
+	const onWizardDone = useCallback(() => {
+		setForceWizard(false);
+		refresh();
+	}, [refresh]);
+	if (available.length === 0 || forceWizard) {
+		const canCancel = forceWizard && available.length > 0;
+		return /* @__PURE__ */ jsx(SetupWizard, {
+			registry,
+			dataDir: config.paths.dir,
+			onConfigured: onWizardDone,
+			onCancel: canCancel ? () => setForceWizard(false) : void 0
+		});
+	}
+	const options = [...available.map((p) => ({
 		name: p.label,
 		description: p.methods.map((m) => m.detail).join(" · "),
 		value: p.key
-	}));
+	})), {
+		name: "+ add or re-configure a provider",
+		description: "launch the setup wizard",
+		value: WIZARD_OPTION_VALUE
+	}];
 	return /* @__PURE__ */ jsx("box", {
 		title: " pick a provider ",
 		style: {
@@ -992,48 +1286,318 @@ function AuthScreen({ onPick }) {
 			wrapSelection: true,
 			onSelect: (_idx, option) => {
 				if (!option) return;
-				const provider = available.find((p) => p.key === option.value);
+				if (option.value === WIZARD_OPTION_VALUE) {
+					setForceWizard(true);
+					return;
+				}
+				const provider = findByKey(available, option.value);
 				if (provider) onPick(provider);
 			},
 			style: { flexGrow: 1 }
 		})
 	});
 }
-function NoAuthScreen({ providers }) {
+function SetupWizard({ registry, dataDir, onConfigured, onCancel }) {
+	const [step, setStep] = useState({ kind: "pick-provider" });
+	const [error, setError] = useState(null);
+	const descriptors = useMemo(() => Object.values(registry), [registry]);
+	const onPickProvider = useCallback((descriptor) => {
+		setError(null);
+		setStep({
+			kind: "pick-method",
+			descriptor
+		});
+	}, []);
+	const onPickMethod = useCallback((descriptor, method) => {
+		setError(null);
+		if (method === "apikey") setStep({
+			kind: "enter-apikey",
+			descriptor
+		});
+		else setStep({
+			kind: "oauth-running",
+			descriptor
+		});
+	}, []);
+	const onApiKeySubmit = useCallback((descriptor, value) => {
+		const trimmed = value.trim();
+		if (!trimmed) {
+			setError("API key cannot be empty.");
+			return;
+		}
+		try {
+			setProviderCredential(dataDir, descriptor, {
+				kind: "apikey",
+				value: trimmed
+			});
+			if (descriptor.envKey) process.env[descriptor.envKey] = trimmed;
+			onConfigured();
+		} catch (err) {
+			setError(err instanceof Error ? err.message : String(err));
+		}
+	}, [dataDir, onConfigured]);
+	if (descriptors.length === 0) return /* @__PURE__ */ jsx(EmptyRegistryNotice, {});
+	if (step.kind === "pick-provider") return /* @__PURE__ */ jsx(PickProviderStep, {
+		descriptors,
+		error,
+		onPick: onPickProvider,
+		onCancel
+	});
+	if (step.kind === "pick-method") return /* @__PURE__ */ jsx(PickMethodStep, {
+		descriptor: step.descriptor,
+		error,
+		onPick: onPickMethod
+	});
+	if (step.kind === "enter-apikey") return /* @__PURE__ */ jsx(EnterApiKeyStep, {
+		descriptor: step.descriptor,
+		error,
+		onSubmit: onApiKeySubmit
+	});
+	return /* @__PURE__ */ jsx(OAuthRunningStep, {
+		descriptor: step.descriptor,
+		dataDir,
+		onSuccess: onConfigured,
+		onError: (msg) => {
+			setError(msg);
+			setStep({
+				kind: "pick-method",
+				descriptor: step.descriptor
+			});
+		}
+	});
+}
+/**
+* Shared wrapper for every wizard step — same border + padding + flex layout
+* with a customizable title and accent color. Footnote slot at the bottom for
+* an error banner.
+*/
+function WizardPanel({ title, accent = COLOR.border, error, children }) {
 	return /* @__PURE__ */ jsxs("box", {
-		title: " no authentication detected ",
+		title,
 		style: {
 			border: true,
-			borderColor: COLOR.error,
+			borderColor: accent,
 			padding: 1,
-			flexDirection: "column",
 			gap: 1,
+			flexDirection: "column",
 			flexGrow: 1
 		},
+		children: [children, error && /* @__PURE__ */ jsx("text", {
+			fg: COLOR.error,
+			children: error
+		})]
+	});
+}
+/** "esc to exit" footer hint shared by every wizard step that doesn't offer a "← back" affordance. */
+function WizardEscHint() {
+	return /* @__PURE__ */ jsx("text", {
+		fg: COLOR.dim,
+		children: "esc to exit"
+	});
+}
+function EmptyRegistryNotice() {
+	return /* @__PURE__ */ jsxs(WizardPanel, {
+		title: " no providers configured ",
+		accent: COLOR.error,
+		children: [/* @__PURE__ */ jsx("text", {
+			fg: COLOR.error,
+			children: "This TUI has no providers registered."
+		}), /* @__PURE__ */ jsxs("text", {
+			fg: COLOR.dim,
+			children: [
+				"Pass providers via",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.model,
+					children: " runTui({ providers }) "
+				}),
+				"or use the built-ins via",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.model,
+					children: " BUILTIN_PROVIDERS "
+				}),
+				"."
+			]
+		})]
+	});
+}
+/** Sentinel option value used for the wizard's "← back to picker" entry. */
+const WIZARD_BACK_VALUE = "__back__";
+function PickProviderStep({ descriptors, error, onPick, onCancel }) {
+	const focused = useModalAwareFocus();
+	const options = [...descriptors.map((d) => {
+		const methods = supportsOAuth(d) ? ["API key", "OAuth"] : ["API key"];
+		return {
+			name: d.label,
+			description: methods.join(" · "),
+			value: d.key
+		};
+	}), ...onCancel ? [{
+		name: "← back",
+		description: "return to the provider list",
+		value: WIZARD_BACK_VALUE
+	}] : []];
+	return /* @__PURE__ */ jsxs(WizardPanel, {
+		title: onCancel ? " add or re-configure a provider " : " welcome to zidane · pick a provider ",
+		error,
+		children: [!onCancel && /* @__PURE__ */ jsxs("text", {
+			fg: COLOR.dim,
+			children: [
+				"No provider credentials yet. Pick a provider to configure — keys are stored in",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.model,
+					children: " ~/.zidane/credentials.json "
+				}),
+				"(owner-only)."
+			]
+		}), /* @__PURE__ */ jsx("select", {
+			...SELECT_THEME,
+			focused,
+			options,
+			wrapSelection: true,
+			onSelect: (_idx, option) => {
+				if (!option) return;
+				if (option.value === WIZARD_BACK_VALUE) {
+					onCancel?.();
+					return;
+				}
+				const descriptor = findByKey(descriptors, option.value);
+				if (descriptor) onPick(descriptor);
+			},
+			style: { flexGrow: 1 }
+		})]
+	});
+}
+function PickMethodStep({ descriptor, error, onPick }) {
+	const focused = useModalAwareFocus();
+	const options = useMemo(() => {
+		const items = [{
+			name: "API key",
+			description: `paste your ${descriptor.label} API key`,
+			value: "apikey"
+		}];
+		if (supportsOAuth(descriptor)) {
+			const hint = descriptor.oauthHint ? ` (${descriptor.oauthHint})` : "";
+			items.push({
+				name: "OAuth",
+				description: `browser-based sign-in${hint}`,
+				value: "oauth"
+			});
+		}
+		return items;
+	}, [descriptor]);
+	return /* @__PURE__ */ jsxs(WizardPanel, {
+		title: ` configure ${descriptor.label} — pick auth method `,
+		error,
+		children: [/* @__PURE__ */ jsx(WizardEscHint, {}), /* @__PURE__ */ jsx("select", {
+			...SELECT_THEME,
+			focused,
+			options,
+			wrapSelection: true,
+			onSelect: (_idx, option) => {
+				if (option) onPick(descriptor, option.value);
+			},
+			style: { flexGrow: 1 }
+		})]
+	});
+}
+function EnterApiKeyStep({ descriptor, error, onSubmit }) {
+	const focused = useModalAwareFocus();
+	const inputRef = useRef(null);
+	const submit = useCallback(() => {
+		onSubmit(descriptor, inputRef.current?.value ?? "");
+	}, [descriptor, onSubmit]);
+	return /* @__PURE__ */ jsxs(WizardPanel, {
+		title: ` configure ${descriptor.label} — paste API key `,
+		error,
+		children: [/* @__PURE__ */ jsxs("text", {
+			fg: COLOR.dim,
+			children: [
+				"Paste your",
+				` ${descriptor.label} `,
+				"API key and press",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.model,
+					children: " enter "
+				}),
+				"to save. Esc to exit."
+			]
+		}), /* @__PURE__ */ jsx("box", {
+			style: {
+				border: true,
+				borderColor: COLOR.borderActive,
+				paddingLeft: 1,
+				paddingRight: 1,
+				height: 3
+			},
+			children: /* @__PURE__ */ jsx("input", {
+				ref: inputRef,
+				focused,
+				keyBindings: API_KEY_INPUT_BINDINGS,
+				placeholder: descriptor.apiKeyPlaceholder ?? "API key…",
+				onSubmit: submit,
+				style: { flexGrow: 1 }
+			})
+		})]
+	});
+}
+function OAuthRunningStep({ descriptor, dataDir, onSuccess, onError }) {
+	const [url, setUrl] = useState(null);
+	const [status, setStatus] = useState("starting browser…");
+	useEffect(() => {
+		const ac = new AbortController();
+		let cancelled = false;
+		(async () => {
+			try {
+				const creds = await runOAuthLogin(descriptor, {
+					onUrl: (loginUrl) => {
+						if (cancelled) return;
+						setUrl(loginUrl);
+						setStatus("waiting for browser callback…");
+					},
+					onProgress: (message) => {
+						if (!cancelled) setStatus(message);
+					},
+					signal: ac.signal
+				});
+				if (cancelled) return;
+				setProviderCredential(dataDir, descriptor, {
+					kind: "oauth",
+					...creds
+				});
+				onSuccess();
+			} catch (err) {
+				if (cancelled) return;
+				onError(err instanceof Error ? err.message : String(err));
+			}
+		})();
+		return () => {
+			cancelled = true;
+			ac.abort();
+		};
+	}, [
+		descriptor,
+		dataDir,
+		onSuccess,
+		onError
+	]);
+	return /* @__PURE__ */ jsxs(WizardPanel, {
+		title: ` configure ${descriptor.label} — OAuth `,
 		children: [
-			/* @__PURE__ */ jsx("text", {
-				fg: COLOR.error,
-				children: "No provider credentials found."
-			}),
-			/* @__PURE__ */ jsx("text", {
-				fg: COLOR.dim,
-				children: "Set one of these env vars (or run `bun run auth` for OAuth):"
-			}),
-			providers.map((p) => /* @__PURE__ */ jsxs("text", {
-				fg: COLOR.dim,
-				children: [
-					"  · ",
-					/* @__PURE__ */ jsx("span", {
-						fg: COLOR.brand,
-						children: p.label
-					}),
-					" → ",
-					/* @__PURE__ */ jsx("span", {
-						fg: COLOR.model,
-						children: envKeyFor(p.key)
-					})
-				]
-			}, p.key))
+			/* @__PURE__ */ jsx(WizardEscHint, {}),
+			/* @__PURE__ */ jsx(Spinner, { label: status }),
+			url && /* @__PURE__ */ jsxs("box", {
+				style: {
+					flexDirection: "column",
+					gap: 0
+				},
+				children: [/* @__PURE__ */ jsx("text", {
+					fg: COLOR.dim,
+					children: "If the browser didn't open, visit:"
+				}), /* @__PURE__ */ jsx("text", {
+					fg: COLOR.model,
+					children: url
+				})]
+			})
 		]
 	});
 }
@@ -1074,7 +1638,7 @@ function SessionsScreen({ sessions, currentId, onPick, onCreate }) {
 			onSelect: (_idx, option) => {
 				if (!option) return;
 				if (option.value === NEW_VALUE) onCreate();
-				else onPick(option.value);
+				else if (typeof option.value === "string") onPick(option.value);
 			},
 			style: { flexGrow: 1 }
 		})
@@ -1087,7 +1651,7 @@ function ChatScreen({ events, busy, settings, onSubmit, session }) {
 	const title = useMemo(() => {
 		if (!session) return " untitled ";
 		const turns = `${session.turnCount} turn${session.turnCount === 1 ? "" : "s"}`;
-		return ` ${session.title}  ·  #${shortId(session.id)} · ${turns} `;
+		return ` ${session.title} · #${shortId(session.id)} · ${turns} `;
 	}, [session]);
 	const userPrompts = useMemo(() => events.filter((e) => e.kind === "info").map((e) => e.text.replace(/^❯ /, "")), [events]);
 	return /* @__PURE__ */ jsxs("box", {
@@ -1239,40 +1803,76 @@ function useSettings() {
 	if (!ctx) throw new Error("useSettings must be used inside <SettingsProvider>");
 	return ctx;
 }
-const ROWS = [
+const TOGGLES = [
 	{
+		kind: "toggle",
 		key: "showThinking",
 		label: "Thinking blocks",
 		description: "agent reasoning shown inline"
 	},
 	{
+		kind: "toggle",
 		key: "showToolCalls",
 		label: "Tool calls",
 		description: "the ↳ name(args) lines"
 	},
 	{
+		kind: "toggle",
 		key: "showToolResults",
 		label: "Tool outputs",
 		description: "the ┃ result blocks under tool calls"
 	}
 ];
-function SettingsModal() {
+function SettingsModal({ actions } = {}) {
 	const { settings, toggle } = useSettings();
-	const [cursor, setCursor] = useState(0);
+	const [cursor, setCursorRaw] = useState(0);
+	const items = useMemo(() => {
+		const actionItems = [];
+		if (actions?.onReauth) actionItems.push({
+			kind: "action",
+			id: "reauth",
+			label: "Authentication",
+			description: "switch provider, add another, or re-authenticate",
+			onPick: actions.onReauth
+		});
+		return [...TOGGLES, ...actionItems];
+	}, [actions]);
+	const safeCursor = Math.min(cursor, items.length - 1);
+	const setCursor = useCallback((update) => setCursorRaw((prev) => Math.min(Math.max(0, update(prev)), items.length - 1)), [items.length]);
 	useKeyboard((key) => {
-		if (key.name === "up" || key.ctrl && key.name === "p") setCursor((c) => Math.max(0, c - 1));
-		else if (key.name === "down" || key.ctrl && key.name === "n") setCursor((c) => Math.min(ROWS.length - 1, c + 1));
-		else if (key.name === "return" || key.name === "space") toggle(ROWS[cursor].key);
+		if (key.name === "up" || key.ctrl && key.name === "p") setCursor((c) => c - 1);
+		else if (key.name === "down" || key.ctrl && key.name === "n") setCursor((c) => c + 1);
+		else if (key.name === "return" || key.name === "space") {
+			const item = items[safeCursor];
+			if (!item) return;
+			if (item.kind === "toggle") toggle(item.key);
+			else item.onPick();
+		}
 	});
+	const firstActionIndex = items.findIndex((i) => i.kind === "action");
 	return /* @__PURE__ */ jsxs(Modal, {
 		title: "settings",
 		children: [/* @__PURE__ */ jsx("box", {
 			style: { flexDirection: "column" },
-			children: ROWS.map((row, i) => /* @__PURE__ */ jsx(SettingRowView, {
-				row,
-				enabled: settings[row.key],
-				focused: i === cursor
-			}, row.key))
+			children: items.map((item, i) => /* @__PURE__ */ jsxs("box", {
+				style: { flexDirection: "column" },
+				children: [i === firstActionIndex && i > 0 && /* @__PURE__ */ jsx("box", { style: {
+					border: ["top"],
+					borderColor: COLOR.mute,
+					height: 1,
+					marginTop: 1,
+					marginBottom: 1
+				} }), item.kind === "toggle" ? /* @__PURE__ */ jsx(ToggleRow, {
+					label: item.label,
+					description: item.description,
+					enabled: settings[item.key],
+					focused: i === safeCursor
+				}) : /* @__PURE__ */ jsx(ActionRow, {
+					label: item.label,
+					description: item.description,
+					focused: i === safeCursor
+				})]
+			}, item.kind === "toggle" ? item.key : item.id))
 		}), /* @__PURE__ */ jsxs("text", {
 			fg: COLOR.mute,
 			children: [
@@ -1285,7 +1885,7 @@ function SettingsModal() {
 					fg: COLOR.warn,
 					children: "↵"
 				}),
-				" toggle · ",
+				firstActionIndex >= 0 ? " toggle/select · " : " toggle · ",
 				/* @__PURE__ */ jsx("span", {
 					fg: COLOR.warn,
 					children: "esc"
@@ -1296,14 +1896,13 @@ function SettingsModal() {
 	});
 }
 /**
-* A single setting row — `▶` marker · checkbox · label · description.
+* Toggle row — `▶` marker · checkbox · label · description.
 *
 * Rendered as one `<text>` so OpenTUI's word-wrap handles narrow terminals
 * automatically: on wide screens everything sits on one line; on narrow ones
-* the trailing description wraps under the label without breaking the row's
-* structure.
+* the trailing description wraps under the label without breaking the row.
 */
-function SettingRowView({ row, enabled, focused }) {
+function ToggleRow({ label, description, enabled, focused }) {
 	return /* @__PURE__ */ jsxs("text", {
 		fg: focused ? COLOR.brand : COLOR.dim,
 		children: [
@@ -1317,11 +1916,42 @@ function SettingRowView({ row, enabled, focused }) {
 			}),
 			/* @__PURE__ */ jsx("span", {
 				fg: focused ? COLOR.brand : COLOR.dim,
-				children: row.label
+				children: label
 			}),
 			/* @__PURE__ */ jsx("span", {
 				fg: COLOR.mute,
-				children: `  ${row.description}`
+				children: `  ${description}`
+			})
+		]
+	});
+}
+/**
+* Action row — cursor marker · label · description · (focus-only) trailing arrow.
+*
+* The label sits in the same column as a toggle row's `[✓]` checkbox (right
+* after the 2-col cursor slot). The trailing `›` only renders when focused
+* so it reads as a "this row runs" affordance, not a static decoration on
+* every action.
+*/
+function ActionRow({ label, description, focused }) {
+	return /* @__PURE__ */ jsxs("text", {
+		fg: focused ? COLOR.brand : COLOR.dim,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				fg: focused ? COLOR.brand : COLOR.mute,
+				children: focused ? "▶ " : "  "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: focused ? COLOR.brand : COLOR.accent,
+				children: label
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: `  ${description}`
+			}),
+			focused && /* @__PURE__ */ jsx("span", {
+				fg: COLOR.brand,
+				children: " ›"
 			})
 		]
 	});
@@ -1544,20 +2174,20 @@ function AppShell() {
 	const sessionRef = useRef(null);
 	const stream = useStreamBuffer(setEvents);
 	const makePicked = useCallback((provider, modelId) => {
-		const factory = providerRegistry[provider.key];
-		if (!factory) return null;
+		const descriptor = providerRegistry[provider.key];
+		if (!descriptor) return null;
 		const remembered = initialState.lastModelByProvider?.[provider.key];
 		return {
 			provider,
-			model: modelId ?? remembered ?? factory().meta.defaultModel
+			model: modelId ?? remembered ?? descriptor.defaultModel ?? descriptor.factory().meta.defaultModel
 		};
 	}, [providerRegistry, initialState]);
 	const buildAgent = useCallback((session, key) => {
-		const factory = providerRegistry[key];
-		if (!factory) throw new Error(`No provider registered for key "${key}"`);
+		const descriptor = providerRegistry[key];
+		if (!descriptor) throw new Error(`No provider registered for key "${key}"`);
 		const agent = createAgent({
 			...preset,
-			provider: factory(),
+			provider: descriptor.factory(),
 			session
 		});
 		agent.hooks.hook("stream:thinking", ({ delta }) => stream.queueStreamDelta("thinking", delta));
@@ -1799,10 +2429,14 @@ function AppShell() {
 		events.length,
 		stream
 	]);
+	const onReauth = useCallback(() => {
+		modal.close();
+		setScreen("auth");
+	}, [modal]);
 	useKeyboard((key) => {
 		if (modal.isOpen) return;
 		if (key.ctrl && key.name === "," && screen !== "auth") {
-			modal.open(/* @__PURE__ */ jsx(SettingsModal, {}));
+			modal.open(/* @__PURE__ */ jsx(SettingsModal, { actions: { onReauth } }));
 			return;
 		}
 		if (key.ctrl && key.name === "m" && screen === "chat" && picked && !busy) {
@@ -1821,6 +2455,10 @@ function AppShell() {
 			else renderer.destroy();
 			return;
 		}
+		if (picked) {
+			setScreen(currentSession ? "chat" : "sessions");
+			return;
+		}
 		renderer.destroy();
 	});
 	const hints = useMemo(() => buildHints(screen, busy, currentSession), [
@@ -1830,7 +2468,9 @@ function AppShell() {
 	]);
 	const contextUsage = useMemo(() => {
 		if (screen !== "chat" || !picked) return null;
-		const max = modelsFor(picked.provider.key).find((m) => m.id === picked.model)?.contextWindow ?? getContextWindow(picked.provider.key, picked.model);
+		const descriptor = providerRegistry[picked.provider.key];
+		if (!descriptor) return null;
+		const max = getContextWindow(descriptor, picked.model);
 		return max ? {
 			used: lastInputTokens,
 			max
@@ -1839,7 +2479,7 @@ function AppShell() {
 		screen,
 		picked,
 		lastInputTokens,
-		modelsFor
+		providerRegistry
 	]);
 	useEffect(() => () => {
 		teardown();
@@ -1971,15 +2611,14 @@ let runTuiInvoked = false;
 * to `runTui({ storageDir, prefix })`.
 *
 * ```ts
-* import { runTui } from 'zidane/tui'
+* import { BUILTIN_PROVIDERS, runTui } from 'zidane/tui'
 * import { createRemoteStore } from 'zidane/session'  // for the `store` option
 *
 * await runTui()                                       // ~/.zidane/sessions.db + state.json
 * await runTui({ prefix: '.myapp' })                   // ~/.myapp/...
 * await runTui({ storageDir: '/data', prefix: 'myapp' })
-* await runTui({ providers: { custom: () => myProvider() } })
+* await runTui({ providers: { ...BUILTIN_PROVIDERS, mine: myDescriptor } })
 * await runTui({ store: createRemoteStore({ url: '…' }) })
-* await runTui({ models: { anthropic: [{ id: 'claude-foo', contextWindow: 200_000 }] } })
 * ```
 */
 async function runTui(options = {}) {
@@ -1999,6 +2638,6 @@ async function runTui(options = {}) {
 	process.exit(0);
 }
 //#endregion
-export { App, AuthScreen, COLOR, ChatScreen, ConfigProvider, DEFAULT_SETTINGS, FACTORIES, Footer, MD_STYLE, Modal, ModalRoot, ModelPickerModal, PI_PROVIDER_ID, SELECT_THEME, SessionsScreen, SettingsModal, SettingsProvider, Spinner, Transcript, ageString, createStateStore, createTuiStore, detectAuth, envKeyFor, eventsFromTurns, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, fmtTokens, getContextWindow, lastContextSizeFromTurns, listSessionMeta, loadState, marginTopFor, onInputSubmit, resolveConfig, runTui, saveState, shortId, titleFromTurns, toolCallPreview, toolResultText, turnContextSize, useConfig, useModal, useModalAwareFocus, useSettings, useStreamBuffer };
+export { App, AuthScreen, BUILTIN_PROVIDERS, COLOR, ChatScreen, ConfigProvider, DEFAULT_SETTINGS, Footer, MD_STYLE, Modal, ModalRoot, ModelPickerModal, SELECT_THEME, SessionsScreen, SettingsModal, SettingsProvider, Spinner, Transcript, ageString, anthropicDescriptor, applyApiKeyEnv, cerebrasDescriptor, createStateStore, createTuiStore, credKeyOf, credentialsPath, detectAuth, eventsFromTurns, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, fmtTokens, getContextWindow, lastContextSizeFromTurns, listSessionMeta, loadState, marginTopFor, modelsForDescriptor, onInputSubmit, openaiDescriptor, openrouterDescriptor, piIdOf, readCredentials, readProviderCredential, removeProviderCredential, resolveConfig, runOAuthLogin, runTui, saveState, setProviderCredential, shortId, supportsOAuth, titleFromTurns, toolCallPreview, toolResultText, turnContextSize, useConfig, useModal, useModalAwareFocus, useSettings, useStreamBuffer, writeCredentials };
 
 //# sourceMappingURL=tui.js.map