@gajae-code/ai 0.17.2 → 0.17.4

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;

package/src/utils/stream-repetition-guard.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Runaway-repetition detector for a model's streamed text or thinking channel.
+ *
+ * Some models fall into a decode loop and emit the same sentence — or the same
+ * short token run — until the turn's budget runs out. Nothing errors: the tool
+ * calls in the same message still execute, and the transcript just fills with
+ * dozens of identical lines (#5624).
+ *
+ * This is a pure state machine with no provider knowledge: `feed()` takes a
+ * chunk of streamed text and returns the prefix that is safe to emit. Until it
+ * trips, that prefix is the chunk itself, so a healthy stream passes through
+ * byte for byte. Once it trips, it emits nothing further and {@link takeTrip}
+ * hands the caller a one-shot signal to abort the request.
+ *
+ * Use one instance per stream **per channel**. Interleaving the visible-text
+ * and reasoning channels through a single instance would splice unrelated
+ * tokens into the same window and manufacture patterns that were never
+ * streamed.
+ */
+/** Consecutive repeats of one unit that trip the guard. */
+export declare const DEFAULT_REPETITION_THRESHOLD = 12;
+/**
+ * Largest accepted repetition threshold.
+ *
+ * Token retention is `MAX_NGRAM_TOKENS * (threshold + 1)`, so capping the
+ * threshold is what makes the guard's memory bounded: at this cap it retains
+ * at most 64 * 129 = 8256 tokens, against 832 at the default. That is roughly
+ * ten times the default's headroom — generous for a caller who genuinely wants
+ * a laxer guard — while keeping a hostile or buggy option from turning the
+ * detector into an unbounded buffer (#5627 review r6).
+ */
+export declare const MAX_REPETITION_THRESHOLD = 128;
+/**
+ * `errorCode` stamped on a turn this guard stopped. A bounded classifier, never
+ * raw model text — consumers branch on it to tell a local decode-loop stop from
+ * a client cancellation or a transport fault (#5627).
+ */
+export declare const REPETITION_GUARD_ERROR_CODE = "repetition_guard_tripped";
+/**
+ * Wire-safe `errorMessage` for a turn this guard stopped. A literal with zero
+ * interpolation — not the sample, not the channel, not the repeat count.
+ *
+ * The auth gateway forwards `errorMessage` to API clients on the streaming path
+ * (`redactGatewayMessage` only strips credential-shaped text), so anything
+ * interpolated here is raw model output published verbatim. It also reaches
+ * `classifyGatewayError`, which keyword-matches on message text, so a repeated
+ * `quota` or `forbidden` in a sample could pick the HTTP status (#5627 r5).
+ *
+ * The repeated unit is not logged either: the provider logs bounded metadata
+ * only, because the default log transport persists metadata verbatim to a
+ * rotating file on disk (#5627 review r6). {@link StreamRepetitionTrip.sample}
+ * stays in memory for callers that want it.
+ */
+export declare const REPETITION_GUARD_STOP_MESSAGE = "Stopped the turn: the model produced runaway repeated output.";
+export type RepetitionUnitKind = "line" | "ngram";
+export interface StreamRepetitionTrip {
+    /** Whether the repeats were whole lines or an n-gram inside one line. */
+    readonly kind: RepetitionUnitKind;
+    /** Consecutive repeats observed when the guard tripped. */
+    readonly repeats: number;
+    /** Normalized, truncated sample of the repeated unit, for diagnostics. */
+    readonly sample: string;
+}
+export interface StreamRepetitionGuardOptions {
+    /**
+     * Consecutive repeats that trip the guard. Defaults to 12. Normalized by
+     * {@link normalizeThreshold} — non-finite values fall back to the default,
+     * fractional values are floored, and the result is clamped into
+     * `[2, MAX_REPETITION_THRESHOLD]`.
+     */
+    readonly threshold?: number;
+}
+export declare class StreamRepetitionGuard {
+    #private;
+    constructor(options?: StreamRepetitionGuardOptions);
+    /**
+     * The threshold actually in force — the caller's option after
+     * {@link normalizeThreshold}, which may differ from what was passed.
+     */
+    get threshold(): number;
+    get tripped(): boolean;
+    get trip(): StreamRepetitionTrip | undefined;
+    /**
+     * Returns the trip exactly once, then `undefined` forever. Callers drive a
+     * one-shot side effect (aborting the request) off this, so the once-only
+     * latch lives here rather than being re-implemented at each call site.
+     */
+    takeTrip(): StreamRepetitionTrip | undefined;
+    /**
+     * Feed a chunk of streamed text. Returns the portion safe to emit: the whole
+     * chunk while healthy, the prefix up to the repeat that tripped the guard on
+     * the chunk that trips it, and nothing at all after that.
+     */
+    feed(text: string): string;
+    /**
+     * Close the in-progress unit at end of stream and run detection once more.
+     *
+     * `feed()` only closes a token on whitespace and a line on `\n`, so a stream
+     * whose final repeat arrives without a trailing newline left the last copy
+     * uncounted and the turn read as a healthy completion (#5627 review r5).
+     *
+     * Emits nothing — everything `feed()` returned has already been rendered by
+     * the time this runs. A trip found here therefore classifies the turn while
+     * the last copy is already on screen; that is intended. Idempotent.
+     */
+    finalize(): void;
+}