@f5-sales-demo/xcsh 20.5.1 → 20.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "20.5.1",
+	"version": "20.6.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -44,6 +44,7 @@
 		"fmt": "biome format --write . && bun run format-prompts",
 		"format-prompts": "bun scripts/format-prompts.ts",
 		"mermaid:gallery": "bun scripts/mermaid-gallery.ts",
+		"uat:auth-profiles": "bun scripts/auth-profile-rpc-uat.ts",
 		"generate-docs-index": "bun scripts/generate-docs-index.ts",
 		"generate-api-spec-index": "bun scripts/generate-api-spec-index.ts",
 		"generate-branding-index": "bun scripts/generate-branding-index.ts",
@@ -60,13 +61,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@mozilla/readability": "^0.6",
-		"@f5-sales-demo/xcsh-stats": "20.5.1",
-		"@f5-sales-demo/pi-agent-core": "20.5.1",
-		"@f5-sales-demo/pi-ai": "20.5.1",
-		"@f5-sales-demo/pi-natives": "20.5.1",
-		"@f5-sales-demo/pi-resource-management": "20.5.1",
-		"@f5-sales-demo/pi-tui": "20.5.1",
-		"@f5-sales-demo/pi-utils": "20.5.1",
+		"@f5-sales-demo/xcsh-stats": "20.6.0",
+		"@f5-sales-demo/pi-agent-core": "20.6.0",
+		"@f5-sales-demo/pi-ai": "20.6.0",
+		"@f5-sales-demo/pi-natives": "20.6.0",
+		"@f5-sales-demo/pi-resource-management": "20.6.0",
+		"@f5-sales-demo/pi-tui": "20.6.0",
+		"@f5-sales-demo/pi-utils": "20.6.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/browser/chat-handler.ts

