@oh-my-pi/pi-ai 18.2.0 → 18.2.2

package/src/utils/openai-http.ts

@@ -14,7 +14,7 @@
  *   captured response body for the strict-tools fallback and the responses
  *   chain-state detectors, which regex over `error.message`.
  */
-import { fetchWithRetry, readSseJson, type SseEventObserver } from "@oh-my-pi/pi-utils";
+import { fetchWithRetry, readSseJsonOrText, type SseEventObserver } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import { OpenAIHttpError } from "../error";
 
@@ -68,6 +68,8 @@ export interface OpenAIStreamRequestInit {
 	body: unknown;
 	signal: AbortSignal;
 	fetch?: FetchImpl;
+	/** Optional caller-specific gate composed with shared transport retry exclusions. */
+	shouldRetryResponse?: (response: Response, bodyText: string) => boolean | Promise<boolean>;
 	/** Raw wire-frame observer (`onSseEvent` debug pipeline). */
 	onSseEvent?: SseEventObserver;
 }
@@ -98,7 +100,9 @@ export async function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): P
 		// A proxy concurrency-admission 429 (`rate_limit_type: max_parallel_requests`)
 		// surfaces immediately instead of being slept-and-retried here; session
 		// recovery owns its backoff/fallback (issue #8854).
-		shouldRetryResponse: (response, bodyText) => !isConcurrencyAdmissionRejection(response, bodyText),
+		shouldRetryResponse: async (response, bodyText) =>
+			!isConcurrencyAdmissionRejection(response, bodyText) &&
+			(init.shouldRetryResponse === undefined || (await init.shouldRetryResponse(response, bodyText))),
 		// 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.
@@ -113,12 +117,44 @@ export async function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): P
 		});
 	}
 	return {
-		events: readSseJson<TEvent>(response.body, init.signal, init.onSseEvent),
+		events: decodeStream<TEvent>(response.body, init.signal, init.onSseEvent),
 		response,
 		requestId: response.headers.get("x-request-id"),
 	};
 }
 
