@gajae-code/ai 0.17.1 → 0.17.4

package/src/providers/openai-opencodex-responses.ts

@@ -31,6 +31,11 @@ interface CatalogRow {
 	maxTokens?: unknown;
 	reasoning?: unknown;
 	input?: unknown;
+	capabilities?: {
+		context_length?: unknown;
+		input_modalities?: unknown;
+		supports_reasoning?: unknown;
+	};
 }
 
 export interface OpenCodexEndpoint {
@@ -120,6 +125,9 @@ function asPositiveNumber(value: unknown, fallback: number): number {
 
 function normalizeCatalogPayload(payload: unknown): CatalogRow[] {
 	if (Array.isArray(payload)) return payload as CatalogRow[];
+	if (payload && typeof payload === "object" && Array.isArray((payload as { data?: unknown }).data)) {
+		return (payload as { data: CatalogRow[] }).data;
+	}
 	if (payload && typeof payload === "object" && Array.isArray((payload as { models?: unknown }).models)) {
 		return (payload as { models: CatalogRow[] }).models;
 	}
@@ -127,12 +135,14 @@ function normalizeCatalogPayload(payload: unknown): CatalogRow[] {
 }
 
 function normalizeModel(row: CatalogRow, endpoint: OpenCodexEndpoint): Model<"openai-responses"> | undefined {
+	if (!row || typeof row !== "object") return undefined;
 	const rawId = typeof row.id === "string" ? row.id.trim() : typeof row.model === "string" ? row.model.trim() : "";
 	if (!rawId || rawId.includes("\n")) return undefined;
 	const publicId = `opencodex/${rawId}`;
+	const modalities = row.input ?? row.capabilities?.input_modalities;
 	const input =
-		Array.isArray(row.input) && row.input.every(value => value === "text" || value === "image")
-			? row.input
+		Array.isArray(modalities) && modalities.every(value => value === "text" || value === "image")
+			? modalities
 			: ["text"];
 	return {
 		id: publicId,
@@ -142,10 +152,10 @@ function normalizeModel(row: CatalogRow, endpoint: OpenCodexEndpoint): Model<"op
 		provider: "opencodex",
 		baseUrl: `${endpoint.baseUrl}/v1`,
 		compat: { supportsServiceTier: true },
-		reasoning: row.reasoning !== false,
+		reasoning: (row.reasoning ?? row.capabilities?.supports_reasoning) !== false,
 		input,
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: asPositiveNumber(row.contextWindow, 128_000),
+		contextWindow: asPositiveNumber(row.contextWindow ?? row.capabilities?.context_length, 128_000),
 		maxTokens: asPositiveNumber(row.maxTokens, 16_384),
 	};
 }
@@ -154,7 +164,7 @@ export async function fetchOpenCodexModels(): Promise<readonly Model<"openai-res
 	const endpoint = await resolveOpenCodexEndpoint();
 	if (!endpoint) return null;
 	try {
-		const rows = normalizeCatalogPayload(await fetchJson(`${endpoint.baseUrl}/api/models`));
+		const rows = normalizeCatalogPayload(await fetchJson(`${endpoint.baseUrl}/v1/models`));
 		const models = rows
 			.map(row => normalizeModel(row, endpoint))
 			.filter((model): model is Model<"openai-responses"> => model !== undefined);

package/src/stream.ts

@@ -27,6 +27,7 @@ function markManagedAttemptValidated<T extends object>(options: T): T {
 import { getCustomApi } from "./api-registry";
 import type { Effort } from "./model-thinking";
 import {
+	getMiniMaxThinkingMode,
 	mapEffortToAnthropicAdaptiveEffort,
 	mapEffortToGoogleThinkingLevel,
 	requireSupportedEffort,
@@ -499,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();
 }
 
@@ -823,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();
 }
 
@@ -978,6 +985,16 @@ function mapOptionsForApi<TApi extends Api>(
 
 	switch (model.api) {
 		case "anthropic-messages": {
+			const miniMaxMode = getMiniMaxThinkingMode(model);
+			if (miniMaxMode) {
+				return castApi<"anthropic-messages">({
+					...base,
+					thinkingEnabled:
+						miniMaxMode === "toggle" ? !!options?.reasoning && !options?.disableReasoning : undefined,
+					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
+					serviceTier: options?.serviceTier,
+				});
+			}
 			// Explicitly disable thinking when reasoning is not specified or model doesn't support it
 			const reasoning = options?.reasoning;
 			if (!reasoning || !model.reasoning) {
@@ -1094,9 +1111,15 @@ function mapOptionsForApi<TApi extends Api>(
 			return castApi<"openai-completions">({
 				...base,
 				reasoning: resolveOpenAiReasoningEffort(model, options),
-				disableReasoning: options?.disableReasoning,
+				// Agent-level off is represented by an absent effort. MiniMax's
+				// native OpenAI endpoint defaults to on, so send an explicit switch.
+				disableReasoning:
+					getMiniMaxThinkingMode(model) === "toggle"
+						? !options?.reasoning || options?.disableReasoning
+						: 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,8 +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.
+ * `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
@@ -41,19 +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",
 	]);
 	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) {
-			if (!h2FallbackCodes.has((err as { code?: string }).code ?? "")) throw err;
-			return original(input, init);
+			const code = (err as { code?: string }).code ?? "";
+			if (!h2FallbackCodes.has(code)) throw err;
+			if (code === "HTTP2RefusedStream" && !isReplayableRequest(snapshot.input, snapshot.init)) throw err;
+			return original(snapshot.input, snapshot.init);
 		}
 	} as typeof fetch & PatchedFetch;
 
@@ -63,8 +71,63 @@ export function installH2Fetch(): void {
 	globalThis.fetch = wrapper;
 }
 
+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 };
+	}
+
+	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 {
 	if (typeof input === "string") return input.startsWith("https:");
 	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

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { APP_NAME, extractHttpStatusFromError, getLogsDir } from "@gajae-code/utils";
+import { APP_NAME, extractHttpStatusFromError, getEffectiveLogsDir } from "@gajae-code/utils";
 import { isCopilotTransientModelError } from "./retry.js";
 import { formatErrorMessageWithRetryAfter } from "./retry-after.js";
 
@@ -43,6 +43,8 @@ const TRANSPORT_FAILURE_CODES: ReadonlySet<string> = new Set([
 	"ConnectionReset",
 	"ConnectionTimeout",
 	"FailedToOpenSocket",
+	"HTTP2RefusedStream",
+	"HTTP2StreamReset",
 	"HTTP2Unsupported",
 	"EAI_AGAIN",
 	"ECONNREFUSED",
@@ -109,7 +111,7 @@ const MAX_RETAINED_DUMPS = 50;
 
 /** Directory holding the retained HTTP 400 dumps. */
 export function httpRequestDumpDir(): string {
-	return path.join(getLogsDir(), "http-400-requests");
+	return path.join(getEffectiveLogsDir(), "http-400-requests");
 }
 
 /**

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();
 	}
 }