@gajae-code/ai 0.17.2 → 0.17.5

package/src/providers/transform-messages.ts

@@ -85,6 +85,59 @@ function collapseAdjacentThinking<T extends { type: string }>(content: T[]): T[]
 	return dropped ? collapsed : content;
 }
 
+const MIN_CROSS_MODEL_THINKING_REPEAT_COUNT = 64;
+const MIN_CROSS_MODEL_THINKING_REPEAT_SAVED_CHARACTERS = 4_096;
+
+/**
+ * Bound pathological cross-model reasoning replay without editing the stored
+ * thinking block. Only exact adjacent non-empty paragraphs qualify, and the
+ * threshold requires both a large run and substantial net savings.
+ */
+function compressRepeatedThinkingParagraphs(thinking: string): string {
+	const parts = thinking.split(/(\r?\n(?:[ \t]*\r?\n)+)/);
+	const compressedParts: string[] = [];
+	let compressed = false;
+
+	for (let paragraphIndex = 0; paragraphIndex < parts.length; ) {
+		const paragraph = parts[paragraphIndex];
+		let runEnd = paragraphIndex;
+		while (runEnd + 2 < parts.length && parts[runEnd + 2] === paragraph) {
+			runEnd += 2;
+		}
+
+		const repeatCount = (runEnd - paragraphIndex) / 2 + 1;
+		let marker: string | undefined;
+		let savedCharacters = 0;
+		if (paragraph.length > 0 && repeatCount >= MIN_CROSS_MODEL_THINKING_REPEAT_COUNT) {
+			marker = `[Repeated paragraph occurred exactly ${repeatCount} consecutive times; only its first occurrence is shown.]`;
+			savedCharacters = (repeatCount - 1) * paragraph.length - marker.length;
+			for (let separatorIndex = paragraphIndex + 3; separatorIndex < runEnd; separatorIndex += 2) {
+				savedCharacters += parts[separatorIndex].length;
+			}
+		}
+
+		if (marker !== undefined && savedCharacters >= MIN_CROSS_MODEL_THINKING_REPEAT_SAVED_CHARACTERS) {
+			compressedParts.push(paragraph);
+			if (paragraphIndex + 1 < parts.length) compressedParts.push(parts[paragraphIndex + 1]);
+			compressedParts.push(marker);
+			compressed = true;
+		} else {
+			for (let partIndex = paragraphIndex; partIndex <= runEnd; partIndex++) {
+				compressedParts.push(parts[partIndex]);
+			}
+		}
+
+		// The separator after the run belongs to the next paragraph and must
+		// survive verbatim, regardless of whether this run was compressed.
+		if (runEnd + 1 < parts.length) {
+			compressedParts.push(parts[runEnd + 1]);
+		}
+		paragraphIndex = runEnd + 2;
+	}
+
+	return compressed ? compressedParts.join("") : thinking;
+}
+
 export function transformMessages<TApi extends Api>(
 	messages: Message[],
 	model: Model<TApi>,
@@ -170,7 +223,7 @@ export function transformMessages<TApi extends Api>(
 					if (isSameModel) return sanitized;
 					return {
 						type: "text" as const,
-						text: sanitized.thinking,
+						text: compressRepeatedThinkingParagraphs(sanitized.thinking),
 					};
 				}
 

package/src/stream.ts

@@ -500,6 +500,9 @@ export async function complete<TApi extends Api>(
 	options?: OptionsForApi<TApi>,
 ): Promise<AssistantMessage> {
 	const s = stream(model, context, options);
+	for await (const _event of s) {
+		// Completion callers only need the terminal message, not buffered events.
+	}
 	return s.result();
 }
 
@@ -824,6 +827,9 @@ export async function completeSimple<TApi extends Api>(
 	options?: SimpleStreamOptions,
 ): Promise<AssistantMessage> {
 	const s = streamSimple(model, context, options);
+	for await (const _event of s) {
+		// Completion callers only need the terminal message, not buffered events.
+	}
 	return s.result();
 }
 
@@ -1113,6 +1119,7 @@ function mapOptionsForApi<TApi extends Api>(
 						: options?.disableReasoning,
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
 				serviceTier: options?.serviceTier,
+				repetitionGuard: options?.repetitionGuard,
 			});
 
 		case "openai-responses":