@@ -436,10 +436,10 @@ export class ChatHandler {
 			if (!defaultModel) {
 				throw new Error("Invalid baked default model selector");
 			}
-			const currentChoice = LITELLM_LOGIN_MODEL_CHOICES.find(
-				choice => choice.provider === this.#session.model?.provider && choice.modelId === this.#session.model.id,
-			);
-			const modelId = msg.model ?? currentChoice?.modelId ?? defaultModel.id;
+			// An omitted model means the baked Office default, never whichever model a
+			// previous CLI/global session happened to leave active. An explicit pane
+			// selection still wins through msg.model.
+			const modelId = msg.model ?? defaultModel.id;
 			const choice = LITELLM_LOGIN_MODEL_CHOICES.find(candidate => candidate.modelId === modelId);
 			const matchingProviders = (["anthropic", "litellm"] as const).filter(candidate =>
 				registry.find(candidate, modelId),

package/src/browser/headless-bridge.ts

@@ -15,6 +15,8 @@
  * NOT browser-safe (node/bun): runs inside the full xcsh binary, never the pane.
  */
 import { getProjectDir, getXCSHConfigDir } from "@f5-sales-demo/pi-utils";
+import { parseModelString } from "../config/model-resolver";
+import { DEFAULT_MODEL_ROLE } from "../config/settings-schema";
 import { createAgentSession } from "../sdk";
 import { ContextService } from "../services/xcsh-context";
 import { deriveTenantEnv } from "../services/xcsh-env";
@@ -141,6 +143,10 @@ export async function startHeadlessChatBridge(deps: HeadlessBridgeDeps = default
 	// selectProvider() reuses a dead bridge. The caller (startOfficeServe) treats
 	// the rethrow as a non-fatal "pane only" fallback.
 	try {
+		const officeDefault = parseModelString(DEFAULT_MODEL_ROLE);
+		if (!officeDefault) {
+			throw new Error("Invalid baked Office default model selector");
+		}
 		// Create ONE headless Office session with the full CLI-parity builtin set
 		// (OFFICE_TOOL_NAMES: bash/read/write/edit/grep/inspect_image/… — NO browser tools, which
 		// would be hallucinated in a document task pane). The document's own tools
@@ -148,6 +154,11 @@ export async function startHeadlessChatBridge(deps: HeadlessBridgeDeps = default
 		const { session } = await deps.createAgentSession({
 			cwd,
 			hasUI: false,
+			// Office must open on the production GPT profile regardless of a stale
+			// global/default role or resumable session. A saved pane model is applied
+			// afterward by its explicit configure frame and remains authoritative.
+			modelPattern: DEFAULT_MODEL_ROLE,
+			thinkingLevel: officeDefault.thinkingLevel,
 			// Office conversations can contain private workbook and working-directory
 			// data. Keep the entire headless session ephemeral instead of inheriting
 			// createAgentSession's file-backed default.

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "20.5.1",
-	"commit": "2ab4312e288d9147a956db45c74739efb6d950e4",
-	"shortCommit": "2ab4312",
+	"version": "20.6.0",
+	"commit": "fda51f1e37f9202c495558b6e33c0067e822967e",
+	"shortCommit": "fda51f1",
 	"branch": "main",
-	"tag": "v20.5.1",
-	"commitDate": "2026-08-05T22:06:08Z",
-	"buildDate": "2026-08-05T22:34:37.560Z",
+	"tag": "v20.6.0",
+	"commitDate": "2026-08-06T11:20:36Z",
+	"buildDate": "2026-08-06T11:58:39.606Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/2ab4312e288d9147a956db45c74739efb6d950e4",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.5.1"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/fda51f1e37f9202c495558b6e33c0067e822967e",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.6.0"
 };

package/src/modes/components/login-prompt-input.ts

@@ -0,0 +1,9 @@
+import type { OAuthPrompt } from "@f5-sales-demo/pi-ai";
+import { Input } from "@f5-sales-demo/pi-tui";
+
+/** Build a login input with the display policy declared by its prompt contract. */
+export function createLoginPromptInput(prompt: Partial<OAuthPrompt>): Input {
+	const input = new Input();
+	input.setMasked(prompt.secret === true);
+	return input;
+}

package/src/modes/components/oauth-selector.ts

@@ -1,5 +1,5 @@
 import { getOAuthProviders, type OAuthProviderInfo } from "@f5-sales-demo/pi-ai";
-import { Container, matchesKey, Spacer, TruncatedText } from "@f5-sales-demo/pi-tui";
+import { Container, Input, matchesKey, Spacer, Text, TruncatedText } from "@f5-sales-demo/pi-tui";
 import { theme } from "../../modes/theme/theme";
 import { matchesSelectCancel } from "../../modes/utils/keybinding-matchers";
 import type { AuthStorage } from "../../session/auth-storage";
@@ -8,8 +8,12 @@ import { DynamicBorder } from "./dynamic-border";
  * Component that renders an OAuth provider selector.
  */
 export class OAuthSelectorComponent extends Container {
+	static readonly MAX_VISIBLE_PROVIDERS = 10;
+
 	#listContainer: Container;
 	#allProviders: OAuthProviderInfo[] = [];
+	#filteredProviders: OAuthProviderInfo[] = [];
+	#searchInput: Input;
 	#selectedIndex: number = 0;
 	#mode: "login" | "logout";
 	#authStorage: AuthStorage;
@@ -47,6 +51,10 @@ export class OAuthSelectorComponent extends Container {
 		const title = mode === "login" ? "Select provider to login:" : "Select provider to logout:";
 		this.addChild(new TruncatedText(theme.bold(title)));
 		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("muted", "Type to filter providers:"), 0, 0));
+		this.#searchInput = new Input();
+		this.addChild(this.#searchInput);
+		this.addChild(new Spacer(1));
 		// Create list container
 		this.#listContainer = new Container();
 		this.addChild(this.#listContainer);
@@ -63,7 +71,20 @@ export class OAuthSelectorComponent extends Container {
 		this.#stopSpinner();
 	}
 	#loadProviders(): void {
-		this.#allProviders = getOAuthProviders();
+		this.#allProviders = getOAuthProviders().filter(provider => this.#mode === "login" || !provider.loginOnly);
+		this.#filteredProviders = this.#allProviders;
+	}
+
+	#filterProviders(query: string): void {
+		const normalizedQuery = query.trim().toLowerCase();
+		this.#filteredProviders = normalizedQuery
+			? this.#allProviders.filter(provider =>
+					`${provider.name} ${provider.id}`.toLowerCase().includes(normalizedQuery),
+				)
+			: this.#allProviders;
+		this.#selectedIndex = 0;
+		this.#statusMessage = undefined;
+		this.#updateList();
 	}
 
 	#startValidation(): void {
@@ -143,8 +164,15 @@ export class OAuthSelectorComponent extends Container {
 	}
 	#updateList(): void {
 		this.#listContainer.clear();
-		for (let i = 0; i < this.#allProviders.length; i++) {
-			const provider = this.#allProviders[i];
+		const maxVisible = OAuthSelectorComponent.MAX_VISIBLE_PROVIDERS;
+		const startIndex = Math.max(
+			0,
+			Math.min(this.#selectedIndex - maxVisible + 1, this.#filteredProviders.length - maxVisible),
+		);
+		const endIndex = Math.min(startIndex + maxVisible, this.#filteredProviders.length);
+
+		for (let i = startIndex; i < endIndex; i++) {
+			const provider = this.#filteredProviders[i];
 			if (!provider) continue;
 			const isSelected = i === this.#selectedIndex;
 			const isAvailable = provider.available;
@@ -167,32 +195,90 @@ export class OAuthSelectorComponent extends Container {
 			const message =
 				this.#mode === "login" ? "No OAuth providers available" : "No OAuth providers logged in. Use /login first.";
 			this.#listContainer.addChild(new TruncatedText(theme.fg("muted", `  ${message}`), 0, 0));
+		} else if (this.#filteredProviders.length === 0) {
+			this.#listContainer.addChild(new TruncatedText(theme.fg("muted", "  No matching providers"), 0, 0));
+			this.#listContainer.addChild(
+				new TruncatedText(theme.fg("muted", `  0 matches (${this.#allProviders.length} total)`), 0, 0),
+			);
+		} else if (this.#searchInput.getValue()) {
+			const matchLabel = this.#filteredProviders.length === 1 ? "match" : "matches";
+			this.#listContainer.addChild(
+				new TruncatedText(
+					theme.fg(
+						"muted",
+						`  ${this.#filteredProviders.length} ${matchLabel} (${this.#allProviders.length} total)`,
+					),
+					0,
+					0,
+				),
+			);
+		} else {
+			this.#listContainer.addChild(
+				new TruncatedText(
+					theme.fg("muted", `  Showing ${startIndex + 1}-${endIndex} of ${this.#filteredProviders.length}`),
+					0,
+					0,
+				),
+			);
 		}
 		if (this.#statusMessage) {
 			this.#listContainer.addChild(new Spacer(1));
 			this.#listContainer.addChild(new TruncatedText(theme.fg("warning", `  ${this.#statusMessage}`), 0, 0));
 		}
+		this.#listContainer.addChild(new Spacer(1));
+		this.#listContainer.addChild(
+			new TruncatedText(theme.fg("muted", "  Type to filter providers · Enter: select · Esc: clear/cancel"), 0, 0),
+		);
 	}
 	handleInput(keyData: string): void {
 		// Up arrow
 		if (matchesKey(keyData, "up")) {
-			if (this.#allProviders.length > 0) {
-				this.#selectedIndex = this.#selectedIndex === 0 ? this.#allProviders.length - 1 : this.#selectedIndex - 1;
+			if (this.#filteredProviders.length > 0) {
+				this.#selectedIndex =
+					this.#selectedIndex === 0 ? this.#filteredProviders.length - 1 : this.#selectedIndex - 1;
 			}
 			this.#statusMessage = undefined;
 			this.#updateList();
 		}
 		// Down arrow
 		else if (matchesKey(keyData, "down")) {
-			if (this.#allProviders.length > 0) {
-				this.#selectedIndex = this.#selectedIndex === this.#allProviders.length - 1 ? 0 : this.#selectedIndex + 1;
+			if (this.#filteredProviders.length > 0) {
+				this.#selectedIndex =
+					this.#selectedIndex === this.#filteredProviders.length - 1 ? 0 : this.#selectedIndex + 1;
 			}
 			this.#statusMessage = undefined;
 			this.#updateList();
 		}
+		// Page up
+		else if (matchesKey(keyData, "pageUp")) {
+			this.#selectedIndex = Math.max(0, this.#selectedIndex - OAuthSelectorComponent.MAX_VISIBLE_PROVIDERS);
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
+		// Page down
+		else if (matchesKey(keyData, "pageDown")) {
+			this.#selectedIndex = Math.min(
+				Math.max(0, this.#filteredProviders.length - 1),
+				this.#selectedIndex + OAuthSelectorComponent.MAX_VISIBLE_PROVIDERS,
+			);
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
+		// Home
+		else if (matchesKey(keyData, "home")) {
+			this.#selectedIndex = 0;
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
+		// End
+		else if (matchesKey(keyData, "end")) {
+			this.#selectedIndex = Math.max(0, this.#filteredProviders.length - 1);
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
 		// Enter
 		else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
-			const selectedProvider = this.#allProviders[this.#selectedIndex];
+			const selectedProvider = this.#filteredProviders[this.#selectedIndex];
 			if (selectedProvider?.available) {
 				this.#statusMessage = undefined;
 				this.stopValidation();
@@ -204,8 +290,20 @@ export class OAuthSelectorComponent extends Container {
 		}
 		// Escape or Ctrl+C
 		else if (matchesSelectCancel(keyData)) {
+			if (this.#searchInput.getValue()) {
+				this.#searchInput.setValue("");
+				this.#filterProviders("");
+				return;
+			}
 			this.stopValidation();
 			this.#onCancelCallback();
 		}
+		// Everything else edits the provider filter.
+		else {
+			const previousQuery = this.#searchInput.getValue();
+			this.#searchInput.handleInput(keyData);
+			const nextQuery = this.#searchInput.getValue();
+			if (nextQuery !== previousQuery) this.#filterProviders(nextQuery);
+		}
 	}
 }

package/src/modes/controllers/enterprise-oauth-login-flow.ts

@@ -0,0 +1,94 @@
+export type EnterpriseOAuthRecoveryAction = "retry" | "edit" | "cancel";
+export type EnterpriseOAuthLoginAction = "initial" | EnterpriseOAuthRecoveryAction;
+export type EnterpriseOAuthLoginStage = "authenticate" | "apply";
+
+export interface EnterpriseOAuthRecoveryRequest {
+	stage: EnterpriseOAuthLoginStage;
+	error: string;
+	canEdit: true;
+}
+
+export type EnterpriseOAuthLoginResult = { status: "completed" } | { status: "cancelled" };
+
+interface EnterpriseOAuthLoginFlowOptions<TSnapshot> {
+	capture(): Promise<TSnapshot> | TSnapshot;
+	authenticate(action: EnterpriseOAuthLoginAction): Promise<void>;
+	applyModel(): Promise<boolean>;
+	restore(snapshot: TSnapshot): Promise<void>;
+	recover(request: EnterpriseOAuthRecoveryRequest): Promise<EnterpriseOAuthRecoveryAction>;
+	sleep?(milliseconds: number): Promise<void>;
+	maxAutomaticRetries?: number;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function isCancellation(error: unknown): boolean {
+	return (
+		(error instanceof Error && error.name === "AbortError") ||
+		/\b(login |authentication )?cancelled\b/i.test(errorMessage(error))
+	);
+}
+
+function isTransientAuthenticationError(error: unknown): boolean {
+	return /\b(fetch|network|timeout|timed out|ECONN(?:RESET|REFUSED)|EAI_AGAIN|429|5\d\d)\b/i.test(errorMessage(error));
+}
+
+async function restoreOrThrow<TSnapshot>(
+	options: EnterpriseOAuthLoginFlowOptions<TSnapshot>,
+	snapshot: TSnapshot,
+	originalError: unknown,
+): Promise<void> {
+	try {
+		await options.restore(snapshot);
+	} catch (rollbackError) {
+		throw new AggregateError([originalError, rollbackError], "Enterprise login failed and rollback was incomplete");
+	}
+}
+
+/** Coordinate enterprise OAuth, model application, bounded retries, and rollback. */
+export async function runEnterpriseOAuthLoginFlow<TSnapshot>(
+	options: EnterpriseOAuthLoginFlowOptions<TSnapshot>,
+): Promise<EnterpriseOAuthLoginResult> {
+	const snapshot = await options.capture();
+	const sleep = options.sleep ?? Bun.sleep;
+	const maxAutomaticRetries = options.maxAutomaticRetries ?? 2;
+	let action: EnterpriseOAuthLoginAction = "initial";
+	let automaticRetries = 0;
+
+	while (true) {
+		let stage: EnterpriseOAuthLoginStage = "authenticate";
+		try {
+			await options.authenticate(action);
+			stage = "apply";
+			if (!(await options.applyModel())) {
+				throw new Error("Gemini 3.6 Flash High is unavailable after authentication");
+			}
+			return { status: "completed" };
+		} catch (error) {
+			await restoreOrThrow(options, snapshot, error);
+			if (isCancellation(error)) return { status: "cancelled" };
+
+			if (
+				stage === "authenticate" &&
+				isTransientAuthenticationError(error) &&
+				automaticRetries < maxAutomaticRetries
+			) {
+				await sleep(250 * 2 ** automaticRetries);
+				automaticRetries += 1;
+				action = "retry";
+				continue;
+			}
+
+			const recoveryAction = await options.recover({
+				stage,
+				error: errorMessage(error),
+				canEdit: true,
+			});
+			if (recoveryAction === "cancel") return { status: "cancelled" };
+			action = recoveryAction;
+			automaticRetries = 0;
+		}
+	}
+}

package/src/modes/controllers/enterprise-oauth-login-transaction.ts

@@ -0,0 +1,103 @@
+import type { ThinkingLevel } from "@f5-sales-demo/pi-agent-core";
+import type { Model } from "@f5-sales-demo/pi-ai";
+
+type StoredCredential =
+	| { type: "api_key"; key: string }
+	| ({ type: "oauth" } & {
+			refresh: string;
+			access: string;
+			expires: number;
+			enterpriseUrl?: string;
+			projectId?: string;
+			tierId?: string;
+			email?: string;
+			accountId?: string;
+	  });
+
+interface EnterpriseOAuthTransactionSession {
+	model?: Model;
+	thinkingLevel?: ThinkingLevel;
+	modelRegistry: {
+		authStorage: {
+			get(provider: string): StoredCredential | undefined;
+			set(provider: string, credential: StoredCredential): Promise<void>;
+			remove(provider: string): Promise<void>;
+		};
+		refresh(mode: "online"): Promise<void>;
+	};
+	settings: {
+		getModelRoles(): Readonly<Record<string, string | undefined>>;
+		set(key: "modelRoles", value: Record<string, string>): void;
+	};
+	setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel): Promise<void>;
+	setThinkingLevel(level: ThinkingLevel): void;
+}
+
+export interface EnterpriseOAuthLoginSnapshot {
+	credential?: StoredCredential;
+	model?: Model;
+	thinkingLevel?: ThinkingLevel;
+	modelRoles: Record<string, string>;
+}
+
+const CANONICAL_PROVIDER = "google-antigravity";
+
+export function captureEnterpriseOAuthLoginState(
+	session: EnterpriseOAuthTransactionSession,
+): EnterpriseOAuthLoginSnapshot {
+	const credential = session.modelRegistry.authStorage.get(CANONICAL_PROVIDER);
+	const modelRoles = Object.fromEntries(
+		Object.entries(session.settings.getModelRoles()).filter(
+			(entry): entry is [string, string] => entry[1] !== undefined,
+		),
+	);
+	return {
+		credential: credential ? { ...credential } : undefined,
+		model: session.model,
+		thinkingLevel: session.thinkingLevel,
+		modelRoles,
+	};
+}
+
+/** Restore all durable and active state that enterprise login can replace. */
+export async function restoreEnterpriseOAuthLoginState(
+	session: EnterpriseOAuthTransactionSession,
+	snapshot: EnterpriseOAuthLoginSnapshot,
+): Promise<void> {
+	const rollbackErrors: unknown[] = [];
+	try {
+		if (snapshot.credential) {
+			await session.modelRegistry.authStorage.set(CANONICAL_PROVIDER, snapshot.credential);
+		} else {
+			await session.modelRegistry.authStorage.remove(CANONICAL_PROVIDER);
+		}
+	} catch (error) {
+		rollbackErrors.push(error);
+	}
+
+	try {
+		session.settings.set("modelRoles", { ...snapshot.modelRoles });
+	} catch (error) {
+		rollbackErrors.push(error);
+	}
+
+	try {
+		await session.modelRegistry.refresh("online");
+	} catch (error) {
+		rollbackErrors.push(error);
+	}
+
+	try {
+		if (snapshot.model) {
+			await session.setModelTemporary(snapshot.model, snapshot.thinkingLevel);
+		} else if (snapshot.thinkingLevel !== undefined) {
+			session.setThinkingLevel(snapshot.thinkingLevel);
+		}
+	} catch (error) {
+		rollbackErrors.push(error);
+	}
+
+	if (rollbackErrors.length > 0) {
+		throw new AggregateError(rollbackErrors, "Enterprise OAuth rollback was incomplete");
+	}
+}

package/src/modes/controllers/litellm-login-flow.ts

@@ -0,0 +1,109 @@
+import type { ProbeResult } from "../../config/auto-config";
+import { getAvailableLiteLLMLoginModelChoices, type LiteLLMLoginModelChoice } from "./login-model";
+
+export interface LiteLLMLoginCredentials {
+	baseUrl: string;
+	apiKey: string;
+}
+
+export type LoginRecoveryAction = "retry" | "edit" | "cancel";
+export type LiteLLMLoginStage = "probe" | "models" | "commit";
+
+export interface LoginRecoveryRequest {
+	stage: LiteLLMLoginStage;
+	error: string;
+	canEdit: boolean;
+}
+
+export interface LiteLLMLoginCommit {
+	credentials: LiteLLMLoginCredentials;
+	probe: ProbeResult;
+	choice: LiteLLMLoginModelChoice;
+}
+
+export type LiteLLMLoginFlowResult = { status: "completed"; choice: LiteLLMLoginModelChoice } | { status: "cancelled" };
+
+interface LiteLLMLoginFlowOptions {
+	collectCredentials(): Promise<LiteLLMLoginCredentials | null>;
+	probe(credentials: LiteLLMLoginCredentials): Promise<ProbeResult>;
+	selectModel(choices: readonly LiteLLMLoginModelChoice[]): Promise<LiteLLMLoginModelChoice | null>;
+	commit(input: LiteLLMLoginCommit): Promise<void>;
+	recover(request: LoginRecoveryRequest): Promise<LoginRecoveryAction>;
+	sleep?(milliseconds: number): Promise<void>;
+	maxAutomaticRetries?: number;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function isAuthenticationError(message: string): boolean {
+	return /\b(401|403|Unauthorized|Forbidden)\b/i.test(message);
+}
+
+/**
+ * Coordinate LiteLLM discovery and selection without persisting anything until
+ * the user has selected one of the certified models.
+ */
+export async function runLiteLLMLoginFlow(options: LiteLLMLoginFlowOptions): Promise<LiteLLMLoginFlowResult> {
+	const sleep = options.sleep ?? Bun.sleep;
+	const maxAutomaticRetries = options.maxAutomaticRetries ?? 2;
+
+	credentialsLoop: while (true) {
+		const credentials = await options.collectCredentials();
+		if (!credentials) return { status: "cancelled" };
+
+		let probe: ProbeResult;
+		let automaticRetries = 0;
+		while (true) {
+			try {
+				probe = await options.probe(credentials);
+			} catch (error) {
+				probe = { reachable: false, models: [], error: errorMessage(error) };
+			}
+
+			if (probe.reachable) break;
+			const error = probe.error ?? "connection failed";
+			if (!isAuthenticationError(error) && automaticRetries < maxAutomaticRetries) {
+				await sleep(250 * 2 ** automaticRetries);
+				automaticRetries += 1;
+				continue;
+			}
+
+			const action = await options.recover({ stage: "probe", error, canEdit: true });
+			if (action === "cancel") return { status: "cancelled" };
+			if (action === "edit") continue credentialsLoop;
+			automaticRetries = 0;
+		}
+
+		const choices = getAvailableLiteLLMLoginModelChoices(probe.models);
+		if (choices.length === 0) {
+			const action = await options.recover({
+				stage: "models",
+				error: "Neither GPT-5.6 Sol nor Claude Opus 5 is available from this proxy.",
+				canEdit: true,
+			});
+			if (action === "cancel") return { status: "cancelled" };
+			if (action === "edit") continue;
+			continue;
+		}
+
+		const choice = await options.selectModel(choices);
+		if (!choice) return { status: "cancelled" };
+
+		while (true) {
+			try {
+				await options.commit({ credentials, probe, choice });
+				return { status: "completed", choice };
+			} catch (error) {
+				const action = await options.recover({
+					stage: "commit",
+					error: errorMessage(error),
+					canEdit: true,
+				});
+				if (action === "cancel") return { status: "cancelled" };
+				if (action === "edit") continue credentialsLoop;
+			}
+		}
+	}
+}