@linxiraos/pi-ai 1.0.0 → 1.0.2

package/src/error/rate-limit.ts

@@ -1,3 +1,5 @@
+import { extractRetryHint } from "@linxiraos/pi-utils";
+
 /**
  * Rate limit reason classification and backoff calculation utilities.
  * Ported from opencode-antigravity-auth plugin for consistency.
@@ -5,6 +7,7 @@
 
 export type RateLimitReason =
 	| "QUOTA_EXHAUSTED"
+	| "INSUFFICIENT_G1_CREDITS_BALANCE"
 	| "RATE_LIMIT_EXCEEDED"
 	| "CONCURRENT_LIMIT"
 	| "MODEL_CAPACITY_EXHAUSTED"
@@ -67,6 +70,66 @@ const CN_TRANSIENT_CAP_PATTERN =
 // of rotating through the opaque-429 fallback.
 const CN_THROTTLE_PATTERN = /速率(?:限制|过快)|频率(?:过高|过快)|过于频繁|稍后[重再]试/;
 
+const GOOGLE_RPC_ERROR_INFO_TYPE = "type.googleapis.com/google.rpc.ErrorInfo";
+const LONG_RATE_LIMIT_DELAY_MS = 5 * 60 * 1000;
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function parseJsonBody(errorMessage: string): Record<string, unknown> | undefined {
+	const start = errorMessage.indexOf("{");
+	const end = errorMessage.lastIndexOf("}");
+	if (start < 0 || end < start) return undefined;
+	try {
+		const parsed: unknown = JSON.parse(errorMessage.slice(start, end + 1));
+		return asRecord(parsed);
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Classify structured Google RESOURCE_EXHAUSTED bodies before consulting text.
+ * Cloud Code Assist prefixes the JSON with its HTTP error label, so accept an
+ * embedded top-level object as well as a raw JSON body.
+ */
+function parseGoogleRpcRateLimitReason(errorMessage: string): RateLimitReason | undefined {
+	const body = parseJsonBody(errorMessage);
+	const error = asRecord(body?.error);
+	if (typeof error?.status !== "string" || error.status.trim().toUpperCase() !== "RESOURCE_EXHAUSTED") {
+		return undefined;
+	}
+	if (!Array.isArray(error.details)) return undefined;
+
+	for (const value of error.details) {
+		const detail = asRecord(value);
+		if (detail?.["@type"] !== GOOGLE_RPC_ERROR_INFO_TYPE || typeof detail.reason !== "string") continue;
+		const reason = detail.reason.trim().toUpperCase();
+		switch (reason) {
+			case "QUOTA_EXHAUSTED":
+				return "QUOTA_EXHAUSTED";
+			case "INSUFFICIENT_G1_CREDITS_BALANCE":
+				// Keep Google's specific credit-balance reason available to logs
+				// and callers while treating it as credential-rotatable below.
+				return "INSUFFICIENT_G1_CREDITS_BALANCE";
+			case "RATE_LIMIT_EXCEEDED": {
+				const retryDelayMs = extractRetryHint(undefined, errorMessage);
+				return retryDelayMs !== undefined && retryDelayMs >= LONG_RATE_LIMIT_DELAY_MS
+					? "QUOTA_EXHAUSTED"
+					: "RATE_LIMIT_EXCEEDED";
+			}
+		}
+	}
+	return undefined;
+}
+
+function isQuotaExhaustedReason(reason: RateLimitReason): boolean {
+	return reason === "QUOTA_EXHAUSTED" || reason === "INSUFFICIENT_G1_CREDITS_BALANCE";
+}
+
 /**
  * Classify a rate-limit error message into a reason category.
  * Priority order: explicit details in a resource-exhausted error > QUOTA
@@ -77,6 +140,8 @@ const CN_THROTTLE_PATTERN = /速率(?:限制|过快)|频率(?:过高|过快)|过
  * Explicit details such as "quota exceeded" retain their normal classification.
  */
 export function parseRateLimitReason(errorMessage: string): RateLimitReason {
+	const structuredReason = parseGoogleRpcRateLimitReason(errorMessage);
+	if (structuredReason !== undefined) return structuredReason;
 	const lowerWithStatus = errorMessage.toLowerCase();
 	const lower = lowerWithStatus.replace(RESOURCE_EXHAUSTED_PATTERN, "");
 	const hasResourceExhaustedStatus = lower !== lowerWithStatus;
@@ -162,6 +227,7 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
  */
 export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 	switch (reason) {
+		case "INSUFFICIENT_G1_CREDITS_BALANCE":
 		case "QUOTA_EXHAUSTED":
 			return QUOTA_EXHAUSTED_BACKOFF_MS;
 		case "RATE_LIMIT_EXCEEDED":
@@ -215,6 +281,8 @@ export function isUsageLimitStatus(status: number | undefined): boolean {
  *     credentials.
  */
 export function isUsageLimitOutcome(status: number | undefined, message: string | undefined): boolean {
+	const structuredReason = message ? parseGoogleRpcRateLimitReason(message) : undefined;
+	if (structuredReason !== undefined) return isQuotaExhaustedReason(structuredReason);
 	// Concurrency caps are shed-and-backoff, not credential-rotatable — but only
 	// for quota-worded 429 / other statuses. HTTP 402 is categorically an
 	// account-billing cap, so a 402 whose body happens to mention concurrency is
@@ -235,7 +303,7 @@ export function isUsageLimitOutcome(status: number | undefined, message: string
 	const reason = parseRateLimitReason(message);
 	// For the categorical 402 billing cap a concurrency-worded body is still an
 	// exhausted cap (rotate); for 429 / other only QUOTA_EXHAUSTED rotates.
-	return reason === "QUOTA_EXHAUSTED" || (isBillingCapStatus && reason === "CONCURRENT_LIMIT");
+	return isQuotaExhaustedReason(reason) || (isBillingCapStatus && reason === "CONCURRENT_LIMIT");
 }
 
 /**
@@ -272,6 +340,8 @@ export function isOpaqueStatusBody(message: string): boolean {
  * {@link isUsageLimitOutcome} uses it for the account-rotation decision.
  */
 export function matchesUsageLimitText(errorMessage: string): boolean {
+	const structuredReason = parseGoogleRpcRateLimitReason(errorMessage);
+	if (structuredReason !== undefined) return isQuotaExhaustedReason(structuredReason);
 	return (
 		USAGE_LIMIT_PATTERN.test(errorMessage) ||
 		(CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) ||

package/src/providers/amazon-bedrock.ts

@@ -45,6 +45,19 @@ import { decodeEventStream } from "./aws-eventstream";
 import { signRequest } from "./aws-sigv4";
 import { transformMessages } from "./transform-messages";
 
+/**
+ * Headers SigV4 generates for itself. A caller cannot be allowed to supply these:
+ * `signRequest` would sign the caller's value but return its own, so the signature
+ * would not match what goes on the wire.
+ */
+const SIGNER_OWNED_HEADERS = new Set(["host", "x-amz-date", "x-amz-content-sha256", "x-amz-security-token"]);
+
+/** Headers the Bedrock request sets itself; a caller copy in any casing duplicates them. */
+// `content-length` included: the fetch layer recomputes it from the serialized
+// body, so a caller value would be signed but not sent, and AWS rejects the
+// mismatch.
+const BEDROCK_RESERVED_HEADERS = new Set(["content-type", "accept", "authorization", "content-length"]);
+
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 
 export interface BedrockOptions extends StreamOptions {
@@ -356,7 +369,32 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 
 			const bodyText = JSON.stringify(commandInput);
 			const body = new TextEncoder().encode(bodyText);
+			// Caller headers are merged BEFORE signing, so SigV4 covers them and they
+			// reach the wire. Bedrock built its header map from scratch and ignored
+			// `options.headers` entirely, so tracing/attribution headers set by a
+			// caller (or by a `before_provider_headers` extension) were silently
+			// dropped here while working on every other provider. Content-type and
+			// accept stay last: the eventstream framing is not the caller's to change.
+			//
+			// The signer's OWN headers are dropped first, and that is load-bearing:
+			// `signRequest` lets a caller value overwrite `host`/`x-amz-*` in the map
+			// it signs, but always RETURNS the generated ones, which `requestHeaders`
+			// below then puts on the wire. A caller supplying any of them would sign
+			// one set of values and send another, and Bedrock would reject every
+			// request with a signature mismatch.
+			// Lower-cased, and names the request sets itself are dropped. Keeping a
+			// caller `Content-Type` beside the fixed `content-type` leaves TWO object
+			// keys: SigV4 signs one value while fetch canonicalizes both into a single
+			// comma-joined wire header, so AWS validates different bytes than were
+			// signed and rejects the request.
+			const callerHeaders: Record<string, string> = {};
+			for (const [name, value] of Object.entries(options?.headers ?? {})) {
+				const field = name.toLowerCase();
+				if (SIGNER_OWNED_HEADERS.has(field) || BEDROCK_RESERVED_HEADERS.has(field)) continue;
+				callerHeaders[field] = value;
+			}
 			const baseHeaders: Record<string, string> = {
+				...callerHeaders,
 				"content-type": "application/json",
 				accept: "application/vnd.amazon.eventstream",
 			};

package/src/providers/anthropic-client.ts

@@ -27,7 +27,7 @@ import { AnthropicApiError, AnthropicConnectionError, AnthropicConnectionTimeout
 export { AnthropicApiError, AnthropicConnectionError, AnthropicConnectionTimeoutError };
 
 import type { FetchImpl } from "../types";
-import type { MessageCreateParamsStreaming } from "./anthropic-wire";
+import type { MessageCreateParams } from "./anthropic-wire";
 
 /** Default pre-response timeout, matching the SDK's 10-minute default. */
 const DEFAULT_TIMEOUT_MS = 600_000;
@@ -173,7 +173,7 @@ export class AnthropicMessages {
 		this.#path = path;
 	}
 
-	create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest {
+	create(params: MessageCreateParams, options?: AnthropicRequestOptions): AnthropicApiRequest {
 		return this.#client.request(this.#path, params, options);
 	}
 }
@@ -184,8 +184,8 @@ export class AnthropicMessages {
  * alternative Messages-API client via `AnthropicOptions.client`.
  */
 export interface AnthropicMessagesClientLike {
-	messages: { create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown };
-	beta?: { messages: { create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown } };
+	messages: { create(params: MessageCreateParams, options?: AnthropicRequestOptions): unknown };
+	beta?: { messages: { create(params: MessageCreateParams, options?: AnthropicRequestOptions): unknown } };
 }
 
 export class AnthropicMessagesClient implements AnthropicMessagesClientLike {
@@ -199,7 +199,7 @@ export class AnthropicMessagesClient implements AnthropicMessagesClientLike {
 		this.beta = { messages: new AnthropicMessages(this, "/v1/messages?beta=true") };
 	}
 
-	request(path: string, params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest {
+	request(path: string, params: MessageCreateParams, options?: AnthropicRequestOptions): AnthropicApiRequest {
 		return new AnthropicApiRequest(() => this.#send(path, params, options));
 	}
 
@@ -218,11 +218,7 @@ export class AnthropicMessagesClient implements AnthropicMessagesClientLike {
 		return headers;
 	}
 
-	async #send(
-		path: string,
-		params: MessageCreateParamsStreaming,
-		options?: AnthropicRequestOptions,
-	): Promise<Response> {
+	async #send(path: string, params: MessageCreateParams, options?: AnthropicRequestOptions): Promise<Response> {
 		const opts = this.#options;
 		const fetchFn: FetchImpl = opts.fetch ?? fetch;
 		const callerSignal = options?.signal;