@oh-my-pi/pi-ai 18.2.8 → 18.2.9

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

@@ -4290,11 +4290,22 @@ async function openCodexSseEventStream(
 	// an internal timeout stays retryable while an explicit abort fails fast.
 	let clearPreResponseTimeout: (() => void) | undefined;
 	const fetchAttempt: FetchImpl = async (input, init) => {
+		let response: Response | undefined;
 		try {
-			return await (fetchOverride ?? fetch)(input, init);
+			response = await (fetchOverride ?? fetch)(input, init);
+			return response;
 		} finally {
-			clearPreResponseTimeout?.();
-			clearPreResponseTimeout = undefined;
+			// A successful streaming body is governed by the iterator-level idle
+			// watchdog, so disarm the pre-response guard the instant headers arrive.
+			// Keep it armed for a non-2xx response: the error body is still
+			// consumed under this deadline — by fetchWithRetry's
+			// retry-status inspection and by CodexApiError.fromResponse — otherwise a
+			// server that sends headers then stalls the body hangs the turn past every
+			// configured first-event/idle deadline (issue #12664).
+			if (!response || response.ok) {
+				clearPreResponseTimeout?.();
+				clearPreResponseTimeout = undefined;
+			}
 		}
 	};
 	const bodyJson = JSON.stringify(body);
@@ -4318,6 +4329,9 @@ async function openCodexSseEventStream(
 			body: requestBody,
 			signal,
 			prepareInit: () => {
+				// A retried non-2xx attempt leaves its guard armed for the retry-status
+				// body read; disarm it before arming the next attempt's guard.
+				clearPreResponseTimeout?.();
 				const watchdog = armPreResponseTimeout(signal, firstEventTimeoutMs);
 				clearPreResponseTimeout = watchdog.clear;
 				return { signal: watchdog.signal };
@@ -4342,8 +4356,9 @@ async function openCodexSseEventStream(
 				});
 			response = await send(bodyJson);
 		}
-	} finally {
+	} catch (error) {
 		clearPreResponseTimeout?.();
+		throw error;
 	}
 	CODEX_DEBUG &&
 		logger.debug("[codex] codex response", {
@@ -4354,7 +4369,14 @@ async function openCodexSseEventStream(
 			cfRay: response.headers.get("cf-ray") || null,
 		});
 	if (!response.ok) {
-		throw await CodexApiError.fromResponse(response);
+		// The pre-response guard is still armed for a non-2xx response; keep it live
+		// across the error-body read so a stalled body is bounded, then disarm once
+		// the read settles (issue #12664).
+		try {
+			throw await CodexApiError.fromResponse(response);
+		} finally {
+			clearPreResponseTimeout?.();
+		}
 	}
 	updateCodexSessionMetadataFromHeaders(turnState, state, response.headers);
 	if (!response.body) {

package/src/providers/openai-completions.ts

@@ -1,3 +1,4 @@
+import { resolveModelPolicy } from "@oh-my-pi/pi-catalog/compat/resolve";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { resolveWireModelId } from "@oh-my-pi/pi-catalog/model-thinking";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
@@ -133,6 +134,13 @@ type OpenAICompletionsDeltaWithReasoningDetails = ChatCompletionChunk.Choice["de
 	reasoning_details?: unknown;
 };
 
+type GeminiMessageThoughtSignatureField = "thinking_signature" | "thought_signature";
+
+type GeminiMessageThoughtSignature = {
+	field: GeminiMessageThoughtSignatureField;
+	signature: string;
+};
+
 type GeminiThoughtSignatureNamespace = "google" | "vertex";
 
 type GeminiThoughtSignatureExtraContent = Partial<
@@ -145,6 +153,11 @@ type OpenAICompletionsFunctionToolCall = ChatCompletionMessageFunctionToolCall &
 
 const GEMINI_THOUGHT_SIGNATURE_NAMESPACES: readonly GeminiThoughtSignatureNamespace[] = ["google", "vertex"];
 
+const GEMINI_MESSAGE_THOUGHT_SIGNATURE_FIELDS: readonly GeminiMessageThoughtSignatureField[] = [
+	"thinking_signature",
+	"thought_signature",
+];
+
 function getGeminiThoughtSignatureExtraContent(value: unknown): GeminiThoughtSignatureExtraContent | undefined {
 	if (typeof value !== "object" || value === null) return undefined;
 	for (const namespace of GEMINI_THOUGHT_SIGNATURE_NAMESPACES) {
@@ -159,20 +172,66 @@ function getGeminiThoughtSignatureExtraContent(value: unknown): GeminiThoughtSig
 	return undefined;
 }
 
-function parseGeminiThoughtSignatureExtraContent(
-	thoughtSignature: string | undefined,
-): GeminiThoughtSignatureExtraContent | undefined {
+function getGeminiMessageThoughtSignature(value: unknown): GeminiMessageThoughtSignature | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	for (const field of GEMINI_MESSAGE_THOUGHT_SIGNATURE_FIELDS) {
+		const signature = Reflect.get(value, field);
+		if (typeof signature === "string" && signature.length > 0) return { field, signature };
+	}
+	return undefined;
+}
+
+function parseStoredThoughtSignature(thoughtSignature: string | undefined): unknown {
 	if (!thoughtSignature) return undefined;
 	try {
-		const parsed: unknown = JSON.parse(thoughtSignature);
-		return getGeminiThoughtSignatureExtraContent(parsed);
+		return JSON.parse(thoughtSignature);
 	} catch {
 		return undefined;
 	}
 }
 
+// A single tool-call turn on an OpenAI-compatible Gemini wire can carry two
+// independent signatures: a per-call one (`extra_content.google|vertex` or an
+// encrypted `reasoning_details` entry) and a message-level `thinking_signature`
+// / `thought_signature`. Both are stashed together on the originating tool
+// call's `thoughtSignature` so persistence and replay preserve each field.
+// `perCall` holds the raw extra_content object or reasoning detail; `message`
+// holds the message-level signature in its wire shape.
+type StoredGeminiSignature = {
+	perCall?: unknown;
+	message?: Partial<Record<GeminiMessageThoughtSignatureField, string>>;
+};
+
+// Reads the stored envelope, also accepting the legacy raw shapes emitted before
+// the envelope existed (a bare extra_content object, reasoning detail, or
+// message-level signature) so persisted history keeps replaying.
+function normalizeStoredGeminiSignature(value: unknown): StoredGeminiSignature | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	const perCall = Reflect.get(value, "perCall");
+	const envelopeMessage = getGeminiMessageThoughtSignature(Reflect.get(value, "message"));
+	if (perCall !== undefined || envelopeMessage) {
+		const normalized: StoredGeminiSignature = {};
+		if (perCall !== undefined) normalized.perCall = perCall;
+		if (envelopeMessage) normalized.message = { [envelopeMessage.field]: envelopeMessage.signature };
+		return normalized;
+	}
+	const legacyMessage = getGeminiMessageThoughtSignature(value);
+	if (legacyMessage) return { message: { [legacyMessage.field]: legacyMessage.signature } };
+	return { perCall: value };
+}
+
+// Merges a new per-call or message-level signature into whatever is already
+// stored, so a later message-level signature never clobbers an earlier per-call
+// one (and vice versa).
+function mergeStoredGeminiSignature(existing: string | undefined, update: StoredGeminiSignature): string {
+	const merged = normalizeStoredGeminiSignature(parseStoredThoughtSignature(existing)) ?? {};
+	if (update.perCall !== undefined) merged.perCall = update.perCall;
+	if (update.message) merged.message = update.message;
+	return JSON.stringify(merged);
+}
+
 type OpenAICompletionsAssistantMessageParam = ChatCompletionAssistantMessageParam &
-	Partial<Record<OpenAICompletionsReasoningField, string>> & {
+	Partial<Record<OpenAICompletionsReasoningField | GeminiMessageThoughtSignatureField, string>> & {
 		reasoning_details?: unknown[];
 	};
 
@@ -919,6 +978,7 @@ const streamOpenAICompletionsOnce = (
 				}
 			};
 			let currentBlock: OpenAIStreamBlock | undefined;
+			let messageThoughtSignature: GeminiMessageThoughtSignature | undefined;
 			const blockIndex = (block: OpenAIStreamBlock | undefined): number => {
 				if (!block) return Math.max(0, output.content.length - 1);
 				return output.content.indexOf(block);
@@ -1347,7 +1407,11 @@ const streamOpenAICompletionsOnce = (
 							if (toolCall.id) block.id = toolCall.id;
 							if (incomingName) block.name = incomingName;
 							const extraContent = getGeminiThoughtSignatureExtraContent(Reflect.get(toolCall, "extra_content"));
-							if (extraContent) block.thoughtSignature = JSON.stringify(extraContent);
+							if (extraContent) {
+								block.thoughtSignature = mergeStoredGeminiSignature(block.thoughtSignature, {
+									perCall: extraContent,
+								});
+							}
 							let delta = "";
 							// The OpenAI SDK types `function.arguments` as a JSON string, but MiniMax-compatible
 							// hosts stream a fully-formed object instead. Model both shapes so the branches below
@@ -1411,11 +1475,29 @@ const streamOpenAICompletionsOnce = (
 									b => b.type === "toolCall" && b.id === detailObject.id,
 								) as ToolCall | undefined;
 								if (matchingToolCall) {
-									matchingToolCall.thoughtSignature = JSON.stringify(detailObject);
+									matchingToolCall.thoughtSignature = mergeStoredGeminiSignature(
+										matchingToolCall.thoughtSignature,
+										{ perCall: detailObject },
+									);
 								}
 							}
 						}
 					}
+
+					const incomingMessageThoughtSignature = getGeminiMessageThoughtSignature(choice.delta);
+					if (incomingMessageThoughtSignature) messageThoughtSignature = incomingMessageThoughtSignature;
+					if (messageThoughtSignature) {
+						for (const block of output.content) {
+							if (block.type !== "toolCall") continue;
+							block.thoughtSignature = mergeStoredGeminiSignature(block.thoughtSignature, {
+								message: {
+									[messageThoughtSignature.field]: messageThoughtSignature.signature,
+								},
+							});
+							messageThoughtSignature = undefined;
+							break;
+						}
+					}
 				}
 
 				// If usage arrived on the finish chunk without cache-read fields,
