@vib-rato/ai 0.16.0

package/src/utils/oauth/anthropic.ts

@@ -0,0 +1,233 @@
+/**
+ * Anthropic OAuth flow (Anthropic model Pro/Max)
+ */
+import { OAuthCallbackFlow, type OAuthCallbackFlowOptions } from "./callback-server";
+import { generatePKCE } from "./pkce";
+import type { OAuthController, OAuthCredentials } from "./types";
+
+const decode = (s: string) => atob(s);
+const CLIENT_ID = decode("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL = "https://api.anthropic.com/v1/oauth/token";
+const CALLBACK_PORT = 54545;
+const CALLBACK_PATH = "/callback";
+/**
+ * Redirect target for the paste-a-code login. Anthropic renders the
+ * authorization code on this page instead of redirecting into this machine, so
+ * a vib running over SSH, in a container, or on a headless box can be paired
+ * from a browser that has no route back to `localhost:54545`.
+ *
+ * Deliberately a hard-coded constant rather than an env/config override: this
+ * is where the authorization code is delivered, so making it injectable would
+ * turn any writable environment into an auth-code exfiltration channel.
+ */
+export const ANTHROPIC_MANUAL_REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
+const SCOPES = "org:create_api_key user:profile user:inference";
+
+function formatErrorDetails(error: unknown): string {
+	if (error instanceof Error) {
+		const details: string[] = [`${error.name}: ${error.message}`];
+		const errorWithCode = error as Error & { code?: string; errno?: number | string; cause?: unknown };
+		if (errorWithCode.code) details.push(`code=${errorWithCode.code}`);
+		if (typeof errorWithCode.errno !== "undefined") details.push(`errno=${String(errorWithCode.errno)}`);
+		if (typeof error.cause !== "undefined") {
+			details.push(`cause=${formatErrorDetails(error.cause)}`);
+		}
+		if (error.stack) {
+			details.push(`stack=${error.stack}`);
+		}
+		return details.join("; ");
+	}
+	return String(error);
+}
+
+async function postJson(url: string, body: Record<string, string | number>): Promise<string> {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json",
+		},
+		body: JSON.stringify(body),
+		signal: AbortSignal.timeout(30_000),
+	});
+
+	const responseBody = await response.text();
+	if (!response.ok) {
+		throw new Error(`HTTP request failed. status=${response.status}; url=${url}; body=${responseBody}`);
+	}
+	return responseBody;
+}
+
+/**
+ * Decoded shape of Anthropic's `/v1/oauth/token` response (both
+ * `authorization_code` exchange and `refresh_token` refresh return the same
+ * envelope). The `account` block is inlined alongside the tokens, so we can
+ * surface `accountId` / `email` on {@link OAuthCredentials} without a separate
+ * `/api/oauth/profile` round-trip.
+ */
+interface AnthropicTokenResponse {
+	access_token: string;
+	refresh_token: string;
+	expires_in: number;
+	account?: { uuid?: string; email_address?: string };
+}
+
+function parseOAuthTokenResponse(responseBody: string, operation: string): AnthropicTokenResponse {
+	try {
+		return JSON.parse(responseBody) as AnthropicTokenResponse;
+	} catch (error) {
+		throw new Error(
+			`Anthropic ${operation} returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`,
+		);
+	}
+}
+
+/**
+ * Lift the OAuth response's `account: { uuid, email_address }` block onto
+ * {@link OAuthCredentials} so downstream identity propagation (e.g.
+ * `metadata.user_id.account_uuid`, usage tracking) works without a separate
+ * `/api/oauth/profile` round-trip. Returns `undefined` for either field when
+ * the response omits it or carries a non-string / empty value.
+ */
+function extractAccountFromTokenResponse(data: AnthropicTokenResponse): {
+	accountId?: string;
+	email?: string;
+} {
+	const accountUuid = data.account?.uuid;
+	const emailAddress = data.account?.email_address;
+	return {
+		accountId: typeof accountUuid === "string" && accountUuid.length > 0 ? accountUuid : undefined,
+		email: typeof emailAddress === "string" && emailAddress.length > 0 ? emailAddress : undefined,
+	};
+}
+
+export interface AnthropicOAuthFlowOptions {
+	/**
+	 * Pair by pasting the code Anthropic displays instead of waiting on a local
+	 * `localhost:54545` callback. Use when the browser completing the login has
+	 * no network route back to the machine running vib.
+	 */
+	manualCode?: boolean;
+}
+
+export class AnthropicOAuthFlow extends OAuthCallbackFlow {
+	#verifier: string = "";
+	#challenge: string = "";
+	readonly #manualCode: boolean;
+
+	constructor(ctrl: OAuthController, options: AnthropicOAuthFlowOptions = {}) {
+		const manualCode = options.manualCode === true;
+		const flowOptions: OAuthCallbackFlowOptions = {
+			preferredPort: CALLBACK_PORT,
+			callbackPath: CALLBACK_PATH,
+			redirectUri: manualCode ? ANTHROPIC_MANUAL_REDIRECT_URI : undefined,
+			skipCallbackServer: manualCode,
+		};
+		super(ctrl, flowOptions);
+		this.#manualCode = manualCode;
+	}
+
+	async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> {
+		const pkce = await generatePKCE();
+		this.#verifier = pkce.verifier;
+		this.#challenge = pkce.challenge;
+
+		const authParams = new URLSearchParams({
+			code: "true",
+			client_id: CLIENT_ID,
+			response_type: "code",
+			redirect_uri: redirectUri,
+			scope: SCOPES,
+			code_challenge: this.#challenge,
+			code_challenge_method: "S256",
+			state,
+		});
+		const url = `${AUTHORIZE_URL}?${authParams.toString()}`;
+
+		return {
+			url,
+			instructions: this.#manualCode
+				? "Complete login in your browser. Anthropic will show an authorization code — paste it here."
+				: "Complete login in your browser. If the browser cannot reach this machine, paste the final redirect URL or authorization code when prompted. To pair by code instead, cancel this login and run /login anthropic --manual.",
+		};
+	}
+
+	async exchangeToken(code: string, state: string, redirectUri: string): Promise<OAuthCredentials> {
+		let exchangeCode = code;
+		let exchangeState = state;
+		const codeFragmentIndex = code.indexOf("#");
+		if (codeFragmentIndex >= 0) {
+			exchangeCode = code.slice(0, codeFragmentIndex);
+			const codeFragmentState = code.slice(codeFragmentIndex + 1);
+			if (codeFragmentState.length > 0) {
+				exchangeState = codeFragmentState;
+			}
+		}
+
+		let responseBody: string;
+		try {
+			responseBody = await postJson(TOKEN_URL, {
+				grant_type: "authorization_code",
+				client_id: CLIENT_ID,
+				code: exchangeCode,
+				state: exchangeState,
+				redirect_uri: redirectUri,
+				code_verifier: this.#verifier,
+			});
+		} catch (error) {
+			throw new Error(
+				`Token exchange request failed. url=${TOKEN_URL}; redirect_uri=${redirectUri}; response_type=authorization_code; details=${formatErrorDetails(error)}`,
+			);
+		}
+
+		const tokenData = parseOAuthTokenResponse(responseBody, "token exchange");
+		const { accountId, email } = extractAccountFromTokenResponse(tokenData);
+
+		return {
+			refresh: tokenData.refresh_token,
+			access: tokenData.access_token,
+			expires: Date.now() + tokenData.expires_in * 1000 - 5 * 60 * 1000,
+			accountId,
+			email,
+		};
+	}
+}
+
+/**
+ * Login with Anthropic OAuth
+ */
+export async function loginAnthropic(
+	ctrl: OAuthController,
+	options: AnthropicOAuthFlowOptions = {},
+): Promise<OAuthCredentials> {
+	const flow = new AnthropicOAuthFlow(ctrl, options);
+	return flow.login();
+}
+
+/**
+ * Refresh Anthropic OAuth token
+ */
+export async function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials> {
+	let responseBody: string;
+	try {
+		responseBody = await postJson(TOKEN_URL, {
+			grant_type: "refresh_token",
+			client_id: CLIENT_ID,
+			refresh_token: refreshToken,
+		});
+	} catch (error) {
+		throw new Error(`Anthropic token refresh request failed. url=${TOKEN_URL}; details=${formatErrorDetails(error)}`);
+	}
+
+	const data = parseOAuthTokenResponse(responseBody, "token refresh");
+	const { accountId, email } = extractAccountFromTokenResponse(data);
+
+	return {
+		refresh: data.refresh_token || refreshToken,
+		access: data.access_token,
+		expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
+		accountId,
+		email,
+	};
+}