package/src/types.d.ts

@@ -338,6 +338,14 @@ export interface AttemptScopeRef {
     readonly generation: number;
     readonly lineage: string;
 }
+/**
+ * Runaway-repetition guard thresholds, per stream channel. A number sets the
+ * consecutive-repeat threshold; `false` disables that channel's guard.
+ */
+export interface RepetitionGuardOptions {
+    thinking?: number | false;
+    text?: number | false;
+}
 export interface SimpleStreamOptions extends StreamOptions {
     reasoning?: Effort;
     /**
@@ -373,6 +381,14 @@ export interface SimpleStreamOptions extends StreamOptions {
     syntheticApiFormat?: "openai" | "anthropic";
     /** Hint that websocket transport should be preferred when supported by the provider implementation. */
     preferWebsockets?: boolean;
+    /**
+     * Runaway-repetition guard thresholds, per stream channel. Honoured by the
+     * openai-completions transport; ignored by providers without a guard.
+     * Defaults: thinking = DEFAULT_REPETITION_THRESHOLD, text = false — visible
+     * output is a deliverable and intentional repetition there (logs, fixtures,
+     * tables, generated code) must survive byte for byte (#5627).
+     */
+    repetitionGuard?: RepetitionGuardOptions;
 }
 export type StreamFunction<TApi extends Api> = (model: Model<TApi>, context: Context, options: OptionsForApi<TApi>) => AssistantMessageEventStream;
 export interface TextSignatureV1 {

package/src/types.ts

@@ -556,6 +556,15 @@ export interface AttemptScopeRef {
 	readonly lineage: string;
 }
 
+/**
+ * Runaway-repetition guard thresholds, per stream channel. A number sets the
+ * consecutive-repeat threshold; `false` disables that channel's guard.
+ */
+export interface RepetitionGuardOptions {
+	thinking?: number | false;
+	text?: number | false;
+}
+
 // Unified options with reasoning passed to streamSimple() and completeSimple()
 export interface SimpleStreamOptions extends StreamOptions {
 	reasoning?: Effort;
@@ -592,6 +601,14 @@ export interface SimpleStreamOptions extends StreamOptions {
 	syntheticApiFormat?: "openai" | "anthropic";
 	/** Hint that websocket transport should be preferred when supported by the provider implementation. */
 	preferWebsockets?: boolean;
+	/**
+	 * Runaway-repetition guard thresholds, per stream channel. Honoured by the
+	 * openai-completions transport; ignored by providers without a guard.
+	 * Defaults: thinking = DEFAULT_REPETITION_THRESHOLD, text = false — visible
+	 * output is a deliverable and intentional repetition there (logs, fixtures,
+	 * tables, generated code) must survive byte for byte (#5627).
+	 */
+	repetitionGuard?: RepetitionGuardOptions;
 }
 
 // Generic StreamFunction with typed options

package/src/utils/discovery/openai-compatible.ts

@@ -5,6 +5,15 @@ import type { Api, FetchImpl, Model, Provider } from "../../types";
 import { toNumber } from "../../utils";
 
 const MODELS_PATH = "/models";
+
+/**
+ * Shared `/models` request deadline for setup-time probing and runtime
+ * discovery. One policy so an endpoint that passes setup validation cannot
+ * be unreachable under the runtime deadline (previously 10s vs 5s: a 6s
+ * endpoint passed setup, saved discovery-only config, then stayed
+ * unavailable at runtime with no recovery hint).
+ */
+export const MODELS_LIST_REQUEST_TIMEOUT_MS = 10_000;
 const MAX_MODELS_RESPONSE_BYTES = 1_000_000;
 const MAX_CATALOG_MODEL_ID_LENGTH = 200;
 
@@ -233,8 +242,8 @@ export async function fetchOpenAICompatibleModels<TApi extends Api>(
 			method: "GET",
 			headers: requestHeaders,
 			signal: options.signal
-				? AbortSignal.any([options.signal, AbortSignal.timeout(5_000)])
-				: AbortSignal.timeout(5_000),
+				? AbortSignal.any([options.signal, AbortSignal.timeout(MODELS_LIST_REQUEST_TIMEOUT_MS)])
+				: AbortSignal.timeout(MODELS_LIST_REQUEST_TIMEOUT_MS),
 		});
 	} catch {
 		return null;
@@ -308,6 +317,11 @@ export async function fetchOpenAICompatibleModels<TApi extends Api>(
 	return Array.from(deduped.values()).sort((left, right) => left.id.localeCompare(right.id));
 }
 
+/** Bounded JSON body reader for `/models` responses (shared by runtime and setup probe). */
+export async function readBoundedModelsJson(response: Response): Promise<unknown> {
+	return JSON.parse(await readModelsResponse(response));
+}
+
 async function readModelsResponse(response: Response): Promise<string> {
 	const contentLength = Number(response.headers.get("content-length"));
 	if (Number.isFinite(contentLength) && contentLength > MAX_MODELS_RESPONSE_BYTES) {

package/src/utils/fallback-transport.d.ts

@@ -43,6 +43,10 @@ export type TransportHeaders = Headers | Record<string, string | undefined>;
  */
 export interface TransportFailureFacts {
     kind: "transport";
+    /** Diagnostic HTTP/2 reset code; not HTTP status or retry authority. */
+    http2RstCode?: number;
+    /** Native HTTP/2 error code; diagnostic only, not retry authority. */
+    nativeErrorCode?: string;
     status?: number;
     /** Canonical provider error code used for fallback classification. */
     providerCode?: string;

package/src/utils/fallback-transport.ts

@@ -48,6 +48,10 @@ export type TransportHeaders = Headers | Record<string, string | undefined>;
  */
 export interface TransportFailureFacts {
 	kind: "transport";
+	/** Diagnostic HTTP/2 reset code; not HTTP status or retry authority. */
+	http2RstCode?: number;
+	/** Native HTTP/2 error code; diagnostic only, not retry authority. */
+	nativeErrorCode?: string;
 	status?: number;
 	/** Canonical provider error code used for fallback classification. */
 	providerCode?: string;
@@ -235,6 +239,9 @@ export function transportFailureFacts(
 	// (consumers deliberately re-run transportFailureFacts on embedded facts).
 	const headers = retainedHeaderRecord(rawHeaders);
 	const normalizedCode = providerCode?.toLowerCase();
+	const http2RstCode = finiteNonNegativeInteger(propertyOf(value, "http2RstCode"));
+	const nativeCode = stringValue(propertyOf(value, "nativeErrorCode")) ?? stringValue(propertyOf(value, "code"));
+	const nativeErrorCode = nativeCode && /^ERR_HTTP2_[A-Z_]+$/.test(nativeCode) ? nativeCode : undefined;
 	const requestBytes = finiteNonNegativeInteger(propertyOf(value, "requestBytes"));
 	const firstEventElapsedMs = finiteNonNegativeInteger(propertyOf(value, "firstEventElapsedMs"));
 	const firstEventTimeoutMs = finiteNonNegativeInteger(propertyOf(value, "firstEventTimeoutMs"));
@@ -244,6 +251,8 @@ export function transportFailureFacts(
 		endpointClassValue === "canonical" || endpointClassValue === "custom" ? endpointClassValue : undefined;
 	const credentialModelUnavailable = propertyOf(value, "credentialModelUnavailable") === true;
 	if (
+		http2RstCode === undefined &&
+		nativeErrorCode === undefined &&
 		status === undefined &&
 		headers === undefined &&
 		!isQuotaCode(normalizedCode) &&
@@ -268,6 +277,8 @@ export function transportFailureFacts(
 	}
 	return {
 		kind: "transport",
+		...(http2RstCode === undefined ? {} : { http2RstCode }),
+		...(nativeErrorCode === undefined ? {} : { nativeErrorCode }),
 		status,
 		providerCode,
 		anthropicErrorType,

package/src/utils/h2-fetch.ts

@@ -11,13 +11,14 @@
  * Some HTTPS endpoints (e.g. corporate API gateways behind reverse proxies)
  * advertise h2 via ALPN but then refuse or reset the connection at the HTTP/2
  * framing layer. Bun surfaces these as `ConnectionRefused`, `ConnectionReset`,
- * or `ConnectionClosed` rather than `HTTP2Unsupported`, so we treat those
- * codes as h2-fallback triggers as well. `ConnectionRefused` is raised before
- * the request is written, but a reset or a close does not prove the peer never
- * consumed the body — it may have processed the request and died before
- * answering. Replaying those two on h1 would duplicate the side effect, so
- * `ConnectionReset` and `ConnectionClosed` fall back only for replay-safe
- * methods; anything else rethrows the original error.
+ * `ConnectionClosed`, or `HTTP2StreamReset` rather than `HTTP2Unsupported`.
+ * `ConnectionRefused` is raised before the request is written, while
+ * `HTTP2RefusedStream` is the explicit HTTP/2 promise that a stream was never
+ * processed (including a stream above a graceful GOAWAY last-stream-id).
+ * `ConnectionReset`, `ConnectionClosed`, and a generic `HTTP2StreamReset` do
+ * not carry that promise: the peer may have consumed the body before the
+ * connection failed. Retrying those codes would duplicate non-idempotent side
+ * effects, so they preserve the original error instead of falling back.
  *
  * ALPN-refusing hosts (notably zcode.z.ai, the GLM ZCode OAuth broker) abort
  * the TLS handshake entirely when the client offers ALPN h2. Bun reports that
@@ -46,23 +47,21 @@ export function installH2Fetch(): void {
 	const h2FallbackCodes: ReadonlySet<string> = new Set([
 		"HTTP2Unsupported", // Server selected h1 in ALPN
 		"ConnectionRefused", // Server refused the h2 connection
-		"ConnectionReset", // Server reset during h2 handshake
-		"ConnectionClosed", // Server closed before h2 response
+		"HTTP2RefusedStream", // REFUSED_STREAM / never-processed h2 stream
 		// Bun's h2 client reports an ALPN-refusing host's TLS abort with this
 		// code; the h1 fallback below re-verifies the certificate itself.
 		"UNKNOWN_CERTIFICATE_VERIFICATION_ERROR",
 	]);
-	/** Fallback codes that may fire *after* the peer consumed the body — replay only when safe. */
-	const replayGatedCodes: ReadonlySet<string> = new Set(["ConnectionReset", "ConnectionClosed"]);
 	const wrapper = async function h2fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
 		if (!isHttps(input)) return original(input, init);
+		const snapshot = snapshotRequest(input, init);
 		try {
-			return await original(input, { ...init, protocol: "http2" });
+			return await original(snapshot.input, { ...snapshot.init, protocol: "http2" });
 		} catch (err) {
 			const code = (err as { code?: string }).code ?? "";
 			if (!h2FallbackCodes.has(code)) throw err;
-			if (replayGatedCodes.has(code) && !isReplaySafeRequest(input, init)) throw err;
-			return original(input, init);
+			if (code === "HTTP2RefusedStream" && !isReplayableRequest(snapshot.input, snapshot.init)) throw err;
+			return original(snapshot.input, snapshot.init);
 		}
 	} as typeof fetch & PatchedFetch;
 
@@ -72,19 +71,31 @@ export function installH2Fetch(): void {
 	globalThis.fetch = wrapper;
 }
 
-/** Methods a transport-layer retry cannot turn into a second side effect. */
-const replaySafeMethods: ReadonlySet<string> = new Set(["GET", "HEAD", "OPTIONS"]);
+function snapshotRequest(
+	input: string | URL | Request,
+	init?: RequestInit,
+): { input: string | URL | Request; init?: RequestInit } {
+	const snapshotInput = input instanceof URL ? new URL(input.href) : input;
+	const requestLike = typeof input !== "string" && !(input instanceof URL);
+	if (init === undefined && !requestLike) {
+		return { input: snapshotInput };
+	}
 
-/**
- * Whether replaying this request on a fresh connection is side-effect free.
- *
- * PR #5614 introduces an identically-named helper with the same semantics for
- * `HTTP2StreamReset`; whichever of the two lands second should collapse into
- * this one rather than leaving the repo with two devices doing the same job.
- */
-function isReplaySafeRequest(input: string | URL | Request, init?: RequestInit): boolean {
-	const method = init?.method ?? (input instanceof Request ? input.method : "GET");
-	return replaySafeMethods.has(method.toUpperCase());
+	const snapshotInit: RequestInit = { ...(init ?? {}) };
+	if (init?.headers !== undefined) {
+		snapshotInit.headers = snapshotHeaders(init.headers);
+	} else if (requestLike) {
+		snapshotInit.headers = new Headers(input.headers);
+	}
+	return { input: snapshotInput, init: snapshotInit };
+}
+
+function snapshotHeaders(headers: NonNullable<RequestInit["headers"]>): NonNullable<RequestInit["headers"]> {
+	if (headers instanceof Headers) return new Headers(headers);
+	if (Array.isArray(headers)) {
+		return headers.map(([name, value]) => [name, value] as [string, string]);
+	}
+	return { ...headers };
 }
 
 function isHttps(input: string | URL | Request): boolean {
@@ -92,3 +103,31 @@ function isHttps(input: string | URL | Request): boolean {
 	if (input instanceof URL) return input.protocol === "https:";
 	return input.url.startsWith("https:");
 }
+
+/**
+ * Whether the request body can be handed to fetch a second time. This is only
+ * used after `HTTP2RefusedStream`, which proves that the peer did not consume
+ * request bytes; a one-shot ReadableStream is still not reusable locally.
+ */
+function isReplayableRequest(input: string | URL | Request, init?: RequestInit): boolean {
+	try {
+		if (init?.body !== undefined) return isReplayableBody(init.body);
+		if (typeof input === "string" || input instanceof URL) return true;
+		// Request bodies are exposed as ReadableStreams. The same Request object
+		// cannot be used for the second fetch once the first attempt touched it.
+		return input.body === null;
+	} catch {
+		// Cross-realm or proxy Request objects may throw while exposing their
+		// method/body. Do not retry when replayability cannot be established.
+		return false;
+	}
+}
+
+function isReplayableBody(body: RequestInit["body"]): boolean {
+	if (body === null || typeof body === "string") return true;
+	if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+	// ArrayBuffer/views, FormData, and URLSearchParams are mutable caller-owned
+	// values. Fail closed instead of replaying a potentially changed payload if
+	// the asynchronous refusal arrives after the caller mutates one.
+	return false;
+}

package/src/utils/http-inspector.ts

@@ -43,6 +43,8 @@ const TRANSPORT_FAILURE_CODES: ReadonlySet<string> = new Set([
 	"ConnectionReset",
 	"ConnectionTimeout",
 	"FailedToOpenSocket",
+	"HTTP2RefusedStream",
+	"HTTP2StreamReset",
 	"HTTP2Unsupported",
 	"EAI_AGAIN",
 	"ECONNREFUSED",

package/src/utils/idle-iterator.ts

@@ -255,11 +255,19 @@ export async function* iterateWithIdleTimeout<T>(
 	const firstItemTimeoutMs = options.firstItemTimeoutMs ?? options.idleTimeoutMs;
 	const abortSignal = options.abortSignal;
 	const iterator = iterable[Symbol.asyncIterator]();
+	let naturallyExhausted = false;
+	let iteratorClosed = false;
 
 	const closeIterator = (): void => {
-		const returnPromise = iterator.return?.();
-		if (returnPromise) {
-			void returnPromise.catch(() => {});
+		if (iteratorClosed) return;
+		iteratorClosed = true;
+		try {
+			const returnPromise = iterator.return?.();
+			if (returnPromise) {
+				void returnPromise.catch(() => {});
+			}
+		} catch {
+			// Cleanup must not replace the source error or timeout that triggered it.
 		}
 	};
 
@@ -296,109 +304,114 @@ export async function* iterateWithIdleTimeout<T>(
 		(firstItemTimeoutMs === undefined || firstItemTimeoutMs <= 0) &&
 		(options.idleTimeoutMs === undefined || options.idleTimeoutMs <= 0);
 
-	while (true) {
-		let activeTimeoutMs: number | undefined;
-		if (awaitingFirstItem) {
-			activeTimeoutMs =
-				firstItemDeadlineAt === undefined ? undefined : Math.max(0, firstItemDeadlineAt - Date.now());
-		} else if (options.idleTimeoutMs !== undefined && options.idleTimeoutMs > 0) {
-			activeTimeoutMs = options.idleTimeoutMs - (Date.now() - lastProgressAt);
-			// The idle deadline may already have elapsed because the *consumer*
-			// was slow, not because the provider stalled — and the next item may
-			// already be buffered and ready to deliver. Clamp to 0 instead of
-			// throwing eagerly so the next() race below still gets a chance to
-			// win (it settles on a microtask, ahead of the 0ms timer). Only a
-			// genuinely hung iterator loses that race and surfaces as a stall.
-			if (activeTimeoutMs < 0) {
-				activeTimeoutMs = 0;
+	try {
+		while (true) {
+			let activeTimeoutMs: number | undefined;
+			if (awaitingFirstItem) {
+				activeTimeoutMs =
+					firstItemDeadlineAt === undefined ? undefined : Math.max(0, firstItemDeadlineAt - Date.now());
+			} else if (options.idleTimeoutMs !== undefined && options.idleTimeoutMs > 0) {
+				activeTimeoutMs = options.idleTimeoutMs - (Date.now() - lastProgressAt);
+				// The idle deadline may already have elapsed because the *consumer*
+				// was slow, not because the provider stalled — and the next item may
+				// already be buffered and ready to deliver. Clamp to 0 instead of
+				// throwing eagerly so the next() race below still gets a chance to
+				// win (it settles on a microtask, ahead of the 0ms timer). Only a
+				// genuinely hung iterator loses that race and surfaces as a stall.
+				if (activeTimeoutMs < 0) {
+					activeTimeoutMs = 0;
+				}
 			}
-		}
 
-		const racers: Array<
-			Promise<
-				| { kind: "next"; result: IteratorResult<T> }
-				| { kind: "error"; error: unknown }
-				| { kind: "timeout" }
-				| { kind: "abort" }
-			>
-		> = [];
+			const racers: Array<
+				Promise<
+					| { kind: "next"; result: IteratorResult<T> }
+					| { kind: "error"; error: unknown }
+					| { kind: "timeout" }
+					| { kind: "abort" }
+				>
+			> = [];
 
-		let timer: NodeJS.Timeout | undefined;
-		let resolveTimeout: ((value: { kind: "timeout" }) => void) | undefined;
-		const enforceTimeout = !noTimeoutEnforced && activeTimeoutMs !== undefined && activeTimeoutMs >= 0;
-		if (enforceTimeout) {
-			const { promise, resolve } = Promise.withResolvers<{ kind: "timeout" }>();
-			resolveTimeout = resolve;
-			timer = setTimeout(() => resolve({ kind: "timeout" }), activeTimeoutMs);
-			racers.push(promise);
-		}
+			let timer: NodeJS.Timeout | undefined;
+			let resolveTimeout: ((value: { kind: "timeout" }) => void) | undefined;
+			const enforceTimeout = !noTimeoutEnforced && activeTimeoutMs !== undefined && activeTimeoutMs >= 0;
+			if (enforceTimeout) {
+				const { promise, resolve } = Promise.withResolvers<{ kind: "timeout" }>();
+				resolveTimeout = resolve;
+				timer = setTimeout(() => resolve({ kind: "timeout" }), activeTimeoutMs);
+				racers.push(promise);
+			}
 
-		let abortListener: (() => void) | undefined;
-		let resolveAbort: ((value: { kind: "abort" }) => void) | undefined;
-		if (abortSignal) {
-			const { promise, resolve } = Promise.withResolvers<{ kind: "abort" }>();
-			resolveAbort = resolve;
-			abortListener = () => resolve({ kind: "abort" });
-			abortSignal.addEventListener("abort", abortListener, { once: true });
-			racers.push(promise);
-		}
+			let abortListener: (() => void) | undefined;
+			let resolveAbort: ((value: { kind: "abort" }) => void) | undefined;
+			if (abortSignal) {
+				const { promise, resolve } = Promise.withResolvers<{ kind: "abort" }>();
+				resolveAbort = resolve;
+				abortListener = () => resolve({ kind: "abort" });
+				abortSignal.addEventListener("abort", abortListener, { once: true });
+				racers.push(promise);
+			}
 
-		// Arm timeout/abort races before asking the source for its next item. A
-		// periodic keepalive iterator commonly registers its own timer inside
-		// `next()`; registering that first lets equal-deadline keepalives win every
-		// race and extend the idle window forever. Already-buffered items still
-		// settle as microtasks before a 0ms watchdog.
-		racers.unshift(withRacy(iterator.next()));
+			// Arm timeout/abort races before asking the source for its next item. A
+			// periodic keepalive iterator commonly registers its own timer inside
+			// `next()`; registering that first lets equal-deadline keepalives win every
+			// race and extend the idle window forever. Already-buffered items still
+			// settle as microtasks before a 0ms watchdog.
+			racers.unshift(withRacy(iterator.next()));
 
-		try {
-			const outcome = await Promise.race(racers);
-			if (outcome.kind === "abort") {
-				closeIterator();
-				throw abortReason(abortSignal!);
-			}
-			if (outcome.kind === "timeout") {
-				if (!awaitingFirstItem) {
-					options.onIdle?.();
-				} else {
+			try {
+				const outcome = await Promise.race(racers);
+				if (outcome.kind === "abort") {
+					closeIterator();
+					throw abortReason(abortSignal!);
+				}
+				if (outcome.kind === "timeout") {
+					if (!awaitingFirstItem) {
+						options.onIdle?.();
+					} else {
+						options.onFirstItemTimeout?.();
+					}
+					closeIterator();
+					throw awaitingFirstItem
+						? new FirstEventTimeoutError(options.firstItemErrorMessage ?? options.errorMessage)
+						: new Error(options.errorMessage);
+				}
+				if (outcome.kind === "error") {
+					throw outcome.error;
+				}
+				if (awaitingFirstItem && firstItemDeadlineAt !== undefined && Date.now() >= firstItemDeadlineAt) {
 					options.onFirstItemTimeout?.();
+					closeIterator();
+					throw new FirstEventTimeoutError(options.firstItemErrorMessage ?? options.errorMessage);
 				}
-				closeIterator();
-				throw awaitingFirstItem
-					? new FirstEventTimeoutError(options.firstItemErrorMessage ?? options.errorMessage)
-					: new Error(options.errorMessage);
-			}
-			if (outcome.kind === "error") {
-				throw outcome.error;
-			}
-			if (awaitingFirstItem && firstItemDeadlineAt !== undefined && Date.now() >= firstItemDeadlineAt) {
-				options.onFirstItemTimeout?.();
-				closeIterator();
-				throw new FirstEventTimeoutError(options.firstItemErrorMessage ?? options.errorMessage);
-			}
-			if (outcome.result.done) {
-				markFirstItemReceived();
-				return;
-			}
-			const item = outcome.result.value;
-			// Non-progress items (e.g. provider keepalives, synthetic `start` events that
-			// arrive before the model has produced any tokens) MUST NOT flip us out of
-			// `awaitingFirstItem`. Otherwise the next iteration switches from the (longer)
-			// first-item watchdog to the (shorter) idle watchdog while we're still waiting
-			// on the model's first real output.
-			if (isProgressItem(item)) {
-				markFirstItemReceived();
-				lastProgressAt = Date.now();
-			}
-			yield item;
-		} finally {
-			if (timer !== undefined) clearTimeout(timer);
-			// Resolve dangling promises so the racers don't leak (Promise.race is one-shot).
-			resolveTimeout?.({ kind: "timeout" });
-			if (abortListener && abortSignal) {
-				abortSignal.removeEventListener("abort", abortListener);
+				if (outcome.result.done) {
+					naturallyExhausted = true;
+					markFirstItemReceived();
+					return;
+				}
+				const item = outcome.result.value;
+				// Non-progress items (e.g. provider keepalives, synthetic `start` events that
+				// arrive before the model has produced any tokens) MUST NOT flip us out of
+				// `awaitingFirstItem`. Otherwise the next iteration switches from the (longer)
+				// first-item watchdog to the (shorter) idle watchdog while we're still waiting
+				// on the model's first real output.
+				if (isProgressItem(item)) {
+					markFirstItemReceived();
+					lastProgressAt = Date.now();
+				}
+				yield item;
+			} finally {
+				if (timer !== undefined) clearTimeout(timer);
+				// Resolve dangling promises so the racers don't leak (Promise.race is one-shot).
+				resolveTimeout?.({ kind: "timeout" });
+				if (abortListener && abortSignal) {
+					abortSignal.removeEventListener("abort", abortListener);
+				}
+				resolveAbort?.({ kind: "abort" });
 			}
-			resolveAbort?.({ kind: "abort" });
 		}
+	} finally {
+		if (!naturallyExhausted) closeIterator();
 	}
 }
 

package/src/utils/json-parse.ts

@@ -249,6 +249,8 @@ export function findUnnecessaryUnicodeEscape(json: string): string | undefined {
 	const len = json.length;
 	let inString = false;
 	let i = 0;
+	let nextQuote = -1;
+	let nextBackslash = -1;
 
 	const hexAt = (start: number): number | undefined => {
 		if (start + 3 >= len) return undefined;
@@ -268,10 +270,16 @@ export function findUnnecessaryUnicodeEscape(json: string): string | undefined {
 		// Jump straight to the next quote or backslash. A per-character walk costs
 		// ~40ms on a 1MB literal-UTF-8 payload (a large `write`), and every byte in
 		// between is by definition uninteresting.
-		const nextQuote = json.indexOf('"', i);
-		const nextBackslash = json.indexOf("\\", i);
-		if (nextQuote === -1 && nextBackslash === -1) return undefined;
-		i = nextBackslash === -1 || (nextQuote !== -1 && nextQuote < nextBackslash) ? nextQuote : nextBackslash;
+		if (nextQuote < i) {
+			const offset = json.indexOf('"', i);
+			nextQuote = offset === -1 ? len : offset;
+		}
+		if (nextBackslash < i) {
+			const offset = json.indexOf("\\", i);
+			nextBackslash = offset === -1 ? len : offset;
+		}
+		i = Math.min(nextQuote, nextBackslash);
+		if (i === len) return undefined;
 
 		if (json.charCodeAt(i) === QUOTE) {
 			inString = false;