@@ -1542,16 +1624,33 @@ const streamOpenAICompletionsOnce = (
 	return stream;
 };
 
+/**
+ * Custom APIs deliberately have no catalog compat type. Once an extension
+ * explicitly delegates to this streamer, resolve the OpenAI wire policy on a
+ * request-local clone while preserving the custom API id on the original model.
+ */
+function resolveOpenAICompletionsCompat(model: Model<"openai-completions">): Model<"openai-completions"> {
+	if (model.compat !== undefined) return model;
+	const compat = resolveModelPolicy({
+		...model,
+		api: "openai-completions",
+		compat: model.compatConfig,
+	}).compat;
+	return { ...model, compat };
+}
+
 /**
  * Retries benign empty completions and transient provider failures only before
  * assistant output commits the attempt.
  */
-export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (model, context, options) =>
-	withReplaySafeStreamRetry(model, context, options, streamOpenAICompletionsOnce, {
+export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (model, context, options) => {
+	const resolvedModel = resolveOpenAICompletionsCompat(model);
+	return withReplaySafeStreamRetry(resolvedModel, context, options, streamOpenAICompletionsOnce, {
 		retryEmptyCompletion: true,
 		retryProviderErrors: true,
 		maxProviderErrorRetries: 1,
 	});
+};
 
 function createRequestSetup(
 	model: Model<"openai-completions">,
@@ -2350,19 +2449,23 @@ export function convertMessages(
 							arguments: serializeToolArguments(tc.arguments),
 						},
 					};
-					const extraContent = parseGeminiThoughtSignatureExtraContent(tc.thoughtSignature);
+					const stored = normalizeStoredGeminiSignature(parseStoredThoughtSignature(tc.thoughtSignature));
+					const extraContent = getGeminiThoughtSignatureExtraContent(stored?.perCall);
 					if (extraContent) replayedToolCall.extra_content = extraContent;
 					return replayedToolCall;
 				});