+/**
+ * Consume `readSseJsonOrText` and turn a non-JSON `data:` frame into a
+ * classified in-band error. A reverse proxy that already committed to an HTTP
+ * 200 stream (so the status line can no longer carry the failure) answers with
+ * plain text — `data: 429 Too Many Requests`, an nginx throttle page — and
+ * that has to advance the fallback chain like a real 429 (body-error.ts).
+ * Frames that are not recognisable throttles rethrow the original parse error,
+ * preserving the pre-existing loud failure for genuinely malformed payloads.
+ * `readSseJsonOrText` also yields a frame that was a JSON-encoded *string* on the
+ * wire (a double-encoded proxy error page); it is not a usable event either, so
+ * it is classified the same way and then dropped — every consumer here already
+ * ignored a string chunk, the completions loop by its `typeof !== "object"` test.
+ */
+async function* decodeStream<TEvent>(
+	body: ReadableStream<Uint8Array>,
+	signal: AbortSignal | undefined,
+	onSseEvent: SseEventObserver | undefined,
+): AsyncGenerator<TEvent> {
+	for await (const frame of readSseJsonOrText<TEvent>(body, signal, onSseEvent)) {
+		if (typeof frame === "string") {
+			const inBand = AIError.createInBandProviderErrorFromText(frame);
+			if (inBand) throw inBand;
+			// Not a recognisable throttle: reproduce the exact strict-parse failure the
+			// previous reader raised, so genuinely malformed payloads stay equally
+			// loud. A frame that parses again was a JSON string, not a malformed one.
+			JSON.parse(frame);
+			continue;
+		}
+		yield frame;
+	}
+}
+
 /** Decode a non-2xx response into an {@link OpenAIHttpError} without consuming it twice. */
 export async function captureOpenAIHttpError(response: Response): Promise<AIError.OpenAIHttpError> {
 	let bodyText: string | undefined;

package/src/utils/retry-after.ts

@@ -1,5 +1,17 @@
+import { retryResetTimezoneOffsetFor } from "@oh-my-pi/pi-catalog/compat/behavior";
+import { extractRetryHint } from "@oh-my-pi/pi-utils";
+
 export type HeadersLike = Headers | Record<string, string | undefined> | undefined | null;
 
+/** Extracts retry timing using the provider's catalog-declared timestamp timezone. */
+export function extractProviderRetryHint(
+	provider: string | undefined,
+	message: string | undefined,
+): number | undefined {
+	const naiveResetTimezoneOffset = provider === undefined ? undefined : retryResetTimezoneOffsetFor(provider);
+	return extractRetryHint(undefined, message, { naiveResetTimezoneOffset });
+}
+
 const RETRY_AFTER_HINT = "retry-after-ms=";
 
 export function formatErrorMessageWithRetryAfter(error: unknown, headers?: HeadersLike): string {

package/src/utils/schema/normalize.ts

@@ -1877,9 +1877,9 @@ function inferStrictPrimitiveTypeFromEnumOrConst(node: Record<string, unknown>):
 }
 
 /**
- * Per-schema-object memoization slot. The result of `tryEnforceStrictSchema`
- * is stamped directly onto the input via `stamp(target, kStrictSchema, …)`
- * so repeated calls (different providers, retries, batching) reuse the same
+ * Per-schema-object memoization key. The result of `tryEnforceStrictSchema`
+ * is memoized against the input via `stamp(target, kStrictSchema, …)` so
+ * repeated calls (different providers, retries, batching) reuse the same
  * computed pair without re-walking the tree.
  */
 const kStrictSchema = Symbol("pi.schema.strict");

package/src/utils/schema/stamps.ts

@@ -1,38 +1,39 @@
 /**
- * Symbol-keyed lazy memoization stamped directly onto the host object.
+ * Lazy memoization keyed by host object identity, held in a module-level
+ * weak side table.
  *
- * Faster than a module-level `WeakMap` in V8/JSC because the symbol slot is
- * resolved through the object's hidden class instead of a side-table hash
- * lookup. The slot is defined as a non-enumerable property so the stamp
- * does not leak through `{...spread}`, `Object.keys`, `JSON.stringify`, or
- * `toEqual`-style deep equality.
+ * The bookkeeping deliberately lives outside the host rather than in a
+ * non-enumerable symbol property: schema objects are caller-owned and may be
+ * sealed, frozen, or deep-frozen after their first traversal. A recursive
+ * freeze that enumerates with `Reflect.ownKeys` reaches symbol slots, so an
+ * on-host slot would be frozen along with the schema and every later write
+ * would throw. A side table is also invisible to `{...spread}`,
+ * `Object.keys`, `JSON.stringify`, and `toEqual`-style deep equality.
  *
- * Caveats: the stamp lives as long as the host object, even after callers
+ * Caveats: an entry lives as long as the host object, even after callers
  * release their references to the cached value — only use this for caches
- * whose lifetime should match the host. Frozen hosts cannot be stamped;
- * `define` silently skips them, so memoization/visit-tracking degrades to
- * best-effort (recompute on every call, no cycle protection) instead of
- * throwing.
+ * whose lifetime should match the host.
  */
-function define<T extends object>(target: T, key: symbol, value: unknown): void {
-	if (Object.isFrozen(target)) return;
-	Object.defineProperty(target, key, { value, writable: true, configurable: true });
-}
+const memos = new WeakMap<object, Map<symbol, unknown>>();
 
 export function stamp<T extends object, V>(target: T, key: symbol, compute: (target: T) => V): V {
-	const slot = target as Record<symbol, V | undefined>;
-	const existing = slot[key];
+	let slots = memos.get(target);
+	if (!slots) {
+		slots = new Map();
+		memos.set(target, slots);
+	}
+	const existing = slots.get(key) as V | undefined;
 	if (existing !== undefined) return existing;
 	const value = compute(target);
-	define(target, key, value);
+	slots.set(key, value);
 	return value;
 }
 
 /**
- * Epoch-keyed cycle guard. Cheaper than `WeakSet` for recursive traversal
- * because the marker is a single property slot on the host object, written
- * once and overwritten in place on every subsequent traversal — the hidden
- * class transitions once per object lifetime, not per traversal.
+ * Epoch-keyed cycle guard. Cheaper than a per-call `WeakSet` for recursive
+ * traversal because the marker is a single side-table entry per host object,
+ * written once and overwritten in place on every subsequent traversal — no
+ * per-walk allocation.
  *
  * Usage:
  *   function walk(node, epoch = epochNext()) {
@@ -40,7 +41,7 @@ export function stamp<T extends object, V>(target: T, key: symbol, compute: (tar
  *     for (const child of node.children) walk(child, epoch);
  *   }
  */
-const kEpoch = Symbol("pi.schema.epoch");
+const epochs = new WeakMap<object, number>();
 let __epoch = 0;
 
 export function epochNext(): number {
@@ -53,11 +54,9 @@ export function epochNext(): number {
  * subsequent call within the same epoch.
  */
 export function once<T extends object>(target: T, epoch: number): boolean {
-	const slot = target as Record<symbol, number | undefined>;
-	const cur = slot[kEpoch];
+	const cur = epochs.get(target);
 	if (cur !== undefined && cur >= epoch) return false;
-	if (cur === undefined) define(target, kEpoch, epoch);
-	else slot[kEpoch] = epoch;
+	epochs.set(target, epoch);
 	return true;
 }
 
@@ -65,13 +64,9 @@ export function once<T extends object>(target: T, epoch: number): boolean {
  * Counter-based path tracker. Use when a traversal needs to distinguish
  * "currently on the recursion path" from "previously visited" — i.e. cycle
  * detection that throws while still allowing DAG sharing. Increment on
- * entry, decrement on exit; the slot returns to 0 after a balanced walk so
+ * entry, decrement on exit; the counter returns to 0 after a balanced walk so
  * subsequent top-level calls see a fresh state without any reset.
  *
- * Unlike a `WeakSet` with `seen.delete(...)`, the property is never deleted
- * — only incremented and decremented — so the host object's hidden class
- * is never invalidated.
- *
  * Usage:
  *   function walk(node) {
  *     if (!enter(node)) throw new Error("cycle");
@@ -79,7 +74,7 @@ export function once<T extends object>(target: T, epoch: number): boolean {
  *     finally { exit(node); }
  *   }
  */
-const kDepth = Symbol("pi.schema.depth");
+const depths = new WeakMap<object, number>();
 
 /**
  * Returns `true` on first entry, `false` if `target` is already on the
@@ -89,21 +84,14 @@ const kDepth = Symbol("pi.schema.depth");
  * make every later top-level walk of the same object misreport a cycle.
  */
 export function enter<T extends object>(target: T): boolean {
-	const slot = target as Record<symbol, number | undefined>;
-	const cur = slot[kDepth];
-	if (cur === undefined) {
-		define(target, kDepth, 1);
-		return true;
-	}
-	if (cur !== 0) return false;
-	slot[kDepth] = 1;
+	const cur = depths.get(target);
+	if (cur !== undefined && cur !== 0) return false;
+	depths.set(target, 1);
 	return true;
 }
 
 export function exit<T extends object>(target: T): void {
-	const slot = target as Record<symbol, number | undefined>;
-	const cur = slot[kDepth];
-	// Frozen targets never received the kDepth stamp in `enter` — nothing to unwind.
+	const cur = depths.get(target);
 	if (cur === undefined) return;
-	slot[kDepth] = cur - 1;
+	depths.set(target, cur - 1);
 }

package/src/utils/schema/wire.ts

@@ -7,6 +7,7 @@
  */
 
 import type { Type } from "@oh-my-pi/omptype";
+import { structuredCloneJSON } from "@oh-my-pi/pi-utils";
 import type { Tool, TSchema } from "../../types";
 import { upgradeJsonSchemaTo202012 } from "./draft";
 import { stamp } from "./stamps";
@@ -107,7 +108,7 @@ function arkJsonAstToWire(value: unknown): unknown {
 	return {};
 }
 
-/** Symbol-stamped caches keyed by schema object identity. */
+/** `stamp` cache keys; the entries themselves live in a weak side table keyed by schema identity. */
 const kJsonWireSchema = Symbol("pi.schema.json.wire");
 const kArkWireSchema = Symbol("pi.schema.ark.wire");
 const kStrippedSchema = Symbol("pi.schema.descriptions.stripped");
@@ -602,7 +603,9 @@ export function toolWireSchema(tool: Tool): Record<string, unknown> {
 	const params: TSchema = tool.parameters;
 	if (isArkSchema(params)) return arkToWireSchema(params);
 	return stamp(params as Record<string, unknown>, kJsonWireSchema, p => {
-		const raw = isArkJsonAst(p) ? arkJsonAstToWire(p) : p;
+		// Legacy schemas may carry non-cloneable metadata (helper functions); the JSON
+		// fallback drops it the same way the wire serializer always has.
+		const raw = isArkJsonAst(p) ? arkJsonAstToWire(p) : structuredCloneJSON(p);
 		const upgraded = upgradeJsonSchemaTo202012(raw) as Record<string, unknown>;
 		return postProcessJsonSchema(upgraded);
 	});
@@ -663,10 +666,9 @@ function stripSchemaDescriptionsInPlace(node: unknown): void {
 
 /**
  * Return a deep clone of `schema` with every `description` annotation removed.
- * The result is memoized on the input via a non-enumerable symbol (`stamp`) so
- * repeated provider requests reuse the same stripped object; the input is never
- * mutated, so the stamped `toolWireSchema` cache stays intact for
- * system-prompt/UI rendering.
+ * The result is memoized against the input (`stamp`) so repeated provider
+ * requests reuse the same stripped object; the input is never mutated, so the
+ * memoized `toolWireSchema` result stays intact for system-prompt/UI rendering.
  */
 export function stripSchemaDescriptions(schema: Record<string, unknown>): Record<string, unknown> {
 	return stamp(schema, kStrippedSchema, source => {
@@ -682,7 +684,7 @@ export function stripSchemaDescriptions(schema: Record<string, unknown>): Record
  * Used when the full tool catalog is rendered into the system prompt instead, so
  * the descriptions ride the wire once (in the prompt) rather than duplicated on
  * every tool definition. Parameters are resolved to wire JSON Schema and cloned,
- * leaving the original tool objects and the stamped schema cache untouched.
+ * leaving the original tool objects and the memoized schema cache untouched.
  */
 export function stripToolDescriptions(tools: readonly Tool[]): Tool[] {
 	return tools.map(tool => ({

package/src/utils.ts

@@ -45,8 +45,10 @@ export function normalizeResponsesToolCallId(
 	id: string,
 	itemPrefix: ResponsesToolItemIdPrefix = "fc",
 ): { callId: string; itemId: string } {
-	const [callId, itemId] = id.split("|");
-	if (callId && itemId) {
+	const sep = id.search(/[\n|]/);
+	if (sep > 0) {
+		const callId = id.slice(0, sep);
+		const itemId = id.slice(sep + 1);
 		return { callId, itemId: normalizeResponsesItemId(itemId, itemPrefix) };
 	}
 	const hash = Bun.hash(id).toString(36);
@@ -324,6 +326,15 @@ export function stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay(items:
  * 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.
+ *
+ * When the turn does carry replayable output, whitespace-only assistant
+ * messages are dropped rather than replayed. gpt-5.6 Codex ends a turn whose
+ * text all landed in the `commentary` phase with an empty `final_answer`
+ * message; replaying that item verbatim seeds the next turn with an empty slot
+ * the model then fills - `""` → `"\n\n"` → stray words → non-Latin residue -
+ * and each contaminated item is replayed in turn, so the drift compounds until
+ * the visible answer collapses. Codex CLI replays the empty item too
+ * (openai/codex#32389); this is the layer where omp can refuse to.
  */
 export function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(
 	items: Array<Record<string, unknown>>,
@@ -331,34 +342,68 @@ export function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(
 ): ResponseInput | undefined {
 	const sanitized = sanitizeOpenAIResponsesHistoryItemsForReplay(items, options);
 	let hasReplayableAssistantOutput = false;
+	let hasEmptyAssistantMessage = false;
 
 	for (const item of sanitized) {
 		if (item.type === "reasoning") continue;
-		if (item.type !== "message" || item.role !== "assistant") {
-			hasReplayableAssistantOutput = true;
-			break;
+		if (isEmptyAssistantMessage(item)) {
+			hasEmptyAssistantMessage = true;
+			continue;
 		}
-		if (typeof item.content === "string") {
-			if (NON_WHITESPACE_RE.test(item.content)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
+		hasReplayableAssistantOutput = true;
+	}
+
+	if (!hasReplayableAssistantOutput) return undefined;
+	if (!hasEmptyAssistantMessage) return sanitized;
+	return dropEmptyAssistantMessagesForReplay(sanitized);
+}
+
+function isEmptyAssistantMessage(item: OpenAIResponsesReplayItem): boolean {
+	if (item.type !== "message" || item.role !== "assistant") return false;
+	if (typeof item.content === "string") return !NON_WHITESPACE_RE.test(item.content);
+	for (const part of item.content) {
+		if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) return false;
+		if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) return false;
+	}
+	return true;
+}
+
+/**
+ * Remove whitespace-only assistant messages plus any reasoning item left with
+ * no output to introduce: a reasoning item is only meaningful ahead of the
+ * output it produced, and a dangling one is rejected by the Responses API when
+ * it carries an id.
+ */
+function dropEmptyAssistantMessagesForReplay(items: ResponseInput): ResponseInput {
+	const kept: ResponseInput = [];
+	let pendingReasoning: ResponseInput = [];
+	let removedAssistantMessage = false;
+	const flushReasoning = (): void => {
+		kept.push(...pendingReasoning);
+		pendingReasoning = [];
+	};
+	for (const item of items) {
+		if (isOpenAIResponsesClientInputBoundary(item as unknown as Record<string, unknown>)) {
+			pendingReasoning = [];
+			removedAssistantMessage = false;
+			kept.push(item);
 			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 (item.type === "reasoning") {
+			if (removedAssistantMessage) pendingReasoning = [];
+			removedAssistantMessage = false;
+			pendingReasoning.push(item);
+			continue;
 		}
-		if (hasReplayableAssistantOutput) break;
+		if (isEmptyAssistantMessage(item)) {
+			removedAssistantMessage = true;
+			continue;
+		}
+		flushReasoning();
+		removedAssistantMessage = false;
+		kept.push(item);
 	}
-
-	return hasReplayableAssistantOutput ? sanitized : undefined;
+	return kept;
 }
 
 /**