@gajae-code/ai 0.18.0 → 0.18.1

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [0.18.1] - 2026-09-29
+
+### Changed
+
+- Bump the bundled Claude Code fingerprint floor from 2.1.281 to 2.1.284.
+- Anthropic OAuth requests now sign `claude-cli/<version>` and the billing `cc_version` with the latest published Claude Code release instead of a build-time constant. The version is resolved in the background from Anthropic's `latest` release channel and the npm dist-tag (higher wins), refreshed at most every 6 hours, cached in `~/.gjc/cache/claude-code-version.json`, and never blocks a request or drops below the bundled floor. Set `GJC_CLAUDE_CODE_VERSION=X.Y.Z` to pin it. A stale fingerprint is answered with HTTP 400 `claude_code_version_too_old` on newer models, so this no longer waits for a gjc release to recover.
+
+### Fixed
+
+- OpenGateway models discovered from `/v1/models` now take their capabilities from the bundled catalog entry for the same upstream model, and `-ultrafast` deployments resolve to their upstream model, so `opengateway/deepseek/deepseek-v4.1-flash-ultrafast` and the GLM/Kimi ultrafast models are registered with reasoning support and accept thinking levels (#6070).
+
+- Bound Codex turns that stall after an empty reasoning item and streamed tool-call start to the shared stream idle timeout.
+
+- Apply the shared stream idle timeout to Codex WebSocket responses when no WebSocket-specific timeout is configured, so a stalled preferred transport surfaces an error within the expected idle window.
+
 ## [0.18.0] - 2026-09-27
 
 ### Added

package/dist/types/index.d.ts

@@ -14,6 +14,7 @@ export * from "./provider-diagnostic";
 export * from "./provider-models";
 export * from "./providers/anthropic";
 export * from "./providers/azure-openai-responses";
+export * from "./providers/claude-code-version";
 export type * from "./providers/cursor";
 export * from "./providers/gitlab-duo";
 export type * from "./providers/google";

package/dist/types/provider-models/openai-compat.d.ts

@@ -121,8 +121,11 @@ export interface OpenGatewayModelManagerConfig {
 }
 /**
  * OpenGateway by Sionic AI — an OpenAI-compatible gateway that fronts OpenAI,
- * Anthropic, and Google models behind one API key. Models are discovered from
- * the OpenAI-compatible `/v1/models` endpoint.
+ * Anthropic, Google, DeepSeek, Z.ai, Moonshot and Qwen models behind one API key.
+ * Models are discovered from the OpenAI-compatible `/v1/models` endpoint, which
+ * reports no capability metadata, so capabilities come from the bundled catalog:
+ * the OpenGateway entry first, then the same upstream id from any bundled
+ * provider, with `-ultrafast` deployments resolved to their upstream model.
  */
 export declare function opengatewayModelManagerOptions(config?: OpenGatewayModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface BizRouterModelManagerConfig {

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

@@ -107,7 +107,6 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
-export declare const claudeCodeVersion = "2.1.281";
 export declare const claudeCodeEntrypoint = "sdk-cli";
 export declare const claudeToolPrefix: string;
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";

package/dist/types/providers/claude-code-version.d.ts

@@ -0,0 +1,39 @@
+/** Bundled floor; `scripts/check-spoofed-versions.ts --update` keeps it current. */
+export declare const CLAUDE_CODE_BASELINE_VERSION = "2.1.284";
+/** Pins the fingerprint and disables network resolution. */
+export declare const CLAUDE_CODE_VERSION_ENV = "GJC_CLAUDE_CODE_VERSION";
+/**
+ * Anthropic's native-installer release channel. `stable` deliberately lags the
+ * npm package during a staged rollout, so `latest` is the channel that matches
+ * what a freshly updated Claude Code actually reports.
+ */
+export declare const CLAUDE_RELEASE_CHANNEL_URL = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest";
+export declare const CLAUDE_NPM_DIST_TAG_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+export declare function compareClaudeCodeVersions(a: string, b: string): number;
+/**
+ * Latest published Claude Code version: the higher of the native-installer
+ * `latest` channel and the npm dist-tag, so one lagging or unavailable source
+ * cannot pin the fingerprint back. `null` when both sources fail.
+ */
+export declare function fetchLatestClaudeCodeVersion(fetchImpl?: FetchLike, userAgent?: string): Promise<string | null>;
+export interface ClaudeCodeVersionResolverOptions {
+    baseline: string;
+    /** Exact pin; disables network resolution when set. */
+    pinned?: string;
+    /** `null` disables both disk caching and network resolution. */
+    cachePath: string | null;
+    fetch?: FetchLike;
+    now?: () => number;
+    refreshIntervalMs?: number;
+}
+export interface ClaudeCodeVersionResolver {
+    /** Current fingerprint; schedules a background refresh when the cache is stale. */
+    get(): string;
+    /** Refresh now (deduplicated); resolves with the fingerprint afterwards. */
+    refresh(): Promise<string>;
+}
+export declare function createClaudeCodeVersionResolver(options: ClaudeCodeVersionResolverOptions): ClaudeCodeVersionResolver;
+/** Claude Code version the `claude-cli` fingerprint and billing attribution sign with. */
+export declare function getClaudeCodeVersion(): string;
+export {};

package/package.json

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

package/src/index.ts

@@ -14,6 +14,7 @@ export * from "./provider-diagnostic";
 export * from "./provider-models";
 export * from "./providers/anthropic";
 export * from "./providers/azure-openai-responses";
+export * from "./providers/claude-code-version";
 export type * from "./providers/cursor";
 export * from "./providers/gitlab-duo";
 export type * from "./providers/google";

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

@@ -1175,15 +1175,52 @@ export interface OpenGatewayModelManagerConfig {
 	baseUrl?: string;
 }
 
+const OPENGATEWAY_BASE_URL = "https://apis.opengateway.ai/v1";
+/** OpenGateway serves accelerated deployments of an upstream model as `<upstream id>-ultrafast`. */
+const OPENGATEWAY_ULTRAFAST_SUFFIX = "-ultrafast";
+
 /**
  * OpenGateway by Sionic AI — an OpenAI-compatible gateway that fronts OpenAI,
- * Anthropic, and Google models behind one API key. Models are discovered from
- * the OpenAI-compatible `/v1/models` endpoint.
+ * Anthropic, Google, DeepSeek, Z.ai, Moonshot and Qwen models behind one API key.
+ * Models are discovered from the OpenAI-compatible `/v1/models` endpoint, which
+ * reports no capability metadata, so capabilities come from the bundled catalog:
+ * the OpenGateway entry first, then the same upstream id from any bundled
+ * provider, with `-ultrafast` deployments resolved to their upstream model.
  */
 export function opengatewayModelManagerOptions(
 	config?: OpenGatewayModelManagerConfig,
 ): ModelManagerOptions<"openai-completions"> {
-	return createSimpleOpenAICompletionsOptions("opengateway", "https://apis.opengateway.ai/v1", config);
+	const apiKey = config?.apiKey;
+	const baseUrl = config?.baseUrl ?? OPENGATEWAY_BASE_URL;
+	const resolveReference = createReferenceResolver(createBundledReferenceMap<"openai-completions">("opengateway"));
+	return {
+		providerId: "opengateway",
+		...(apiKey && {
+			fetchDynamicModels: () =>
+				fetchOpenAICompatibleModels({
+					api: "openai-completions",
+					provider: "opengateway",
+					baseUrl,
+					apiKey,
+					mapModel: (entry, defaults) => {
+						const reference =
+							resolveReference(defaults.id) ??
+							(defaults.id.endsWith(OPENGATEWAY_ULTRAFAST_SUFFIX)
+								? resolveReference(defaults.id.slice(0, -OPENGATEWAY_ULTRAFAST_SUFFIX.length))
+								: undefined);
+						const mapped = mapWithBundledReference(entry, defaults, reference);
+						return {
+							...mapped,
+							contextWindow: toPositiveNumber(entry.context_window, mapped.contextWindow),
+							maxTokens: toPositiveNumber(entry.max_output_tokens, mapped.maxTokens),
+							api: "openai-completions",
+							provider: "opengateway",
+							baseUrl,
+						};
+					},
+				}),
+		}),
+	};
 }
 
 // ---------------------------------------------------------------------------

package/src/providers/anthropic.d.ts

@@ -107,7 +107,6 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
-export declare const claudeCodeVersion = "2.1.281";
 export declare const claudeCodeEntrypoint = "sdk-cli";
 export declare const claudeToolPrefix: string;
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";

package/src/providers/anthropic.ts

@@ -113,6 +113,7 @@ import {
 	type ResolveToolChoiceResult,
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
+import { getClaudeCodeVersion } from "./claude-code-version";
 import {
 	buildCopilotDynamicHeaders,
 	hasCopilotVisionInput,
@@ -294,7 +295,7 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 		const incomingUserAgent = getHeaderCaseInsensitive(options.modelHeaders, "User-Agent");
 		const userAgent = isClaudeCodeClientUserAgent(incomingUserAgent)
 			? incomingUserAgent
-			: `claude-cli/${claudeCodeVersion} (external, cli)`;
+			: `claude-cli/${getClaudeCodeVersion()} (external, cli)`;
 		return {
 			...modelHeaders,
 			...claudeCodeHeaders,
@@ -851,7 +852,6 @@ function getCacheControl(
 }
 
 // Stealth mode: Mimic Anthropic Code headers and tool prefixing.
-export const claudeCodeVersion = "2.1.281";
 export const claudeCodeEntrypoint = "sdk-cli";
 export const claudeToolPrefix: string = "proxy_";
 export const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
@@ -928,7 +928,7 @@ function createClaudeBillingHeader(payload: unknown): string {
 	const buildHash = Array.from(randomBytes, byte => byte.toString(16).padStart(2, "0"))
 		.join("")
 		.slice(0, 3);
-	return `${CLAUDE_BILLING_HEADER_PREFIX} cc_version=${claudeCodeVersion}.${buildHash}; cc_entrypoint=${claudeCodeEntrypoint}; cch=${cch};`;
+	return `${CLAUDE_BILLING_HEADER_PREFIX} cc_version=${getClaudeCodeVersion()}.${buildHash}; cc_entrypoint=${claudeCodeEntrypoint}; cch=${cch};`;
 }
 
 const CLAUDE_CLOAKING_USER_ID_REGEX =

package/src/providers/claude-code-version.d.ts

@@ -0,0 +1,39 @@
+/** Bundled floor; `scripts/check-spoofed-versions.ts --update` keeps it current. */
+export declare const CLAUDE_CODE_BASELINE_VERSION = "2.1.284";
+/** Pins the fingerprint and disables network resolution. */
+export declare const CLAUDE_CODE_VERSION_ENV = "GJC_CLAUDE_CODE_VERSION";
+/**
+ * Anthropic's native-installer release channel. `stable` deliberately lags the
+ * npm package during a staged rollout, so `latest` is the channel that matches
+ * what a freshly updated Claude Code actually reports.
+ */
+export declare const CLAUDE_RELEASE_CHANNEL_URL = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest";
+export declare const CLAUDE_NPM_DIST_TAG_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+export declare function compareClaudeCodeVersions(a: string, b: string): number;
+/**
+ * Latest published Claude Code version: the higher of the native-installer
+ * `latest` channel and the npm dist-tag, so one lagging or unavailable source
+ * cannot pin the fingerprint back. `null` when both sources fail.
+ */
+export declare function fetchLatestClaudeCodeVersion(fetchImpl?: FetchLike, userAgent?: string): Promise<string | null>;
+export interface ClaudeCodeVersionResolverOptions {
+    baseline: string;
+    /** Exact pin; disables network resolution when set. */
+    pinned?: string;
+    /** `null` disables both disk caching and network resolution. */
+    cachePath: string | null;
+    fetch?: FetchLike;
+    now?: () => number;
+    refreshIntervalMs?: number;
+}
+export interface ClaudeCodeVersionResolver {
+    /** Current fingerprint; schedules a background refresh when the cache is stale. */
+    get(): string;
+    /** Refresh now (deduplicated); resolves with the fingerprint afterwards. */
+    refresh(): Promise<string>;
+}
+export declare function createClaudeCodeVersionResolver(options: ClaudeCodeVersionResolverOptions): ClaudeCodeVersionResolver;
+/** Claude Code version the `claude-cli` fingerprint and billing attribution sign with. */
+export declare function getClaudeCodeVersion(): string;
+export {};

package/src/providers/claude-code-version.ts

@@ -0,0 +1,205 @@
+/**
+ * Claude Code client-version resolution for the `claude-cli` fingerprint.
+ *
+ * Anthropic gates newer models behind a minimum Claude Code version and answers
+ * stale fingerprints with HTTP 400 (`claude_code_version_too_old`). A version
+ * baked in at build time goes stale between releases, so the fingerprint is the
+ * higher of the bundled floor and the latest published Claude Code release,
+ * resolved in the background and cached on disk. Requests never wait on the
+ * network: they sign with whatever is known at that instant.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getClaudeCodeVersionCachePath, isEnoent, logger } from "@gajae-code/utils";
+
+/** Bundled floor; `scripts/check-spoofed-versions.ts --update` keeps it current. */
+export const CLAUDE_CODE_BASELINE_VERSION = "2.1.284";
+
+/** Pins the fingerprint and disables network resolution. */
+export const CLAUDE_CODE_VERSION_ENV = "GJC_CLAUDE_CODE_VERSION";
+
+/**
+ * Anthropic's native-installer release channel. `stable` deliberately lags the
+ * npm package during a staged rollout, so `latest` is the channel that matches
+ * what a freshly updated Claude Code actually reports.
+ */
+export const CLAUDE_RELEASE_CHANNEL_URL =
+	"https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest";
+export const CLAUDE_NPM_DIST_TAG_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
+
+const REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 5_000;
+const EXACT_SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+const EMBEDDED_SEMVER_RE = /(\d+\.\d+\.\d+)/;
+
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+
+export function compareClaudeCodeVersions(a: string, b: string): number {
+	const left = a.split(".").map(Number);
+	const right = b.split(".").map(Number);
+	for (let i = 0; i < 3; i++) {
+		const diff = (left[i] ?? 0) - (right[i] ?? 0);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+
+function isExactSemver(value: unknown): value is string {
+	return typeof value === "string" && EXACT_SEMVER_RE.test(value);
+}
+
+function highest(candidates: ReadonlyArray<string | null | undefined>): string | null {
+	let best: string | null = null;
+	for (const candidate of candidates) {
+		if (!isExactSemver(candidate)) continue;
+		if (best === null || compareClaudeCodeVersions(candidate, best) > 0) best = candidate;
+	}
+	return best;
+}
+
+async function fetchText(fetchImpl: FetchLike, url: string, userAgent: string): Promise<string | null> {
+	try {
+		const res = await fetchImpl(url, {
+			headers: { "User-Agent": userAgent },
+			signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+		});
+		if (!res.ok) return null;
+		return await res.text();
+	} catch {
+		return null;
+	}
+}
+
+async function fetchReleaseChannel(fetchImpl: FetchLike, userAgent: string): Promise<string | null> {
+	const text = await fetchText(fetchImpl, CLAUDE_RELEASE_CHANNEL_URL, userAgent);
+	return text === null ? null : (EMBEDDED_SEMVER_RE.exec(text.trim())?.[1] ?? null);
+}
+
+async function fetchNpmDistTag(fetchImpl: FetchLike, userAgent: string): Promise<string | null> {
+	const text = await fetchText(fetchImpl, CLAUDE_NPM_DIST_TAG_URL, userAgent);
+	if (text === null) return null;
+	try {
+		const data = JSON.parse(text) as { version?: unknown };
+		return typeof data.version === "string" ? (EMBEDDED_SEMVER_RE.exec(data.version)?.[1] ?? null) : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Latest published Claude Code version: the higher of the native-installer
+ * `latest` channel and the npm dist-tag, so one lagging or unavailable source
+ * cannot pin the fingerprint back. `null` when both sources fail.
+ */
+export async function fetchLatestClaudeCodeVersion(
+	fetchImpl: FetchLike = fetch,
+	userAgent = "gajae-code/claude-code-version",
+): Promise<string | null> {
+	return highest(
+		await Promise.all([fetchReleaseChannel(fetchImpl, userAgent), fetchNpmDistTag(fetchImpl, userAgent)]),
+	);
+}
+
+interface CachedClaudeCodeVersion {
+	version: string;
+	checkedAt: number;
+}
+
+export interface ClaudeCodeVersionResolverOptions {
+	baseline: string;
+	/** Exact pin; disables network resolution when set. */
+	pinned?: string;
+	/** `null` disables both disk caching and network resolution. */
+	cachePath: string | null;
+	fetch?: FetchLike;
+	now?: () => number;
+	refreshIntervalMs?: number;
+}
+
+export interface ClaudeCodeVersionResolver {
+	/** Current fingerprint; schedules a background refresh when the cache is stale. */
+	get(): string;
+	/** Refresh now (deduplicated); resolves with the fingerprint afterwards. */
+	refresh(): Promise<string>;
+}
+
+export function createClaudeCodeVersionResolver(options: ClaudeCodeVersionResolverOptions): ClaudeCodeVersionResolver {
+	const { baseline, cachePath } = options;
+	const fetchImpl = options.fetch ?? fetch;
+	const now = options.now ?? Date.now;
+	const refreshIntervalMs = options.refreshIntervalMs ?? REFRESH_INTERVAL_MS;
+	const pinned = isExactSemver(options.pinned) ? options.pinned : undefined;
+
+	let loaded = false;
+	let resolved: string | undefined;
+	let checkedAt = 0;
+	let inflight: Promise<string> | undefined;
+
+	const current = (): string => (resolved && compareClaudeCodeVersions(resolved, baseline) > 0 ? resolved : baseline);
+
+	const loadCache = (): void => {
+		if (loaded || cachePath === null) return;
+		loaded = true;
+		try {
+			const data = JSON.parse(fs.readFileSync(cachePath, "utf-8")) as Partial<CachedClaudeCodeVersion>;
+			if (isExactSemver(data.version) && typeof data.checkedAt === "number" && Number.isFinite(data.checkedAt)) {
+				resolved = data.version;
+				checkedAt = data.checkedAt;
+			}
+		} catch (error) {
+			if (!isEnoent(error)) logger.debug("Ignoring unreadable Claude Code version cache", { error: String(error) });
+		}
+	};
+
+	const refresh = (): Promise<string> => {
+		if (pinned || cachePath === null) return Promise.resolve(pinned ?? current());
+		loadCache();
+		inflight ??= (async () => {
+			try {
+				const latest = await fetchLatestClaudeCodeVersion(fetchImpl);
+				// A failed lookup still counts as a check so an offline host does not
+				// retry on every request; the next attempt waits a full interval.
+				checkedAt = now();
+				if (latest && (!resolved || compareClaudeCodeVersions(latest, resolved) > 0)) resolved = latest;
+				if (resolved) {
+					const record: CachedClaudeCodeVersion = { version: resolved, checkedAt };
+					await Bun.write(cachePath, `${JSON.stringify(record)}\n`);
+				}
+			} catch (error) {
+				logger.debug("Claude Code version refresh failed", { error: String(error) });
+			} finally {
+				inflight = undefined;
+			}
+			return current();
+		})();
+		return inflight;
+	};
+
+	return {
+		get() {
+			if (pinned) return pinned;
+			if (cachePath === null) return baseline;
+			loadCache();
+			if (!inflight && now() - checkedAt >= refreshIntervalMs) void refresh();
+			return current();
+		},
+		refresh,
+	};
+}
+
+let defaultResolver: ClaudeCodeVersionResolver | undefined;
+
+function getDefaultResolver(): ClaudeCodeVersionResolver {
+	defaultResolver ??= createClaudeCodeVersionResolver({
+		baseline: CLAUDE_CODE_BASELINE_VERSION,
+		pinned: process.env[CLAUDE_CODE_VERSION_ENV]?.trim() || undefined,
+		// Tests must stay hermetic and deterministic: no network, no user cache.
+		cachePath: process.env.NODE_ENV === "test" ? null : path.resolve(getClaudeCodeVersionCachePath()),
+	});
+	return defaultResolver;
+}
+
+/** Claude Code version the `claude-cli` fingerprint and billing attribution sign with. */
+export function getClaudeCodeVersion(): string {
+	return getDefaultResolver().get();
+}

package/src/providers/openai-codex-responses.ts

@@ -222,6 +222,14 @@ function isCodexStreamProgressEvent(event: unknown): boolean {
 	const delta = (event as { delta?: unknown }).delta;
 	return typeof delta === "string" && delta.length > 0;
 }
+
+function codexOutputHasMeaningfulProgress(output: AssistantMessage): boolean {
+	return output.content.some(
+		block =>
+			(block.type === "text" && block.text.length > 0) || (block.type === "thinking" && block.thinking.length > 0),
+	);
+}
+
 type CodexTransport = "sse" | "websocket";
 interface CodexInitialTransport {
 	eventStream: AsyncGenerator<Record<string, unknown>>;
@@ -412,7 +420,7 @@ function getCodexWebSocketIdleTimeoutMs(overrideMs?: number): number {
 		overrideMs ??
 		parseCodexPositiveInteger(
 			$env.GJC_OPENAI_CODE_WEBSOCKET_IDLE_TIMEOUT_MS ?? $env.PI_CODEX_WEBSOCKET_IDLE_TIMEOUT_MS,
-			CODEX_WEBSOCKET_IDLE_TIMEOUT_MS,
+			getOpenAIStreamIdleTimeoutMs() ?? CODEX_WEBSOCKET_IDLE_TIMEOUT_MS,
 		)
 	);
 }
@@ -1728,6 +1736,20 @@ async function recoverCodexStreamError(
 	error: unknown,
 ): Promise<boolean> {
 	if (isCodexFirstEventTimeout(error)) return false;
+	// A post-progress idle timeout has already consumed the stream's silence budget.
+	// Replaying it over another transport can leave the turn silent for another full window.
+	if (
+		(codexOutputHasMeaningfulProgress(context.output) ||
+			(context.output.content.some(block => block.type === "thinking") &&
+				context.output.content.some(
+					block => block.type === "toolCall" && !runtime.finalizedToolCallIds.has(block.id),
+				))) &&
+		error instanceof Error &&
+		isCodexWebSocketTransportError(error) &&
+		error.message.includes("idle timeout waiting for websocket")
+	) {
+		return false;
+	}
 	if (await tryRetryWithoutForcedToolChoice(context, runtime, error)) {
 		return true;
 	}

package/src/usage/claude.ts

@@ -1,5 +1,5 @@
 import { scheduler } from "node:timers/promises";
-import { claudeCodeVersion } from "../providers/anthropic";
+import { getClaudeCodeVersion } from "../providers/claude-code-version";
 import type {
 	CredentialRankingStrategy,
 	UsageAmount,
@@ -32,7 +32,6 @@ const CLAUDE_HEADERS = {
 	"anthropic-beta":
 		"claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05",
 	"content-type": "application/json",
-	"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
 	connection: "keep-alive",
 } as const;
 
@@ -352,6 +351,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 	const url = `${baseUrl}/usage`;
 	const headers: Record<string, string> = {
 		...CLAUDE_HEADERS,
+		"user-agent": `claude-cli/${getClaudeCodeVersion()} (external, cli)`,
 		authorization: `Bearer ${credential.accessToken}`,
 	};