+				for (const toolCall of toolCalls) {
+					const stored = normalizeStoredGeminiSignature(parseStoredThoughtSignature(toolCall.thoughtSignature));
+					const messageSignature = getGeminiMessageThoughtSignature(stored?.message);
+					if (!messageSignature) continue;
+					assistantMsg[messageSignature.field] = messageSignature.signature;
+					break;
+				}
 				const reasoningDetails = toolCalls.flatMap(tc => {
-					const thoughtSignature = tc.thoughtSignature;
-					if (!thoughtSignature) return [];
-					try {
-						const parsed: unknown = JSON.parse(thoughtSignature);
-						return getGeminiThoughtSignatureExtraContent(parsed) ? [] : [parsed];
-					} catch {
-						return [];
-					}
+					const stored = normalizeStoredGeminiSignature(parseStoredThoughtSignature(tc.thoughtSignature));
+					const perCall = stored?.perCall;
+					if (perCall === undefined || getGeminiThoughtSignatureExtraContent(perCall)) return [];
+					return [perCall];
 				});
 				if (reasoningDetails.length > 0) {
 					assistantMsg.reasoning_details = reasoningDetails;

package/src/providers/pi-native-server.ts

@@ -69,6 +69,7 @@ const ALLOWED_OPTION_KEYS: ReadonlySet<keyof SimpleStreamOptions> = new Set([
 	"streamIdleTimeoutMs",
 	"reasoning",
 	"disableReasoning",
+	"forceReasoningOff",
 	"hideThinkingSummary",
 	"thinkingBudgets",
 	"toolChoice",

package/src/registry/oauth/anthropic.ts

@@ -7,14 +7,13 @@
  */
 
 import * as AIError from "../../error";
-import { claudeCodeVersion } from "../../providers/claude-code-fingerprint";
+import { getClaudeCodeVersion } from "../../providers/claude-code-fingerprint";
 import type { FetchImpl } from "../../types";
 import type { AfterExchangeHook } from "../hooks/types";
 import type { OAuthCredentials } from "./types";
 
 const BOOTSTRAP_URL = "https://api.anthropic.com/api/claude_cli/bootstrap";
 const CLAUDE_CODE_BOOTSTRAP_MODEL = "claude-opus-4-8";
-const CLAUDE_CODE_BOOTSTRAP_USER_AGENT = `claude-code/${claudeCodeVersion}`;
 
 export { ANTHROPIC_OAUTH_GRANT_TTL_MS } from "./anthropic-constants";
 
@@ -56,7 +55,7 @@ export async function fetchAnthropicBootstrapIdentity(
 			Accept: "application/json, text/plain, */*",
 			Authorization: `Bearer ${accessToken}`,
 			"Content-Type": "application/json",
-			"User-Agent": CLAUDE_CODE_BOOTSTRAP_USER_AGENT,
+			"User-Agent": `claude-code/${getClaudeCodeVersion()}`,
 			"anthropic-beta": "oauth-2025-04-20",
 		},
 		signal: AbortSignal.timeout(30_000),

package/src/stream.ts

@@ -1841,7 +1841,7 @@ function resolveBedrockThinkingBudget(
 	model: Model<"bedrock-converse-stream">,
 	options?: SimpleStreamOptions,
 ): { budget: number; level: Effort } | null {
-	if (!options?.reasoning || !model.reasoning) return null;
+	if (!options?.reasoning || !model.reasoning || options.disableReasoning || options.forceReasoningOff) return null;
 	const level = requireSupportedEffort(model, options.reasoning);
 	const budget = options.thinkingBudgets?.[level] ?? BEDROCK_CLAUDE_THINKING[level];
 	return { budget, level };
@@ -2167,7 +2167,11 @@ function mapOptionsForApi<TApi extends Api>(
 		case "bedrock-converse-stream": {
 			const bedrockBase: BedrockOptions = {
 				...base,
-				reasoning: options?.reasoning,
+				// Explicit reasoning-off must fold here like the anthropic-messages
+				// branch: the provider gates thinking only on `reasoning`, and the
+				// budget path below must not inflate a capped request for thinking
+				// that was turned off.
+				reasoning: options?.disableReasoning || options?.forceReasoningOff ? undefined : options?.reasoning,
 				thinkingBudgets: options?.thinkingBudgets,
 				toolChoice: mapAnthropicToolChoice(options?.toolChoice),
 				thinkingDisplay: options?.hideThinkingSummary ? "omitted" : undefined,
@@ -2212,6 +2216,9 @@ function mapOptionsForApi<TApi extends Api>(
 					openrouterVariant: options?.openrouterVariant,
 					maxTokensExplicit: rawOptions?.maxTokens !== undefined,
 					disableReasoning: options?.disableReasoning,
+					// Forwarded, not folded: the Responses record reads both flags
+					// itself (`applyResponsesCompatPolicy`).
+					forceReasoningOff: options?.forceReasoningOff,
 					textVerbosity: options?.textVerbosity,
 					promptCache: options?.promptCache,
 					statefulResponses: options?.statefulResponses,
@@ -2220,7 +2227,8 @@ function mapOptionsForApi<TApi extends Api>(
 			return castApi<"openai-completions">({
 				...base,
 				reasoning: resolveOpenAiReasoningEffort(model, options),
-				disableReasoning: options?.disableReasoning,
+				// `OpenAICompletionsOptions` carries no forceReasoningOff; fold it.
+				disableReasoning: options?.disableReasoning || options?.forceReasoningOff,
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
 				serviceTier: options?.serviceTier,
 				openrouterVariant: options?.openrouterVariant,
@@ -2233,7 +2241,8 @@ function mapOptionsForApi<TApi extends Api>(
 			return castApi<"openai-completions">({
 				...base,
 				reasoning: resolveOpenAiReasoningEffort(model, options),
-				disableReasoning: options?.disableReasoning,
+				// `OpenAICompletionsOptions` carries no forceReasoningOff; fold it.
+				disableReasoning: options?.disableReasoning || options?.forceReasoningOff,
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
 				serviceTier: options?.serviceTier,
 				openrouterVariant: options?.openrouterVariant,

package/src/usage/alibaba-token-plan.ts

@@ -46,7 +46,6 @@ const CHINA_CONSOLE = {
 		protocol: "V2",
 		console: "ONE_CONSOLE",
 		productCode: "p_efm",
-		switchAgent: 12608464,
 		switchUserType: 3,
 		domain: "bailian.console.aliyun.com",
 		consoleSite: "BAILIAN_ALIYUN",
@@ -221,6 +220,13 @@ async function fetchAlibabaTokenPlanUsage(
 			ctx.logger?.warn("Alibaba Token Plan usage response invalid", { provider: PROVIDER });
 			return null;
 		}
+		if (payload.data.success === false) {
+			ctx.logger?.warn("Alibaba Token Plan usage request rejected", {
+				provider: PROVIDER,
+				errorCode: typeof payload.data.errorCode === "string" ? payload.data.errorCode : "unknown",
+			});
+			return null;
+		}
 		const responseData = unwrapGatewayData(payload.data);
 		const limits = [
 			buildLimit(

package/src/usage/claude-api.ts

@@ -0,0 +1,66 @@
+import { getClaudeCodeUserAgent } from "../providers/claude-code-fingerprint";
+
+/** Canonical host for Claude's first-party account API. */
+export const DEFAULT_CLAUDE_API_BASE_URL = "https://api.anthropic.com";
+/** Canonical subscription usage and profile endpoint. */
+export const DEFAULT_CLAUDE_OAUTH_BASE_URL = `${DEFAULT_CLAUDE_API_BASE_URL}/api/oauth`;
+/** OAuth protocol beta required by Claude's account routes. */
+export const CLAUDE_OAUTH_BETA = "oauth-2025-04-20";
+
+/**
+ * Normalize Messages (`/v1`) and OAuth (`/api/oauth`) endpoints to the common
+ * API root used by both usage and reset routes. Custom path prefixes survive.
+ */
+export function normalizeClaudeApiBaseUrl(baseUrl?: string): string {
+	if (!baseUrl?.trim()) return DEFAULT_CLAUDE_API_BASE_URL;
+	let url: URL;
+	try {
+		url = new URL(baseUrl.trim());
+	} catch {
+		return DEFAULT_CLAUDE_API_BASE_URL;
+	}
+	let path = url.pathname.replace(/\/+$/, "");
+	if (path === "/") path = "";
+	const lower = path.toLowerCase();
+	if (lower.endsWith("/api/oauth")) {
+		path = path.slice(0, -"/api/oauth".length);
+	} else if (lower.endsWith("/v1")) {
+		path = path.slice(0, -"/v1".length);
+	}
+	return `${url.origin}${path}`;
+}
+
+/** Resolve the OAuth API base while retaining a configured proxy path prefix. */
+export function claudeOAuthBaseUrl(baseUrl?: string): string {
+	return `${normalizeClaudeApiBaseUrl(baseUrl)}/api/oauth`;
+}
+
+/** Configured OAuth endpoint followed by canonical fallback, without duplicates. */
+export function claudeOAuthBaseUrls(baseUrl?: string): readonly string[] {
+	const configured = claudeOAuthBaseUrl(baseUrl);
+	return configured === DEFAULT_CLAUDE_OAUTH_BASE_URL
+		? [DEFAULT_CLAUDE_OAUTH_BASE_URL]
+		: [configured, DEFAULT_CLAUDE_OAUTH_BASE_URL];
+}
+
+/** Resolve a first-party account route against the configured Claude API root. */
+export function claudeApiUrl(baseUrl: string | undefined, path: string): string {
+	const suffix = path.startsWith("/") ? path : `/${path}`;
+	return `${normalizeClaudeApiBaseUrl(baseUrl)}${suffix}`;
+}
+
+/** Shared OAuth and CLI identity headers for Claude usage, profile, and resets. */
+export function buildClaudeOAuthHeaders(
+	accessToken: string,
+	options: { beta?: string; json?: boolean } = {},
+): Record<string, string> {
+	return {
+		accept: "application/json, text/plain, */*",
+		"accept-encoding": "gzip, compress, deflate, br",
+		"anthropic-beta": options.beta ?? CLAUDE_OAUTH_BETA,
+		...(options.json === false ? {} : { "content-type": "application/json" }),
+		connection: "keep-alive",
+		"user-agent": getClaudeCodeUserAgent(),
+		authorization: `Bearer ${accessToken}`,
+	};
+}