package/src/utils/oauth/api-key-login.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared factory for API-key-paste "login" flows.
+ *
+ * Several providers (Cerebras, Synthetic, Moonshot, Together, NanoGPT, ZenMux,
+ * Command Code GOAT)
+ * don't actually implement OAuth — they just ask the user to paste an API key,
+ * optionally validate it, and return the trimmed key.
+ */
+
+import { validateApiKeyAgainstModelsEndpoint, validateOpenAICompatibleApiKey } from "./api-key-validation";
+import type { OAuthController } from "./types";
+
+type ChatCompletionsValidation = {
+	kind: "chat-completions";
+	provider: string;
+	baseUrl: string;
+	model: string;
+	requireInferenceResponse?: boolean;
+};
+
+type ModelsEndpointValidation = {
+	kind: "models-endpoint";
+	provider: string;
+	modelsUrl: string;
+};
+
+export type ApiKeyLoginConfig = {
+	/** Display name used in error messages, e.g. "Cerebras", "NanoGPT". */
+	providerLabel: string;
+	/** URL opened in browser for the user to grab their key. */
+	authUrl: string;
+	/** Instructions shown with the onAuth callback. */
+	instructions: string;
+	/** Prompt message shown when asking for the key paste. */
+	promptMessage: string;
+	/** Placeholder string for the prompt (e.g. "sk-...", "csk-..."). */
+	placeholder: string;
+	/** Validation strategy, or `null` to skip validation. */
+	validation: ChatCompletionsValidation | ModelsEndpointValidation | null;
+	validationProgressMessage?: string;
+};
+
+export function createApiKeyLogin(config: ApiKeyLoginConfig): (options: OAuthController) => Promise<string> {
+	return async function login(options: OAuthController): Promise<string> {
+		if (options.signal?.aborted) throw new Error("Login cancelled");
+		if (!options.onPrompt) {
+			throw new Error(`${config.providerLabel} login requires onPrompt callback`);
+		}
+
+		options.onAuth?.({
+			url: config.authUrl,
+			instructions: config.instructions,
+		});
+
+		const apiKey = await options.onPrompt({
+			message: config.promptMessage,
+			placeholder: config.placeholder,
+		});
+
+		if (options.signal?.aborted) {
+			throw new Error("Login cancelled");
+		}
+
+		const trimmed = apiKey.trim();
+		if (!trimmed) {
+			throw new Error("API key is required");
+		}
+		if (/[\x00-\x1f\x7f-\x9f]/u.test(trimmed)) {
+			throw new Error("API key contains unsupported control characters");
+		}
+
+		if (config.validation) {
+			options.onProgress?.(config.validationProgressMessage ?? "Validating API key...");
+			if (config.validation.kind === "chat-completions") {
+				await validateOpenAICompatibleApiKey({
+					provider: config.validation.provider,
+					apiKey: trimmed,
+					baseUrl: config.validation.baseUrl,
+					model: config.validation.model,
+					requireInferenceResponse: config.validation.requireInferenceResponse,
+					signal: options.signal,
+					fetch: options.fetch,
+				});
+			} else {
+				await validateApiKeyAgainstModelsEndpoint({
+					provider: config.validation.provider,
+					apiKey: trimmed,
+					modelsUrl: config.validation.modelsUrl,
+					signal: options.signal,
+					fetch: options.fetch,
+				});
+			}
+			if (options.signal?.aborted) throw new Error("Login cancelled");
+		}
+
+		return trimmed;
+	};
+}

