@oh-my-pi/pi-ai 16.3.6 → 16.3.7

package/src/utils/openai-http.ts

@@ -24,8 +24,11 @@ import type { FetchImpl } from "../types";
 import type { CapturedHttpErrorResponse } from "./http-inspector";
 
 /**
- * Total attempts when the caller has no first-event deadline armed. The
- * removed SDK clients ran `maxRetries: 5`, i.e. 6 requests.
+ * Total attempts (initial + retries). Parity with the removed SDK clients'
+ * `maxRetries: 5`, i.e. 6 requests. Callers arming a first-event watchdog
+ * stay bounded: the watchdog aborts the request `signal`, which
+ * `fetchWithRetry` races on every attempt and every backoff sleep, so
+ * transient 408/429/5xx retries can never extend the caller's deadline.
  */
 const DEFAULT_MAX_ATTEMPTS = 6;
 
@@ -39,12 +42,6 @@ export interface OpenAIStreamRequestInit {
 	body: unknown;
 	signal: AbortSignal;
 	fetch?: FetchImpl;
-	/**
-	 * Total attempts (initial + retries). Defaults to {@link DEFAULT_MAX_ATTEMPTS}.
-	 * Pass `1` when a first-event watchdog is armed so retries cannot silently
-	 * extend the caller's deadline (mirrors the old `maxRetries: 0` hint).
-	 */
-	maxAttempts?: number;
 	/** Raw wire-frame observer (`onSseEvent` debug pipeline). */
 	onSseEvent?: SseEventObserver;
 }
@@ -71,7 +68,7 @@ export async function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): P
 		body: JSON.stringify(init.body),
 		signal: init.signal,
 		fetch: init.fetch,
-		maxAttempts: init.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+		maxAttempts: DEFAULT_MAX_ATTEMPTS,
 		// Bun's native fetch enforces a hard ~300s pre-response timeout (issue #2422).
 		// Cold large-context streams legitimately exceed it; the caller's
 		// `firstEventTimeoutMs`/`AbortSignal` already govern stuck requests.

package/src/utils/retry-after.ts

@@ -19,11 +19,14 @@ export function formatErrorMessageWithRetryAfter(error: unknown, headers?: Heade
 export function getRetryAfterMsFromHeaders(headers: HeadersLike): number | undefined {
 	if (!headers) return undefined;
 
+	const retryAfterMs = parseRetryAfterMsHeader(getHeaderValue(headers, "retry-after-ms"));
 	const retryAfter = parseRetryAfterHeader(getHeaderValue(headers, "retry-after"));
 	const resetMs = parseResetHeader(getHeaderValue(headers, "x-ratelimit-reset-ms"), "ms");
 	const resetSeconds = parseResetHeader(getHeaderValue(headers, "x-ratelimit-reset"), "s");
 
-	const candidates = [retryAfter, resetMs, resetSeconds].filter((value): value is number => value !== undefined);
+	const candidates = [retryAfterMs, retryAfter, resetMs, resetSeconds].filter(
+		(value): value is number => value !== undefined,
+	);
 	if (candidates.length === 0) return undefined;
 	return Math.max(...candidates);
 }
@@ -59,6 +62,14 @@ function getHeaderValue(headers: Headers | Record<string, string | undefined>, n
 	return undefined;
 }
 
+/** `retry-after-ms` (Anthropic-style): a plain millisecond delta. */
+function parseRetryAfterMsHeader(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const ms = Number(value.trim());
+	if (!Number.isFinite(ms) || ms <= 0) return undefined;
+	return Math.ceil(ms);
+}
+
 function parseRetryAfterHeader(value: string | undefined): number | undefined {
 	if (!value) return undefined;
 	const trimmed = value.trim();

package/src/utils.ts

@@ -3,6 +3,7 @@ import type { ResponseInput, ResponseInputItem } from "./providers/openai-respon
 import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types";
 
 type OpenAIResponsesReplayItem = ResponseInput[number];
+const NON_WHITESPACE_RE = /\S/;
 
 export { isRecord } from "@oh-my-pi/pi-utils";
 export function normalizeSystemPrompts(systemPrompt: readonly string[] | string | undefined | null): string[] {
@@ -72,6 +73,83 @@ export function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record
 	});
 }
 
+/**
+ * Sanitize assistant-native Responses history for replay.
+ *
+ * Returns `undefined` for hidden-empty turns that only contain reasoning and an
+ * empty assistant message, allowing callers to rebuild visible transcript
+ * history instead of replaying stale native state.
+ */
+export function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(
+	items: Array<Record<string, unknown>>,
+): ResponseInput | undefined {
+	const sanitized = sanitizeOpenAIResponsesHistoryItemsForReplay(items);
+	let hasReplayableAssistantOutput = false;
+
+	for (const item of sanitized) {
+		if (item.type === "reasoning") continue;
+		if (item.type !== "message" || item.role !== "assistant") {
+			hasReplayableAssistantOutput = true;
+			break;
+		}
+		if (typeof item.content === "string") {
+			if (NON_WHITESPACE_RE.test(item.content)) {
+				hasReplayableAssistantOutput = true;
+				break;
+			}
+			continue;
+		}
+		for (const part of item.content) {
+			if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) {
+				hasReplayableAssistantOutput = true;
+				break;
+			}
+			if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) {
+				hasReplayableAssistantOutput = true;
+				break;
+			}
+		}
+		if (hasReplayableAssistantOutput) break;
+	}
+
+	return hasReplayableAssistantOutput ? sanitized : undefined;
+}
+
+/**
+ * Drop hidden-only fallback assistant replay after a native Responses snapshot is rejected.
+ */
+export function sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(items: ResponseInput): ResponseInput {
+	const sanitized: ResponseInput = [];
+
+	for (const item of items) {
+		if (item.type === "reasoning") continue;
+		if (item.type !== "message" || item.role !== "assistant") {
+			sanitized.push(item);
+			continue;
+		}
+
+		let hasVisibleText = false;
+		if (typeof item.content === "string") {
+			hasVisibleText = NON_WHITESPACE_RE.test(item.content);
+		} else {
+			for (const part of item.content) {
+				if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) {
+					hasVisibleText = true;
+					break;
+				}
+				if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) {
+					hasVisibleText = true;
+					break;
+				}
+			}
+		}
+
+		if (hasVisibleText) sanitized.push(item);
+	}
+
+	return sanitized;
+}
+
 function sanitizeOpenAIResponsesHistoryItemForReplay(
 	item: Record<string, unknown>,
 	normalizedCallIds: Map<string, string>,