@f5-sales-demo/pi-ai 21.13.1 → 21.13.2

package/CHANGELOG.md

@@ -10,6 +10,15 @@
 
 ### Fixed
 
+- Removed output-only lifecycle statuses before replaying persisted OpenAI Responses items,
+  including remote compaction and compaction summaries. Semantically ported from
+  [can1357/oh-my-pi#7743](https://github.com/can1357/oh-my-pi/pull/7743) and
+  [#10415](https://github.com/can1357/oh-my-pi/pull/10415)
+  ([#3721](https://github.com/f5-sales-demo/xcsh/issues/3721)).
+- Extended rate-limit handling to keep API-key credentials blocked until their live usage reset
+  and to understand absolute English and Chinese reset timestamps. Semantically ported from
+  [can1357/oh-my-pi#10325](https://github.com/can1357/oh-my-pi/pull/10325)
+  ([#3721](https://github.com/f5-sales-demo/xcsh/issues/3721)).
 - Prevented case-insensitive Windows environment lookup from replacing literal stored credentials,
   and delayed Cursor success until the HTTP/2/CONNECT protocol terminates cleanly so late stream
   errors remain visible. Semantically ported from

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/pi-ai",
-	"version": "21.13.1",
+	"version": "21.13.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -46,7 +46,7 @@
 		"@anthropic-ai/sdk": "^0.115",
 		"@aws-sdk/client-bedrock-runtime": "^3",
 		"@bufbuild/protobuf": "^2.11",
-		"@f5-sales-demo/pi-utils": "21.13.1",
+		"@f5-sales-demo/pi-utils": "21.13.2",
 		"@google/genai": "^2.15",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",

package/src/auth-storage.ts

@@ -1015,7 +1015,10 @@ export class AuthStorage {
 	// Queries provider usage endpoints to detect rate limits before they occur.
 	// ─────────────────────────────────────────────────────────────────────────────
 
-	#buildUsageCredential(credential: OAuthCredential): UsageCredential {
+	#buildUsageCredential(credential: AuthCredential): UsageCredential {
+		if (credential.type === "api_key") {
+			return { type: "api_key", apiKey: credential.key };
+		}
 		return {
 			type: "oauth",
 			accessToken: credential.access,
@@ -1417,11 +1420,11 @@ export class AuthStorage {
 
 	async #getUsageReport(
 		provider: Provider,
-		credential: OAuthCredential,
+		credential: AuthCredential,
 		options?: { baseUrl?: string; timeoutMs?: number },
 	): Promise<UsageReport | null> {
 		return this.#fetchUsageCached(
-			this.#buildUsageRequestForOauth(provider, credential, options?.baseUrl),
+			this.#buildUsageRequest(provider, this.#buildUsageCredential(credential), options?.baseUrl),
 			options?.timeoutMs ?? this.#usageRequestTimeoutMs,
 		);
 	}
@@ -1510,15 +1513,13 @@ export class AuthStorage {
 		const now = Date.now();
 		let blockedUntil = now + (options?.retryAfterMs ?? AuthStorage.#defaultBackoffMs);
 
-		if (sessionCredential.type === "oauth" && this.#rankingStrategyResolver?.(provider)) {
+		if (this.#rankingStrategyResolver?.(provider)) {
 			const credential = this.#getCredentialsForProvider(provider)[sessionCredential.index];
-			if (credential?.type === "oauth") {
+			if (credential?.type === sessionCredential.type) {
 				const report = await this.#getUsageReport(provider, credential, options);
 				if (report && this.#isUsageLimitReached(report)) {
-					const resetAtMs = this.#getUsageResetAtMs(report, Date.now());
-					if (resetAtMs && resetAtMs > blockedUntil) {
-						blockedUntil = resetAtMs;
-					}
+					const resetAtMs = this.#getUsageResetAtMs(report, now);
+					if (resetAtMs && resetAtMs > blockedUntil) blockedUntil = resetAtMs;
 				}
 			}
 		}

package/src/utils/retry-after.ts

@@ -1,6 +1,31 @@
 export type HeadersLike = Headers | Record<string, string | undefined> | undefined | null;
 
 const RETRY_AFTER_HINT = "retry-after-ms=";
+const RETRY_AFTER_MS_BODY_PATTERN = /\bretry-after-ms\s*[:=]\s*([0-9]+)\b/i;
+const WILL_RESET_AT_PATTERN =
+	/(?:will\s+)?reset at\s+([0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:Z|[+-][0-9]{2}:?[0-9]{2})?)/i;
+const CN_RESET_AT_PATTERN = /将在\s*([0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]{2}:[0-9]{2}:[0-9]{2})\s*重置/;
+
+/** Parse body-level retry hints that are not represented by HTTP headers. */
+export function getRetryAfterMsFromErrorText(message: string): number | undefined {
+	const retryAfterMsMatch = RETRY_AFTER_MS_BODY_PATTERN.exec(message);
+	if (retryAfterMsMatch?.[1]) {
+		const milliseconds = Number(retryAfterMsMatch[1]);
+		if (Number.isFinite(milliseconds) && milliseconds > 0) return milliseconds;
+	}
+
+	for (const pattern of [WILL_RESET_AT_PATTERN, CN_RESET_AT_PATTERN]) {
+		const match = pattern.exec(message);
+		if (!match?.[1]) continue;
+		const normalized = match[1].replace(" ", "T");
+		const timestamp = /(?:Z|[+-][0-9]{2}:?[0-9]{2})$/i.test(normalized) ? normalized : `${normalized}Z`;
+		const resetAt = Date.parse(timestamp);
+		const delay = resetAt - Date.now();
+		if (!Number.isNaN(resetAt) && delay > 0) return delay;
+	}
+
+	return undefined;
+}
 
 export function formatErrorMessageWithRetryAfter(error: unknown, headers?: HeadersLike): string {
 	const message = error instanceof Error ? error.message : JSON.stringify(error);

package/src/utils.ts

@@ -65,12 +65,42 @@ export function truncateResponseItemId(id: string, prefix: string): string {
 	return `${prefix}_${Bun.hash(id).toString(36)}`;
 }
 
+/**
+ * Remove response-only lifecycle state from item types that reject it when
+ * replayed as OpenAI Responses input. The original array and untouched item
+ * identities are preserved when no change is needed.
+ */
+export function stripOpenAIResponsesOutputOnlyStatusesForReplay<TItem extends { type?: unknown; status?: unknown }>(
+	items: TItem[],
+): TItem[] {
+	let sanitized: TItem[] | undefined;
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index]!;
+		const rejectsOutputStatus =
+			item.type === "message" ||
+			item.type === "function_call" ||
+			item.type === "custom_tool_call" ||
+			item.type === "compaction" ||
+			item.type === "compaction_summary";
+		if (!rejectsOutputStatus || !Object.hasOwn(item, "status")) {
+			sanitized?.push(item);
+			continue;
+		}
+		if (!sanitized) sanitized = items.slice(0, index);
+		const withoutStatus = { ...item };
+		delete withoutStatus.status;
+		sanitized.push(withoutStatus);
+	}
+	return sanitized ?? items;
+}
+
 export function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record<string, unknown>>): ResponseInput {
 	const normalizedCallIds = new Map<string, string>();
-	return items.flatMap(item => {
+	const sanitized = items.flatMap(item => {
 		const sanitized = sanitizeOpenAIResponsesHistoryItemForReplay(item, normalizedCallIds);
 		return sanitized ? [sanitized] : [];
 	});
+	return stripOpenAIResponsesOutputOnlyStatusesForReplay(sanitized);
 }
 
 function sanitizeOpenAIResponsesHistoryItemForReplay(