package/src/utils/oauth/api-key-validation.ts

@@ -0,0 +1,344 @@
+import { sanitizeDisplayLine } from "@vib-rato/utils";
+
+type OpenAICompatibleValidationOptions = {
+	provider: string;
+	apiKey: string;
+	baseUrl: string;
+	model: string;
+	signal?: AbortSignal;
+	fetch?: typeof globalThis.fetch;
+	requireInferenceResponse?: boolean;
+	timeoutMs?: number;
+};
+
+type ModelListValidationOptions = {
+	provider: string;
+	apiKey: string;
+	modelsUrl: string;
+	signal?: AbortSignal;
+	fetch?: typeof globalThis.fetch;
+	timeoutMs?: number;
+};
+
+const VALIDATION_TIMEOUT_MS = 15_000;
+
+/** Most characters of an upstream body echoed into a validation error. */
+const VALIDATION_DETAILS_LIMIT = 200;
+const VALIDATION_BODY_LIMIT = 64 * 1024;
+
+function redactSecrets(text: string, apiKey: string): string {
+	let safe = text.replace(/\u001b\[[0-?]*[ -/]*[@-~]/gu, "");
+	if (apiKey) {
+		const escaped = [...apiKey].map(char => char.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&"));
+		const interspersed = new RegExp(escaped.join("[\\s\\x00-\\x1f\\x7f-\\x9f]*"), "gu");
+		safe = safe.replace(interspersed, "[REDACTED]");
+	}
+	safe = sanitizeDisplayLine(safe);
+	safe = safe.replace(/[\x00-\x1f\x7f-\x9f]/gu, " ");
+	if (apiKey) safe = safe.replaceAll(apiKey, "[REDACTED]");
+	// Upstream errors sometimes echo credentials under a field name instead of
+	// returning the exact bearer value. Redact those values before retaining any
+	// bounded diagnostic snippet.
+	safe = safe
+		.replace(/(Bearer\s+)([^\s,}"']+)/giu, "$1[REDACTED]")
+		.replace(
+			/(["']?(?:authorization|proxy-authorization|api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|token|secret|password)["']?\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s,}\]]+)/giu,
+			"$1[REDACTED]",
+		);
+	return safe;
+}
+
+function boundedDetails(text: string, apiKey: string): string {
+	const trimmed = redactSecrets(text, apiKey).trim();
+	return trimmed.length > VALIDATION_DETAILS_LIMIT ? `${trimmed.slice(0, VALIDATION_DETAILS_LIMIT)}…` : trimmed;
+}
+
+type BoundedBody = { text: string; truncated: boolean };
+
+async function readBoundedBody(response: Response, signal: AbortSignal): Promise<BoundedBody> {
+	if (signal.aborted) throw new Error("Login cancelled");
+	const contentLength = Number(response.headers.get("content-length"));
+	if (Number.isFinite(contentLength) && contentLength > VALIDATION_BODY_LIMIT) {
+		await response.body?.cancel().catch(() => {});
+		return { text: "", truncated: true };
+	}
+	if (!response.body) return { text: "", truncated: false };
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let total = 0;
+	let truncated = false;
+	try {
+		while (!truncated && total <= VALIDATION_BODY_LIMIT) {
+			if (signal.aborted) throw new Error("Login cancelled");
+			const { promise, resolve, reject } = Promise.withResolvers<{ done: boolean; value?: Uint8Array }>();
+			const onAbort = () => reject(new Error("Login cancelled"));
+			signal.addEventListener("abort", onAbort, { once: true });
+			reader
+				.read()
+				.then(value => resolve(value), reject)
+				.finally(() => signal.removeEventListener("abort", onAbort));
+			const { done, value } = await promise;
+			if (done) break;
+			if (value) {
+				const remaining = VALIDATION_BODY_LIMIT - total;
+				if (value.byteLength > remaining) truncated = true;
+				chunks.push(value.byteLength > remaining ? value.subarray(0, remaining) : value);
+				total += Math.min(value.byteLength, remaining);
+			}
+		}
+	} finally {
+		await reader.cancel().catch(() => {});
+	}
+	const bytes = new Uint8Array(Math.min(total, VALIDATION_BODY_LIMIT));
+	let offset = 0;
+	for (const chunk of chunks) {
+		const take = Math.min(chunk.byteLength, bytes.length - offset);
+		if (take <= 0) break;
+		bytes.set(chunk.subarray(0, take), offset);
+		offset += take;
+	}
+	return { text: new TextDecoder().decode(bytes), truncated };
+}
+
+function abortFailure(
+	provider: string,
+	apiKey: string,
+	callerSignal: AbortSignal | undefined,
+	timeoutSignal: AbortSignal,
+): Error | undefined {
+	if (callerSignal?.aborted) return new Error("Login cancelled");
+	if (timeoutSignal.aborted) return validationFailure(provider, apiKey, "validation request timed out");
+}
+
+function errorDetails(error: unknown, apiKey: string): string {
+	return boundedDetails(error instanceof Error ? error.message : String(error), apiKey);
+}
+
+function validationFailure(provider: string, apiKey: string, suffix: string): Error {
+	const details = boundedDetails(suffix, apiKey);
+	return new Error(
+		details ? `${provider} API key validation failed: ${details}` : `${provider} API key validation failed`,
+	);
+}
+
+/**
+ * Validate an API key against an OpenAI-compatible chat completions endpoint.
+ *
+ * Performs a minimal request to verify credentials and endpoint access.
+ */
+export async function validateOpenAICompatibleApiKey(options: OpenAICompatibleValidationOptions): Promise<void> {
+	const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? VALIDATION_TIMEOUT_MS);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	if (signal.aborted) throw new Error("Login cancelled");
+	if (/[\x00-\x1f\x7f-\x9f]/u.test(options.apiKey))
+		throw new Error(`${options.provider} API key contains unsupported control characters`);
+
+	let response: Response;
+	try {
+		response = await fetchImpl(`${options.baseUrl}/chat/completions`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${options.apiKey}`,
+			},
+			body: JSON.stringify({
+				model: options.model,
+				messages: [{ role: "user", content: "ping" }],
+				max_tokens: 1,
+				temperature: 0,
+			}),
+			signal,
+		});
+	} catch (error) {
+		const abortError = abortFailure(options.provider, options.apiKey, options.signal, timeoutSignal);
+		if (abortError) throw abortError;
+		throw validationFailure(
+			options.provider,
+			options.apiKey,
+			`request failed (${errorDetails(error, options.apiKey)})`,
+		);
+	}
+
+	if (response.ok) {
+		if (options.requireInferenceResponse) {
+			let body: string;
+			try {
+				const bounded = await readBoundedBody(response, signal);
+				if (bounded.truncated) throw new Error("inference probe response exceeded validation limit");
+				body = bounded.text;
+			} catch (error) {
+				const abortError = abortFailure(options.provider, options.apiKey, options.signal, timeoutSignal);
+				if (abortError) throw abortError;
+				if (error instanceof Error && error.message === "Login cancelled") throw error;
+				if (error instanceof Error && error.message === "inference probe response exceeded validation limit")
+					throw validationFailure(options.provider, options.apiKey, error.message);
+				throw validationFailure(
+					options.provider,
+					options.apiKey,
+					`the inference probe response could not be read (${errorDetails(error, options.apiKey)})`,
+				);
+			}
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(body);
+			} catch {
+				throw validationFailure(
+					options.provider,
+					options.apiKey,
+					`the inference probe returned a non-JSON response (${boundedDetails(body, options.apiKey)})`,
+				);
+			}
+			const choices =
+				typeof parsed === "object" && parsed !== null && "choices" in parsed
+					? (parsed as { choices?: unknown }).choices
+					: undefined;
+			const firstChoice = Array.isArray(choices) ? choices[0] : undefined;
+			const message =
+				typeof firstChoice === "object" &&
+				firstChoice !== null &&
+				"message" in firstChoice &&
+				typeof (firstChoice as { message?: unknown }).message === "object" &&
+				!Array.isArray((firstChoice as { message?: unknown }).message)
+					? (firstChoice as { message: Record<string, unknown> }).message
+					: undefined;
+			const content = message?.content;
+			if (!(typeof content === "string" && content.trim().length > 0)) {
+				throw validationFailure(options.provider, options.apiKey, "the inference probe returned no choices");
+			}
+		}
+		return;
+	}
+
+	let details = "";
+	try {
+		const bounded = await readBoundedBody(response, signal);
+		details = bounded.truncated
+			? "response body exceeded validation limit"
+			: boundedDetails(bounded.text, options.apiKey);
+	} catch {
+		const abortError = abortFailure(options.provider, options.apiKey, options.signal, timeoutSignal);
+		if (abortError) throw abortError;
+		// ignore body parse errors, status is enough
+	}
+
+	const message = details
+		? `${options.provider} API key validation failed (${response.status}): ${details}`
+		: `${options.provider} API key validation failed (${response.status})`;
+	throw new Error(message);
+}
+/**
+ * Whether a 200 body is a recognizable model list. OpenAI-compatible endpoints
+ * return `{"object":"list","data":[...]}`; some gateways answer with a bare
+ * array or `{"models":[...]}`. Anything else — including valid JSON without a
+ * list — is not evidence that the credential reached a models endpoint.
+ */
+function isModelList(parsed: unknown): boolean {
+	const isModelArray = (value: unknown): boolean => {
+		if (!Array.isArray(value)) return false;
+		if (value.length === 0) return true;
+		return value.some(
+			item =>
+				typeof item === "object" &&
+				item !== null &&
+				typeof (item as { id?: unknown }).id === "string" &&
+				(item as { id: string }).id.trim().length > 0,
+		);
+	};
+	if (Array.isArray(parsed)) return isModelArray(parsed);
+	if (typeof parsed !== "object" || parsed === null) return false;
+	const record = parsed as { data?: unknown; models?: unknown };
+	return isModelArray(record.data) || isModelArray(record.models);
+}
+
+/**
+ * Validate a provider models endpoint's reachability and response shape.
+ *
+ * Useful for providers where access to specific models may vary by plan and
+ * should not block login; an available model list is not proof that an
+ * authenticated inference request will succeed for the supplied key.
+ *
+ * A 200 status alone is NOT accepted: a captive portal, misrouting proxy, or
+ * broken gateway can answer 200 with an HTML page or an empty JSON object.
+ * The body must parse as JSON and carry a recognizable model list before the
+ * endpoint is considered reachable. This catalog check is not proof that
+ * authenticated inference is entitled to use the supplied key.
+ */
+export async function validateApiKeyAgainstModelsEndpoint(options: ModelListValidationOptions): Promise<void> {
+	const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? VALIDATION_TIMEOUT_MS);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	if (signal.aborted) throw new Error("Login cancelled");
+	if (/[\x00-\x1f\x7f-\x9f]/u.test(options.apiKey))
+		throw new Error(`${options.provider} API key contains unsupported control characters`);
+
+	let response: Response;
+	try {
+		response = await fetchImpl(options.modelsUrl, {
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${options.apiKey}`,
+			},
+			signal,
+		});
+	} catch (error) {
+		const abortError = abortFailure(options.provider, options.apiKey, options.signal, timeoutSignal);
+		if (abortError) throw abortError;
+		throw validationFailure(
+			options.provider,
+			options.apiKey,
+			`request failed (${errorDetails(error, options.apiKey)})`,
+		);
+	}
+
+	if (response.ok) {
+		let body: string;
+		try {
+			const bounded = await readBoundedBody(response, signal);
+			if (bounded.truncated) throw new Error("response body exceeded validation limit");
+			body = bounded.text;
+		} catch (error) {
+			const abortError = abortFailure(options.provider, options.apiKey, options.signal, timeoutSignal);
+			if (abortError) throw abortError;
+			if (error instanceof Error && error.message === "Login cancelled") throw error;
+			throw validationFailure(
+				options.provider,
+				options.apiKey,
+				`the models endpoint response body could not be read (${errorDetails(error, options.apiKey)})`,
+			);
+		}
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(body);
+		} catch {
+			throw new Error(
+				`${options.provider} API key validation failed: the models endpoint returned ${response.status} with a non-JSON body` +
+					`${body.trim() ? ` (${boundedDetails(body, options.apiKey)})` : ""}. Refusing to accept the key on status alone.`,
+			);
+		}
+		if (!isModelList(parsed)) {
+			throw new Error(
+				`${options.provider} API key validation failed: the models endpoint returned ${response.status} without a recognizable ` +
+					`model list. Refusing to accept the key on status alone.`,
+			);
+		}
+		return;
+	}
+
+	let details = "";
+	try {
+		const bounded = await readBoundedBody(response, signal);
+		details = bounded.truncated
+			? "response body exceeded validation limit"
+			: boundedDetails(bounded.text, options.apiKey);
+	} catch {
+		const abortError = abortFailure(options.provider, options.apiKey, options.signal, timeoutSignal);
+		if (abortError) throw abortError;
+		// ignore body parse errors, status is enough
+	}
+
+	const message = details
+		? `${options.provider} API key validation failed (${response.status}): ${details}`
+		: `${options.provider} API key validation failed (${response.status})`;
+	throw new Error(message);
+}

package/src/utils/oauth/bizrouter.ts

@@ -0,0 +1,15 @@
+/** BizRouter login flow (API key paste, validated via /v1/models). */
+import { createApiKeyLogin } from "./api-key-login";
+
+export const loginBizRouter = createApiKeyLogin({
+	providerLabel: "BizRouter",
+	authUrl: "https://bizrouter.ai/settings/keys",
+	instructions: "Create or copy your BizRouter API key",
+	promptMessage: "Paste your BizRouter API key",
+	placeholder: "sk-br-v1-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "BizRouter",
+		modelsUrl: "https://api.bizrouter.ai/v1/models",
+	},
+});