@gajae-code/ai 0.15.4 → 0.15.6

package/src/types.ts

@@ -167,6 +167,7 @@ export const KNOWN_PROVIDERS = [
 	"mistral",
 	"minimax",
 	"opencode-go",
+	"commandcode-goat",
 	"opencode-zen",
 	"opengateway",
 	"bizrouter",
@@ -353,6 +354,19 @@ export type FetchImpl = ((input: string | URL | Request, init?: RequestInit) =>
 	preconnect?: typeof globalThis.fetch.preconnect;
 };
 
+/**
+ * Credential returned by an auth retry resolver.
+ *
+ * The optional admission callback lets an authority-bearing caller retain a
+ * credential lease until the replacement provider request is actually
+ * admitted. Ordinary callers can continue returning a string from
+ * {@link StreamOptions.onAuthError}.
+ */
+export interface AuthRetryCredential {
+	apiKey: string;
+	onStreamCreated?: () => void;
+}
+
 export interface StreamOptions {
 	temperature?: number;
 	topP?: number;
@@ -384,7 +398,11 @@ export interface StreamOptions {
 	 * event has been emitted. Returning a different key retries the provider
 	 * request once.
 	 */
-	onAuthError?: (provider: string, apiKey: string, error: unknown) => Promise<string | undefined>;
+	onAuthError?: (
+		provider: string,
+		apiKey: string,
+		error: unknown,
+	) => Promise<string | AuthRetryCredential | undefined>;
 	cacheRetention?: CacheRetention;
 	/**
 	 * Additional headers to include in provider requests.
@@ -449,6 +467,14 @@ export interface StreamOptions {
 		model?: Model<Api>,
 		scope?: AttemptScopeRef,
 	) => void | Promise<void>;
+	/**
+	 * Internal dispatch-admission hook. Providers invoke this immediately before
+	 * submitting an outbound request; stream forwarding retains a first-response
+	 * fallback for custom providers that do not expose a transport seam.
+	 */
+	onStreamCreated?: () => void;
+	/** Internal authority policy: disable provider-owned retries and corrective replays. */
+	disableProviderRetries?: boolean;
 	/**
 	 * Optional callback for raw Server-Sent Events as they arrive from HTTP streaming providers.
 	 *
@@ -620,31 +646,22 @@ export interface ToolCall {
 	 */
 	incompleteArgumentsReason?: "truncated" | "malformed" | "conflicting" | "ambiguous";
 	/**
-	 * Set when the raw argument JSON spelled a printable character as a `\uXXXX`
-	 * escape instead of a literal character. This includes ASCII landings because
-	 * a one-nibble mutation can move an intended non-ASCII scalar below U+0080.
-	 * Such a payload parses cleanly but
-	 * is unverifiable: one mistyped hex digit decodes to a different, equally
-	 * valid character, so the text can be silently wrong with no in-band evidence.
-	 * The agent loop resamples the turn a bounded number of times and then
-	 * rejects the call instead of executing it. The single bounded exception
-	 * is a tool that enumerated its display-only fields
-	 * (`displaySafeEscapedArgFields`): when every escaped scalar corroborates
-	 * a decoded non-ASCII character inside those fields, the call executes
-	 * with a warning instead — rendered question text, never executable
-	 * content, ids, or durable metadata.
-	 * Escapes that are required (control characters) or unavoidable (lone
-	 * surrogates) never set this.
+	 * Set by current producers when raw argument JSON carries unsafe Unicode
+	 * data, such as malformed escape evidence or a decoded unpaired surrogate.
+	 * Valid JSON `\uXXXX` escapes are canonical spellings of the decoded string
+	 * and current producers do not set this flag for them.
+	 *
+	 * Legacy producers may still set the flag for any escaped non-ASCII spelling.
+	 * The agent loop keeps its bounded legacy resample/display-safe behavior for
+	 * those calls while consuming the transient evidence below.
 	 */
 	escapedNonAsciiArguments?: boolean;
 	/**
-	 * Bounded, payload-free evidence for the original raw escape positions and
-	 * process-keyed scalar/path identities. Required for the display-safe terminal exemption: decoded values
-	 * alone cannot prove that an ASCII landing such as `\u0077` was not a
-	 * one-nibble mutation of a non-ASCII escape. Presence of this evidence implies
-	 * the guarded state even if a legacy producer omitted
-	 * `escapedNonAsciiArguments`. The agent consumes and removes this transient
-	 * field before the tool-call message can become durable.
+	 * Bounded, payload-free evidence for raw Unicode argument data. Current
+	 * producers attach it only for unsafe data; legacy producers may attach
+	 * non-malformed positional evidence used by the display-safe compatibility
+	 * path. The agent consumes and removes this transient field before the
+	 * tool-call message can become durable.
 	 */
 	escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;
 }

package/src/utils/fallback-transport.d.ts

@@ -23,6 +23,13 @@ export interface FallbackTrigger {
 export declare const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export declare const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
+ * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the
+ * code itself is the only structured evidence of the failure and must survive
+ * the existence gate below. It is always compared case-sensitively.
+ */
+export declare const SERVER_OVERLOADED_PROVIDER_CODE = "server_is_overloaded";
 export type TransportHeaders = Headers | Record<string, string | undefined>;
 /**
  * Structured facts from an upstream HTTP or transport failure. Retry decisions

package/src/utils/fallback-transport.ts

@@ -26,6 +26,13 @@ export interface FallbackTrigger {
 export const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
+ * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the
+ * code itself is the only structured evidence of the failure and must survive
+ * the existence gate below. It is always compared case-sensitively.
+ */
+export const SERVER_OVERLOADED_PROVIDER_CODE = "server_is_overloaded";
 
 export type TransportHeaders = Headers | Record<string, string | undefined>;
 
@@ -241,6 +248,11 @@ export function transportFailureFacts(
 		!isContextOverflowCode(normalizedCode) &&
 		normalizedCode !== STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE &&
 		normalizedCode !== EMPTY_RESPONSE_PROVIDER_CODE &&
+		// Matched case-sensitively against the raw code: this is the one gate a
+		// provider-owned code can open on its own, so a cased or padded variant
+		// must not materialize facts that would disqualify an unrelated
+		// bare-default retry.
+		providerCode !== SERVER_OVERLOADED_PROVIDER_CODE &&
 		requestBytes === undefined &&
 		firstEventElapsedMs === undefined &&
 		firstEventTimeoutMs === undefined &&
@@ -360,12 +372,17 @@ export function classifyFallbackTrigger(
 	const retryAfterMs =
 		parseRetryAfterMilliseconds(headers?.get("retry-after-ms") ?? null) ??
 		parseRetryAfterSeconds(headers?.get("retry-after") ?? null);
-	const codes = [facts.openaiErrorCode, facts.anthropicErrorType, facts.providerCode].map(value =>
-		value?.toLowerCase(),
-	);
+	const rawCodes = [facts.openaiErrorCode, facts.anthropicErrorType, facts.providerCode];
+	const codes = rawCodes.map(value => value?.toLowerCase());
 	const code = codes[0] ?? codes[1] ?? codes[2];
+	// The capacity-overload code is provider-owned and is the only code that can
+	// classify without a status, so it is matched case-sensitively — the same
+	// exactness the parser and the session admission use.
+	const rawCode = rawCodes[0] ?? rawCodes[1] ?? rawCodes[2];
 	const triggerClass: FallbackTriggerClass =
-		code === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE || code === EMPTY_RESPONSE_PROVIDER_CODE
+		code === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE ||
+		code === EMPTY_RESPONSE_PROVIDER_CODE ||
+		(facts.status === undefined && rawCode === SERVER_OVERLOADED_PROVIDER_CODE)
 			? "server"
 			: isQuotaCode(code)
 				? "quota"

package/src/utils/json-parse.d.ts

@@ -67,9 +67,11 @@ export declare function collectUnicodeEscapeEvidence(json: string): UnicodeEscap
 /**
  * Return evidence only when decoded tool arguments are unsafe to execute.
  *
- * Valid JSON escapes and literal UTF-8 have the same canonical decoded value.
- * Malformed JSON, duplicate/deep evidence, and unpaired UTF-16 surrogates keep
- * the existing fail-closed path.
+ * Valid JSON escapes and literal UTF-8 have the same canonical decoded value,
+ * including a valid scalar whose hex digits differ from what a caller intended:
+ * runtime syntax validation cannot infer author intent after decoding.
+ * Malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and
+ * unpaired UTF-16 surrogates keep the fail-closed path.
  */
 export declare function collectUnsafeUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined;
 /** Attach unsafe raw evidence while preserving the existing call-level guard flag. */

package/src/utils/json-parse.ts

@@ -486,15 +486,13 @@ export function collectUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidenc
 
 function hasUnpairedUnicodeSurrogate(value: unknown): boolean {
 	const pending: unknown[] = [value];
-	const seen = new WeakSet<object>();
 	while (pending.length > 0) {
 		const current = pending.pop();
 		if (typeof current === "string") {
 			if (!current.isWellFormed()) return true;
 			continue;
 		}
-		if (typeof current !== "object" || current === null || seen.has(current)) continue;
-		seen.add(current);
+		if (typeof current !== "object" || current === null) continue;
 		if (Array.isArray(current)) {
 			for (const child of current) pending.push(child);
 			continue;
@@ -510,9 +508,11 @@ function hasUnpairedUnicodeSurrogate(value: unknown): boolean {
 /**
  * Return evidence only when decoded tool arguments are unsafe to execute.
  *
- * Valid JSON escapes and literal UTF-8 have the same canonical decoded value.
- * Malformed JSON, duplicate/deep evidence, and unpaired UTF-16 surrogates keep
- * the existing fail-closed path.
+ * Valid JSON escapes and literal UTF-8 have the same canonical decoded value,
+ * including a valid scalar whose hex digits differ from what a caller intended:
+ * runtime syntax validation cannot infer author intent after decoding.
+ * Malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and
+ * unpaired UTF-16 surrogates keep the fail-closed path.
  */
 export function collectUnsafeUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined {
 	const hasUnicodeEscape = json.includes("\\u");

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

@@ -1,7 +1,8 @@
 /**
  * Shared factory for API-key-paste "login" flows.
  *
- * Several providers (Cerebras, Synthetic, Moonshot, Together, NanoGPT, ZenMux)
+ * 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.
  */
@@ -14,6 +15,7 @@ type ChatCompletionsValidation = {
 	provider: string;
 	baseUrl: string;
 	model: string;
+	requireInferenceResponse?: boolean;
 };
 
 type ModelsEndpointValidation = {
@@ -35,10 +37,12 @@ export type ApiKeyLoginConfig = {
 	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`);
 		}
@@ -61,16 +65,21 @@ export function createApiKeyLogin(config: ApiKeyLoginConfig): (options: OAuthCon
 		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?.("Validating API key...");
+			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({
@@ -78,8 +87,10 @@ export function createApiKeyLogin(config: ApiKeyLoginConfig): (options: OAuthCon
 					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

@@ -1,9 +1,14 @@
+import { sanitizeDisplayLine } from "@gajae-code/utils";
+
 type OpenAICompatibleValidationOptions = {
 	provider: string;
 	apiKey: string;
 	baseUrl: string;
 	model: string;
 	signal?: AbortSignal;
+	fetch?: typeof globalThis.fetch;
+	requireInferenceResponse?: boolean;
+	timeoutMs?: number;
 };
 
 type ModelListValidationOptions = {
@@ -11,50 +16,209 @@ type ModelListValidationOptions = {
 	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): string {
-	const trimmed = text.trim();
+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(VALIDATION_TIMEOUT_MS);
+	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`);
 
-	const response = await fetch(`${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,
-	});
+	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 {
-		details = boundedDetails(await response.text());
+		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
 	}
 
@@ -70,45 +234,77 @@ export async function validateOpenAICompatibleApiKey(options: OpenAICompatibleVa
  * list — is not evidence that the credential reached a models endpoint.
  */
 function isModelList(parsed: unknown): boolean {
-	if (Array.isArray(parsed)) return true;
+	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 Array.isArray(record.data) || Array.isArray(record.models);
+	return isModelArray(record.data) || isModelArray(record.models);
 }
 
 /**
- * Validate an API key against a provider models endpoint.
+ * 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 key validation.
+ * 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, and
- * accepting the key on status alone would store a credential that was never
- * actually checked. The body must parse as JSON and carry a recognizable model
- * list before the key is considered validated.
+ * 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(VALIDATION_TIMEOUT_MS);
+	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`);
 
-	const response = await fetch(options.modelsUrl, {
-		method: "GET",
-		headers: {
-			Authorization: `Bearer ${options.apiKey}`,
-		},
-		signal,
-	});
+	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 {
-			body = await response.text();
+			const bounded = await readBoundedBody(response, signal);
+			if (bounded.truncated) throw new Error("response body exceeded validation limit");
+			body = bounded.text;
 		} catch (error) {
-			throw new Error(
-				`${options.provider} API key validation failed: the models endpoint response body could not be read (${
-					error instanceof Error ? error.message : String(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;
@@ -117,7 +313,7 @@ export async function validateApiKeyAgainstModelsEndpoint(options: ModelListVali
 		} 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)})` : ""}. Refusing to accept the key on status alone.`,
+					`${body.trim() ? ` (${boundedDetails(body, options.apiKey)})` : ""}. Refusing to accept the key on status alone.`,
 			);
 		}
 		if (!isModelList(parsed)) {
@@ -131,8 +327,13 @@ export async function validateApiKeyAgainstModelsEndpoint(options: ModelListVali
 
 	let details = "";
 	try {
-		details = boundedDetails(await response.text());
+		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
 	}
 

package/src/utils/oauth/commandcode.ts

@@ -0,0 +1,17 @@
+import { createApiKeyLogin } from "./api-key-login";
+
+export const loginCommandCode = createApiKeyLogin({
+	providerLabel: "Command Code GOAT",
+	authUrl: "https://commandcode.ai/studio/#api-keys",
+	instructions: "Create or copy your Command Code API key",
+	promptMessage: "Paste your Command Code API key",
+	placeholder: "cmd-...",
+	validationProgressMessage: "Verifying Command Code inference entitlement...",
+	validation: {
+		kind: "chat-completions",
+		provider: "Command Code GOAT",
+		baseUrl: "https://api.commandcode.ai/provider/v1",
+		model: "zai-org/GLM-5.3",
+		requireInferenceResponse: true,
+	},
+});