@gajae-code/ai 0.14.0 → 0.14.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.14.1] - 2026-08-18
+- Anthropic clients now set an SDK request `timeout` derived from the first-event window (`resolveAnthropicSdkRequestTimeoutMs`; 300s by default for Anthropic, floored at the env/default first-event window, disabled by an explicit `streamFirstEventTimeoutMs: 0`). The Anthropic first-event watchdog deliberately arms only after response headers arrive, so a connection that silently died before headers — the exact failure mode of recent Anthropic stream instability right after a completed tool call — was previously bounded only by the SDK's 10-minute default per attempt multiplied by its internal retry budget, observable as an endless "Working…" spinner for up to an hour with no error, no retry indicator, and no automatic recovery. This mirrors the existing `resolveOpenAISdkRequestTimeoutMs` stalled-before-headers bound on the OpenAI family.
+- oMLX OpenAI-compatible completions now send `chat_template_kwargs.reasoning_effort` with `enable_thinking` when `thinkingFormat` is `qwen-chat-template`. Discovered oMLX models are treated as reasoning models with `low`/`medium`/`high` effort so local Qwen presets can differentiate roles without swapping weights.
+- Fixed a resume-breaking HTTP 400 on `google-gemini-cli`/`google-antigravity` replay: assistant thinking blocks whose `thinkingSignature` is missing, empty (persistence clears oversized signatures to `""`), or invalid no longer emit an unsigned `{"thought": true}` part. Cloud Code Assist maps such parts to Anthropic `thinking` blocks and rejects the whole request with `messages.N.content.0.thinking.signature: Field required`, permanently bricking resumed sessions (#4630). Unsigned thinking now degrades to plain text — the same treatment cross-model reasoning already gets — while validly signed thinking still replays natively as a thought part with its `thoughtSignature`.
+- `validateApiKeyAgainstModelsEndpoint` no longer accepts an API key on HTTP status alone. A 200 whose body is not JSON or carries no recognizable model list (OpenAI-compatible `data` array, gateway `models` array, or a bare array) now fails closed with an actionable error — previously a captive portal or broken gateway answering 200 with an HTML page silently validated and stored the key. Affects every provider using `kind: "models-endpoint"` (Synthetic, DeepSeek, DeepInfra, Fireworks, BizRouter, NanoGPT, OpenGateway, ZenMux, Fugu). Upstream bodies echoed into validation errors are now bounded to 200 characters on both validators.
+
 ## [0.14.0] - 2026-08-17
 - Cursor native tool calls (shell/read/write/… oneof variants) now convert their protobuf payloads into plain JSON-safe data before attaching them as toolCall `arguments`: `$typeName` markers are stripped, safe-range bigints become numbers (decimal strings beyond `Number.MAX_SAFE_INTEGER`), byte arrays become base64 strings, and cycles/functions collapse to null. Raw protobuf-es payloads carry `bigint` fields (`fileSize`, `durationMs`, `fileOutputThresholdBytes`, …) that defeat `JSON.stringify`, which broke managed snapshot staging, JSONL transcript persistence, and provider replay — the issue #4578 local-snapshot producer defect class fixed at its producer boundary.
 - Generic OpenAI-compatible `/v1/models` discovery now reads served context-window and output-limit metadata instead of defaulting every dynamically listed model to the unknown-window sentinel. `max_model_len` (vLLM/SGLang/oMLX), `context_length`, `context_window`, `max_context_length` (LM Studio), and `max_position_embeddings` populate `contextWindow` in that precedence order, while `max_tokens`/`max_output_tokens` populate `maxTokens`; total-window fields never leak into the output-token ceiling. Malformed values (non-finite, zero, negative, non-numeric) are rejected per-field with fallback to the next candidate, so a `1e400`-style catalog entry can no longer poison compaction thresholds or compact-input budgets.
@@ -40,6 +46,7 @@
 
 ### Fixed
 
+- Cursor OAuth `GetUsableModels` discovery now reads the live million-token window from model display names and aliases (`Claude Opus 5 1M Thinking`) instead of keeping the bundled 200k default. `GetUsableModels` still has no numeric `context_window` field, so the named window is the authoritative live signal; larger bundled fallbacks such as Gemini's 1048576-token window are preserved.
 - Grok Build `/usage` now uses the weekly credits quota when the monthly billing endpoint reports a zero limit, avoiding misleading `100% free` and `used/0` output.
 - A deterministic Anthropic thinking-replay rejection now converges under a managed fallback attempt instead of repeating forever (#4262). Every coding-agent turn prompts with `fallbackManaged: true`, and the whole in-provider thinking-replay repair sits behind `!options?.fallbackManaged` because the fallback controller owns retries — the shipping CLI therefore never repaired anything: each turn rebuilt the same replay from the same history, drew the same 400, and the session burned one rejected request per turn without ever self-healing (reported as ~1 rejected 1.3 MB request every 12s, ~300/h, never converging). The provider still does not retry inside a managed attempt — it records the full-history repair escalation on the provider session state instead, so the next managed attempt builds a repaired replay at the cost of zero extra round trips. Only the two deterministic rejections (`blocks ... cannot be modified`, ``Invalid `signature` in `thinking` block``) qualify; the proxy-masked generic `api_error` names no cause and may be a transient blip, so it still never costs the session its native replay.
 - A long-lived process now recovers when the OAuth row it holds in memory is soft-disabled or replaced in the shared store by a peer (`invalid_grant` disable, credential removal, or a re-login that inserts a new row). The refresh lease answers `missing` for a row that is no longer active, which surfaced as `OAuth refresh credential disappeared` — an error the failure classifier reads as transient, so the vanished row was temp-blocked and retried for the life of the process while a valid re-login row sat unused in the store. Resumed sessions therefore failed every request with the misleading `No credentials found for <provider>` until the CLI was restarted, even though `gjc` had just been logged back in (observed as a per-request refresh-failure flood against `anthropic`). `#tryOAuthCredential` now detects that the attempted row is gone from the store, reloads the snapshot, and re-resolves within the existing reload budget, alongside the peer-rotation recovery it already performed.

package/dist/types/providers/anthropic.d.ts

@@ -201,6 +201,8 @@ export type AnthropicClientOptionsArgs = {
     fetch?: FetchImpl;
     requestMaxRetries?: number;
     maxRetryDelayMs?: number;
+    streamFirstEventTimeoutMs?: number;
+    streamIdleTimeoutMs?: number;
 };
 export type AnthropicClientOptionsResult = {
     isOAuthToken: boolean;
@@ -208,6 +210,7 @@ export type AnthropicClientOptionsResult = {
     authToken?: string | null;
     baseURL?: string;
     maxRetries: number;
+    timeout?: number;
     dangerouslyAllowBrowser: boolean;
     defaultHeaders: Record<string, string>;
     logLevel: AnthropicSdkClientOptions["logLevel"];

package/dist/types/utils/discovery/cursor.d.ts

@@ -1,4 +1,6 @@
 import type { Model } from "../../types";
+/** Tokens represented by a Cursor display-name "1M" window. */
+export declare const CURSOR_NAMED_MILLION_CONTEXT_WINDOW = 1000000;
 /**
  * Options for fetching dynamic Cursor models from `GetUsableModels`.
  */
@@ -21,3 +23,27 @@ export interface CursorModelDiscoveryOptions {
  * Returns `[]` only when the endpoint responds successfully with no usable models.
  */
 export declare function fetchCursorUsableModels(options: CursorModelDiscoveryOptions): Promise<Model<"cursor-agent">[] | null>;
+export interface CursorLiveContextWindowInput {
+    id: string;
+    name?: string;
+    displayName?: string;
+    displayNameShort?: string;
+    displayModelId?: string;
+    aliases?: readonly string[];
+    fallback: number;
+}
+/**
+ * Cursor `GetUsableModels` does not send numeric context-window metadata.
+ * The live million-token window is advertised in display names and aliases
+ * (for example "Claude Opus 5 1M Thinking"). Never shrink a larger bundled
+ * fallback such as Gemini's 1048576-token window.
+ */
+export declare function resolveCursorLiveContextWindow(input: CursorLiveContextWindowInput): number;
+/**
+ * Normalize `GetUsableModels` payloads into canonical Cursor model entries.
+ * Tests inject `references` so the overlay can be verified without HTTP/2.
+ */
+export declare function normalizeCursorDiscoveryModels(models: readonly unknown[] | undefined, options?: {
+    baseUrl?: string;
+    references?: ReadonlyMap<string, Model<"cursor-agent">>;
+}): Model<"cursor-agent">[];

package/dist/types/utils/idle-iterator.d.ts

@@ -47,6 +47,22 @@ export declare function getStreamFirstEventTimeoutMs(idleTimeoutMs?: number, fal
  *   slow setup.
  */
 export declare function resolveOpenAISdkRequestTimeoutMs(provider: string, streamFirstEventTimeoutOverride?: number): number | undefined;
+/**
+ * Resolves the Anthropic SDK client `timeout` so stalled-before-headers requests
+ * are bounded. The Anthropic first-event watchdog deliberately arms only once
+ * response headers have arrived (setup latency must not consume the first-event
+ * budget), which left the connect/headers phase governed solely by the SDK
+ * default of 10 minutes per attempt — multiplied by SDK-internal retries, a
+ * connection that silently died right after a completed tool call could spin
+ * with no user-visible error for the better part of an hour.
+ *
+ * - Explicit `0` disables the request timeout, matching a disabled first-event
+ *   watchdog.
+ * - An explicit nonzero override is floored at the env/default first-event
+ *   window (which itself never undershoots the provider idle window) so a short
+ *   post-connect first-event budget cannot kill legitimate slow setup.
+ */
+export declare function resolveAnthropicSdkRequestTimeoutMs(provider: string, streamFirstEventTimeoutOverride?: number, streamIdleTimeoutOverride?: number): number | undefined;
 export type Watchdog = NodeJS.Timeout | undefined;
 export interface FirstEventTimeoutFacts {
     requestBytes?: number;

package/dist/types/utils/oauth/api-key-validation.d.ts

@@ -22,6 +22,12 @@ export declare function validateOpenAICompatibleApiKey(options: OpenAICompatible
  *
  * Useful for providers where access to specific models may vary by plan and
  * should not block key validation.
+ *
+ * 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.
  */
 export declare function validateApiKeyAgainstModelsEndpoint(options: ModelListValidationOptions): Promise<void>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.14.0",
+	"version": "0.14.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -40,8 +40,8 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/natives": "0.14.0",
-		"@gajae-code/utils": "0.14.0",
+		"@gajae-code/natives": "0.14.1",
+		"@gajae-code/utils": "0.14.1",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/model-thinking.ts

@@ -221,6 +221,9 @@ export function applyGeneratedModelPolicies(models: ApiModel<Api>[]): void {
 		if (source.id.split("/").at(-1)?.toLowerCase() === "muse-spark-1.2") {
 			source.reasoning = true;
 		}
+		if (source.provider === "omlx") {
+			source.reasoning = true;
+		}
 		const model = refreshModelThinking(source);
 		applyGeneratedModelPolicy(model);
 		models[index] = model;
@@ -430,6 +433,16 @@ function applyGeneratedModelPolicy(model: ApiModel<Api>): void {
 		};
 		delete model.compat.thinkingFormat;
 	}
+	if (model.provider === "omlx" && model.api === "openai-completions") {
+		model.compat = {
+			...(model.compat ?? {}),
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: true,
+			thinkingFormat: "qwen-chat-template",
+			reasoningContentField: "reasoning_content",
+		};
+	}
 	model.name = scrubGeneratedModelName(model.name);
 	if (
 		model.api === "openai-completions" &&
@@ -621,6 +634,9 @@ function inferDefaultEffort<TApi extends Api>(model: ApiModel<TApi>, parsedModel
 	) {
 		return GPT_5_5_DEFAULT_EFFORT;
 	}
+	if (model.provider === "omlx") {
+		return Effort.Medium;
+	}
 	return undefined;
 }
 
@@ -784,6 +800,9 @@ function inferFallbackEfforts<TApi extends Api>(model: ApiModel<TApi>): readonly
 		return DEFAULT_REASONING_EFFORTS;
 	}
 	if (model.api === "openai-completions") {
+		if (model.provider === "omlx") {
+			return [Effort.Low, Effort.Medium, Effort.High];
+		}
 		const compat = resolveOpenAICompat(model as ApiModel<"openai-completions">);
 		if (compat.thinkingFormat === "openai" && compat.supportsReasoningEffort) {
 			return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;

package/src/provider-models/openai-compat.ts

@@ -1418,6 +1418,24 @@ export function omlxModelManagerOptions(config?: OmlxModelManagerConfig): ModelM
 				provider: "omlx",
 				baseUrl,
 				apiKey,
+				mapModel: (_entry, defaults) => ({
+					...defaults,
+					reasoning: true,
+					thinking: {
+						mode: "effort",
+						minLevel: Effort.Low,
+						maxLevel: Effort.High,
+						defaultLevel: Effort.Medium,
+						levels: [Effort.Low, Effort.Medium, Effort.High],
+					},
+					compat: {
+						supportsStore: false,
+						supportsDeveloperRole: false,
+						supportsReasoningEffort: true,
+						thinkingFormat: "qwen-chat-template",
+						reasoningContentField: "reasoning_content",
+					},
+				}),
 			}),
 	};
 }

package/src/providers/anthropic.ts

@@ -72,6 +72,7 @@ import {
 	getStreamFirstEventTimeoutMs,
 	getStreamIdleTimeoutMs,
 	iterateWithIdleTimeout,
+	resolveAnthropicSdkRequestTimeoutMs,
 } from "../utils/idle-iterator";
 import {
 	findUnnecessaryUnicodeEscape,
@@ -1117,6 +1118,8 @@ export type AnthropicClientOptionsArgs = {
 	fetch?: FetchImpl;
 	requestMaxRetries?: number;
 	maxRetryDelayMs?: number;
+	streamFirstEventTimeoutMs?: number;
+	streamIdleTimeoutMs?: number;
 };
 
 export type AnthropicClientOptionsResult = {
@@ -1125,6 +1128,7 @@ export type AnthropicClientOptionsResult = {
 	authToken?: string | null;
 	baseURL?: string;
 	maxRetries: number;
+	timeout?: number;
 	dangerouslyAllowBrowser: boolean;
 	defaultHeaders: Record<string, string>;
 	logLevel: AnthropicSdkClientOptions["logLevel"];
@@ -1907,6 +1911,8 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					fetch: options?.fetch,
 					requestMaxRetries: options?.requestMaxRetries,
 					maxRetryDelayMs: options?.maxRetryDelayMs,
+					streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
+					streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
 				});
 				client = created.client;
 				isOAuthToken = created.isOAuthToken;
@@ -2996,6 +3002,16 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	const baseFetch = args.fetch ?? fetch;
 	const boundedFetch = wrapAnthropicFetchForBoundedRateLimits(baseFetch, args.maxRetryDelayMs);
 	const debugFetch = onSseEvent ? wrapFetchForSseDebug(boundedFetch, event => onSseEvent(event, model)) : boundedFetch;
+	// Bound the connect/headers phase. The first-event watchdog arms only after
+	// response headers arrive, so a request whose connection dies before headers
+	// was previously governed only by the Anthropic SDK's 10-minute default per
+	// attempt times its internal retry budget — observable as an endless spinner
+	// right after a completed tool call.
+	const sdkTimeoutMs = resolveAnthropicSdkRequestTimeoutMs(
+		model.provider,
+		args.streamFirstEventTimeoutMs,
+		args.streamIdleTimeoutMs,
+	);
 	if (model.provider === "github-copilot") {
 		const copilotApiKey = parseGitHubCopilotApiKey(apiKey).accessToken;
 		const betaFeatures = [...extraBetas];
@@ -3020,6 +3036,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 			authToken: copilotApiKey,
 			baseURL: baseUrl,
 			maxRetries: resolveRetryBudget(args.requestMaxRetries, 5),
+			...(sdkTimeoutMs !== undefined ? { timeout: sdkTimeoutMs } : {}),
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
 			logLevel: ANTHROPIC_SDK_LOG_LEVEL,
@@ -3054,6 +3071,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 			authToken: null,
 			baseURL: baseUrl,
 			maxRetries: resolveRetryBudget(args.requestMaxRetries, 5),
+			...(sdkTimeoutMs !== undefined ? { timeout: sdkTimeoutMs } : {}),
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
 			logLevel: ANTHROPIC_SDK_LOG_LEVEL,
@@ -3072,6 +3090,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 			authToken: null,
 			baseURL: baseUrl,
 			maxRetries: resolveRetryBudget(args.requestMaxRetries, 5),
+			...(sdkTimeoutMs !== undefined ? { timeout: sdkTimeoutMs } : {}),
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
 			logLevel: ANTHROPIC_SDK_LOG_LEVEL,
@@ -3086,6 +3105,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		authToken: oauthToken ? apiKey : undefined,
 		baseURL: baseUrl,
 		maxRetries: resolveRetryBudget(args.requestMaxRetries, 5),
+		...(sdkTimeoutMs !== undefined ? { timeout: sdkTimeoutMs } : {}),
 		dangerouslyAllowBrowser: true,
 		defaultHeaders,
 		logLevel: ANTHROPIC_SDK_LOG_LEVEL,

package/src/providers/google-shared.ts

@@ -257,11 +257,23 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 					// Otherwise convert to plain text (no tags to avoid model mimicking them)
 					if (isSameProviderAndModel) {
 						const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
-						parts.push({
-							thought: true,
-							text: block.thinking.toWellFormed(),
-							...(thoughtSignature && { thoughtSignature }),
-						});
+						// An unsigned `thought: true` part cannot be replayed: Cloud Code Assist
+						// maps it to an Anthropic `thinking` block and rejects the whole request
+						// with `thinking.signature: Field required` (#4630). Persisted signatures
+						// can be missing entirely or cleared to "" (oversized-signature
+						// persistence), so degrade those blocks to the same plain-text treatment
+						// cross-model reasoning already gets. Signed thinking still replays natively.
+						if (!thoughtSignature) {
+							parts.push({
+								text: block.thinking.toWellFormed(),
+							});
+						} else {
+							parts.push({
+								thought: true,
+								text: block.thinking.toWellFormed(),
+								thoughtSignature,
+							});
+						}
 					} else {
 						parts.push({
 							text: block.thinking.toWellFormed(),

package/src/providers/openai-completions.ts

@@ -1398,8 +1398,12 @@ function buildParams(
 		// Qwen uses top-level enable_thinking: boolean
 		params.enable_thinking = !!options?.reasoning && !options?.disableReasoning;
 	} else if (supportsReasoningParams && compat.thinkingFormat === "qwen-chat-template" && model.reasoning) {
+		const enableThinking = !!options?.reasoning && !options?.disableReasoning;
 		params.chat_template_kwargs = {
-			enable_thinking: !!options?.reasoning && !options?.disableReasoning,
+			enable_thinking: enableThinking,
+			...(enableThinking && options?.reasoning
+				? { reasoning_effort: mapReasoningEffort(options.reasoning, compat.reasoningEffortMap) }
+				: {}),
 		};
 	} else if (supportsReasoningParams && compat.thinkingFormat === "openrouter" && model.reasoning) {
 		// OpenRouter normalizes reasoning across providers via a nested reasoning object.

package/src/utils/discovery/cursor.ts

@@ -11,6 +11,9 @@ const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
 
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const DEFAULT_MAX_TOKENS = 64_000;
+/** Tokens represented by a Cursor display-name "1M" window. */
+export const CURSOR_NAMED_MILLION_CONTEXT_WINDOW = 1_000_000;
+const CURSOR_NAMED_MILLION_WINDOW_RE = /\b(\d+(?:\.\d+)?)M\b/i;
 
 const OptionalDisplayNameSchema = z.string().optional().catch(undefined);
 const CursorAliasesSchema = z
@@ -78,8 +81,9 @@ export async function fetchCursorUsableModels(
 			return null;
 		}
 
-		const references = createCursorReferenceMap();
-		return normalizeCursorModels(parsedDecoded.data.models, options.baseUrl, references);
+		return normalizeCursorDiscoveryModels(parsedDecoded.data.models, {
+			baseUrl: options.baseUrl,
+		});
 	} catch {
 		return null;
 	}
@@ -227,6 +231,74 @@ function decodeConnectUnaryBody(payload: Uint8Array): Uint8Array | null {
 	return null;
 }
 
+export interface CursorLiveContextWindowInput {
+	id: string;
+	name?: string;
+	displayName?: string;
+	displayNameShort?: string;
+	displayModelId?: string;
+	aliases?: readonly string[];
+	fallback: number;
+}
+
+/**
+ * Cursor `GetUsableModels` does not send numeric context-window metadata.
+ * The live million-token window is advertised in display names and aliases
+ * (for example "Claude Opus 5 1M Thinking"). Never shrink a larger bundled
+ * fallback such as Gemini's 1048576-token window.
+ */
+export function resolveCursorLiveContextWindow(input: CursorLiveContextWindowInput): number {
+	const fallback = Number.isFinite(input.fallback) && input.fallback > 0 ? input.fallback : DEFAULT_CONTEXT_WINDOW;
+	const named = parseCursorNamedMillionWindow([
+		input.displayName,
+		input.displayNameShort,
+		input.name,
+		input.displayModelId,
+		input.id,
+		...(input.aliases ?? []),
+	]);
+	if (named === undefined) {
+		return fallback;
+	}
+	return Math.max(named, fallback);
+}
+
+function parseCursorNamedMillionWindow(texts: Array<string | undefined>): number | undefined {
+	for (const text of texts) {
+		if (typeof text !== "string" || text.length === 0) {
+			continue;
+		}
+		const match = CURSOR_NAMED_MILLION_WINDOW_RE.exec(text);
+		if (!match) {
+			continue;
+		}
+		const millions = Number(match[1]);
+		if (!Number.isFinite(millions) || millions <= 0) {
+			continue;
+		}
+		const tokens = Math.round(millions * CURSOR_NAMED_MILLION_CONTEXT_WINDOW);
+		if (Number.isFinite(tokens) && tokens > 0) {
+			return tokens;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Normalize `GetUsableModels` payloads into canonical Cursor model entries.
+ * Tests inject `references` so the overlay can be verified without HTTP/2.
+ */
+export function normalizeCursorDiscoveryModels(
+	models: readonly unknown[] | undefined,
+	options: {
+		baseUrl?: string;
+		references?: ReadonlyMap<string, Model<"cursor-agent">>;
+	} = {},
+): Model<"cursor-agent">[] {
+	const references = options.references ? new Map(options.references) : createCursorReferenceMap();
+	return normalizeCursorModels(models, options.baseUrl, references);
+}
+
 function normalizeCursorModels(
 	models: readonly unknown[] | undefined,
 	baseUrlOverride: string | undefined,
@@ -267,6 +339,15 @@ function normalizeCursorModel(
 	const name = pickModelDisplayName(details, id);
 	const reference = references.get(id);
 	const reasoning = Boolean(details.thinkingDetails) || reference?.reasoning === true;
+	const contextWindow = resolveCursorLiveContextWindow({
+		id,
+		name,
+		displayName: details.displayName,
+		displayNameShort: details.displayNameShort,
+		displayModelId: details.displayModelId,
+		aliases: details.aliases,
+		fallback: reference?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+	});
 
 	if (reference) {
 		return {
@@ -275,6 +356,7 @@ function normalizeCursorModel(
 			name,
 			baseUrl: baseUrlOverride ?? reference.baseUrl,
 			reasoning,
+			contextWindow,
 		};
 	}
 	return {
@@ -286,7 +368,7 @@ function normalizeCursorModel(
 		reasoning,
 		input: ["text"],
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		contextWindow,
 		maxTokens: DEFAULT_MAX_TOKENS,
 	};
 }

package/src/utils/idle-iterator.ts

@@ -105,6 +105,39 @@ export function resolveOpenAISdkRequestTimeoutMs(
 	return envSdkTimeoutMs;
 }
 
+/**
+ * Resolves the Anthropic SDK client `timeout` so stalled-before-headers requests
+ * are bounded. The Anthropic first-event watchdog deliberately arms only once
+ * response headers have arrived (setup latency must not consume the first-event
+ * budget), which left the connect/headers phase governed solely by the SDK
+ * default of 10 minutes per attempt — multiplied by SDK-internal retries, a
+ * connection that silently died right after a completed tool call could spin
+ * with no user-visible error for the better part of an hour.
+ *
+ * - Explicit `0` disables the request timeout, matching a disabled first-event
+ *   watchdog.
+ * - An explicit nonzero override is floored at the env/default first-event
+ *   window (which itself never undershoots the provider idle window) so a short
+ *   post-connect first-event budget cannot kill legitimate slow setup.
+ */
+export function resolveAnthropicSdkRequestTimeoutMs(
+	provider: string,
+	streamFirstEventTimeoutOverride?: number,
+	streamIdleTimeoutOverride?: number,
+): number | undefined {
+	const idleTimeoutMs =
+		streamIdleTimeoutOverride ?? getStreamIdleTimeoutMs(getProviderStreamIdleTimeoutFallbackMs(provider));
+	const envSdkTimeoutMs = getStreamFirstEventTimeoutMs(
+		idleTimeoutMs,
+		getProviderFirstEventTimeoutFallbackMs(provider),
+	);
+	if (streamFirstEventTimeoutOverride === 0) return undefined;
+	if (streamFirstEventTimeoutOverride !== undefined) {
+		return Math.max(envSdkTimeoutMs ?? 0, streamFirstEventTimeoutOverride);
+	}
+	return envSdkTimeoutMs;
+}
+
 export type Watchdog = NodeJS.Timeout | undefined;
 export interface FirstEventTimeoutFacts {
 	requestBytes?: number;

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

@@ -15,6 +15,14 @@ type ModelListValidationOptions = {
 
 const VALIDATION_TIMEOUT_MS = 15_000;
 
+/** Most characters of an upstream body echoed into a validation error. */
+const VALIDATION_DETAILS_LIMIT = 200;
+
+function boundedDetails(text: string): string {
+	const trimmed = text.trim();
+	return trimmed.length > VALIDATION_DETAILS_LIMIT ? `${trimmed.slice(0, VALIDATION_DETAILS_LIMIT)}…` : trimmed;
+}
+
 /**
  * Validate an API key against an OpenAI-compatible chat completions endpoint.
  *
@@ -45,7 +53,7 @@ export async function validateOpenAICompatibleApiKey(options: OpenAICompatibleVa
 
 	let details = "";
 	try {
-		details = (await response.text()).trim();
+		details = boundedDetails(await response.text());
 	} catch {
 		// ignore body parse errors, status is enough
 	}
@@ -55,12 +63,30 @@ export async function validateOpenAICompatibleApiKey(options: OpenAICompatibleVa
 		: `${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 {
+	if (Array.isArray(parsed)) return true;
+	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);
+}
 
 /**
  * Validate an API key against a provider models endpoint.
  *
  * Useful for providers where access to specific models may vary by plan and
  * should not block key validation.
+ *
+ * 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.
  */
 export async function validateApiKeyAgainstModelsEndpoint(options: ModelListValidationOptions): Promise<void> {
 	const timeoutSignal = AbortSignal.timeout(VALIDATION_TIMEOUT_MS);
@@ -75,12 +101,37 @@ export async function validateApiKeyAgainstModelsEndpoint(options: ModelListVali
 	});
 
 	if (response.ok) {
+		let body: string;
+		try {
+			body = await response.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)
+				})`,
+			);
+		}
+		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)})` : ""}. 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 {
-		details = (await response.text()).trim();
+		details = boundedDetails(await response.text());
 	} catch {
 		// ignore body parse errors, status is enough
 	}