@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/{error-O63pC8zg.mjs → error-8LVo7tug.mjs}

@@ -1,20 +1,22 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { J as getLogsDir, L as isBunTestRuntime } from "./src-AELUUb5U.mjs";
+import { n as fs_promises_shim_exports } from "./fs-promises-shim-CANAxFWh.mjs";
+import { at as getLogsDir, dt as isEnoent, k as warn, lt as isBunTestRuntime } from "./src-BhinCSpi.mjs";
+import { h as isRecord } from "./cascade-BWjRTD1q.mjs";
+import "./behavior-BwvTUtag.mjs";
 import * as path$1 from "node:path";
 import { scheduler } from "node:timers/promises";
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/fetch-retry.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/fetch-retry.ts
 const QUOTA_RESET_PATTERN = /reset after (?:(\d+)h)?(?:(\d+)m)?(\d+(?:\.\d+)?)s/i;
 const PLEASE_RETRY_PATTERN = /Please retry in ([0-9.]+)(ms|s)/i;
 const RETRY_DELAY_FIELD_PATTERN = /"retryDelay":\s*"([0-9.]+)(ms|s)"/i;
 const TRY_AGAIN_PATTERN = /try again in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h)\b/i;
-const WILL_RESET_IN_PATTERN = /(?:will\s+)?reset in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h)\b/i;
-const WILL_RESET_AT_PATTERN = /(?:will\s+)?reset at\s+([0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:Z|[+-][0-9]{2}:?[0-9]{2})?)/i;
-const CN_RESET_AT_PATTERN = /将在\s*([0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]{2}:[0-9]{2}:[0-9]{2})\s*重置/;
+const WILL_RESET_IN_PATTERN = /(?:will\s+)?resets?\s+in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b/i;
+const RESET_IN_HR_MIN_PATTERN = /resets?\s+in\s+~?\s*(\d+(?:\.\d+)?)\s*hr\s*(\d+(?:\.\d+)?)\s*min\b/i;
+const RESET_AT_PATTERNS = [/(?:will\s+)?reset at\s+([0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:Z|[+-][0-9]{2}:?[0-9]{2})?)/i, /将在\s*([0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]{2}:[0-9]{2}:[0-9]{2})\s*重置/];
 const RETRY_AFTER_MS_BODY_PATTERN = /\bretry-after-ms\s*[:=]\s*([0-9]+)\b/i;
 /**
 * Server-suggested retry delay extraction. Merges the patterns historically used
-* by the OpenAI Codex and Google Gemini retry helpers.
 *
 * Header sources (checked in order):
 *  - `retry-after-ms` (milliseconds)
@@ -30,12 +32,14 @@ const RETRY_AFTER_MS_BODY_PATTERN = /\bretry-after-ms\s*[:=]\s*([0-9]+)\b/i;
 *  - `try again in 250ms` / `try again in 12s` / `try again in 5 min` / `try again in ~158 min`
 *  - `retry-after-ms=98497000` / `retry-after-ms: 7200000` / `retry-after-ms = 7200000`
 *  - `Your limit will reset at 2026-09-01 09:44:51` / `将在 2026-09-01 09:44:51 重置`
+*    (a provider offset makes a naive wall clock authoritative; otherwise it
+*    resolves only when no relative signal is present)
 *
 * Returns `undefined` if no signal is found, or `0` when the provider
 * explicitly asks for an immediate retry (`retry-after…=0`, or an absolute
 * reset timestamp that has already elapsed).
 */
-function extractRetryHint(source, body) {
+function extractRetryHint(source, body, options) {
 	const headers = source instanceof Headers ? source : source?.headers ?? void 0;
 	if (headers) {
 		const retryAfterMs = headers.get("retry-after-ms");
@@ -77,6 +81,10 @@ function extractRetryHint(source, body) {
 	if (!body) return void 0;
 	let longestMs;
 	let retryNow = false;
+	let longestNaiveMs;
+	const considerNaive = (ms) => {
+		if (ms !== void 0 && ms > 0 && (longestNaiveMs === void 0 || ms > longestNaiveMs)) longestNaiveMs = ms;
+	};
 	const consider = (ms) => {
 		if (ms !== void 0 && ms > 0 && (longestMs === void 0 || ms > longestMs)) longestMs = ms;
 	};
@@ -95,15 +103,24 @@ function extractRetryHint(source, body) {
 			consider(totalMs > 0 ? totalMs : void 0);
 		}
 	}
-	for (const pattern of [WILL_RESET_AT_PATTERN, CN_RESET_AT_PATTERN]) {
+	for (const pattern of RESET_AT_PATTERNS) {
 		const match = pattern.exec(body);
-		if (match?.[1]) {
-			const normalized = match[1].replace(" ", "T");
-			const hasOffset = /(?:Z|[+-][0-9]{2}:?[0-9]{2})$/i.test(normalized);
-			const parsed = Date.parse(hasOffset ? normalized : `${normalized}Z`);
-			if (!Number.isNaN(parsed) && parsed > Date.now()) consider(parsed - Date.now());
+		if (!match?.[1]) continue;
+		const normalized = match[1].replace(" ", "T");
+		const hasOffset = /(?:Z|[+-][0-9]{2}:?[0-9]{2})$/i.test(normalized);
+		const configuredOffset = options?.naiveResetTimezoneOffset;
+		const parsed = Date.parse(hasOffset ? normalized : `${normalized}${configuredOffset ?? "Z"}`);
+		if (!Number.isNaN(parsed) && parsed > Date.now()) {
+			if (hasOffset || configuredOffset !== void 0) consider(parsed - Date.now());
+			else considerNaive(parsed - Date.now());
 		}
 	}
+	const compoundResetMatch = RESET_IN_HR_MIN_PATTERN.exec(body);
+	if (compoundResetMatch?.[1] && compoundResetMatch[2]) {
+		const hours = Number.parseFloat(compoundResetMatch[1]);
+		const minutes = Number.parseFloat(compoundResetMatch[2]);
+		if (Number.isFinite(hours) && Number.isFinite(minutes) && hours >= 0 && minutes > 0) consider(hours * 60 * 6e4 + minutes * 6e4);
+	}
 	const accountResetMatch = WILL_RESET_IN_PATTERN.exec(body);
 	if (accountResetMatch?.[1]) {
 		const value = Number.parseFloat(accountResetMatch[1]);
@@ -151,7 +168,7 @@ function extractRetryHint(source, body) {
 		const resetSeconds = Number(resetMatch[1]);
 		if (!Number.isNaN(resetSeconds)) considerClamped(resetSeconds > 1e9 ? resetSeconds * 1e3 - Date.now() : resetSeconds * 1e3);
 	}
-	return longestMs ?? (retryNow ? 0 : void 0);
+	return longestMs ?? longestNaiveMs ?? (retryNow ? 0 : void 0);
 }
 function unitToMs(unit) {
 	switch (unit.toLowerCase()) {
@@ -168,6 +185,9 @@ function unitToMs(unit) {
 		case "hrs":
 		case "hour":
 		case "hours": return 36e5;
+		case "d":
+		case "day":
+		case "days": return 864e5;
 		default: return;
 	}
 }
@@ -202,13 +222,15 @@ async function fetchWithRetry(url, options = {}) {
 			await waitForRetry(resolveDefaultDelay(defaultDelayMs, attempt, maxDelayMs), signal);
 			continue;
 		}
-		if (!isRetryableStatus(response.status)) return response;
+		if (!isRetryableStatus$1(response.status)) return response;
 		if (attempt + 1 >= maxAttempts) return response;
 		const retryBody = await response.clone().text();
 		if (shouldRetryResponse && !await shouldRetryResponse(response, retryBody, attempt)) return response;
 		const hint = extractRetryHint(response, retryBody);
 		if (hint !== void 0 && hint > maxDelayMs) return response;
-		await waitForRetry(Math.min(hint ?? resolveDefaultDelay(defaultDelayMs, attempt, maxDelayMs), maxDelayMs), signal);
+		const delayMs = Math.min(hint ?? resolveDefaultDelay(defaultDelayMs, attempt, maxDelayMs), maxDelayMs);
+		if (!response.bodyUsed) response.body?.cancel().catch(() => {});
+		await waitForRetry(delayMs, signal);
 	}
 }
 function mergeInit(base, overlay, timeout) {
@@ -237,7 +259,7 @@ async function waitForRetry(delayMs, signal) {
 function wrapNetworkError(error) {
 	if (error instanceof Error) {
 		if (error.name === "AbortError" || error.message === "Request was aborted") return /* @__PURE__ */ new Error("Request was aborted");
-		if (error.message === "fetch failed" && error.cause instanceof Error) return /* @__PURE__ */ new Error(`Network error: ${error.cause.message}`);
+		if (error.message === "fetch failed" && error.cause instanceof Error) return new Error(`Network error: ${error.cause.message}`, { cause: error });
 		return error;
 	}
 	return new Error(String(error));
@@ -293,7 +315,7 @@ function extractStatusFromMessage(message) {
 * `true` if the given HTTP status code is one we treat as transient: 408
 * (Request Timeout), 429 (Too Many Requests), or any 5xx (server error).
 */
-function isRetryableStatus(status) {
+function isRetryableStatus$1(status) {
 	return status >= 500 || status === 408 || status === 429;
 }
 /**
@@ -317,14 +339,14 @@ function isRetryableError(error) {
 	if ((info?.name ?? "") === "AbortError" || /timeout|timed out|aborted/i.test(message)) return true;
 	const status = extractHttpStatusFromError(error);
 	if (status !== void 0) {
-		if (isRetryableStatus(status)) return true;
+		if (isRetryableStatus$1(status)) return true;
 		if (status >= 400 && status < 500) return false;
 	}
 	if (VALIDATION_MESSAGE_PATTERN.test(message)) return false;
 	return isUnexpectedSocketCloseMessage(message) || TRANSIENT_MESSAGE_PATTERN.test(message);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/aws.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/aws.ts
 /** A failure resolving AWS credentials for the Bedrock provider. */
 var AwsCredentialsError = class extends Error {
 	kind;
@@ -342,7 +364,136 @@ var EventStreamFrameError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/classes.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/network-cause.ts
+const MAX_CAUSE_DEPTH = 8;
+const MAX_AGGREGATE_BRANCH = 4;
+const MAX_LINKS = 16;
+const MAX_DETAIL_LENGTH = 120;
+const UNKNOWN_HOST = "the API host";
+const OFFLINE_CODE_PATTERN = /^(?:ETIMEOUT|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH)$/i;
+const OFFLINE_TEXT_PATTERN = /\b(?:ETIMEOUT|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH)\b/i;
+const UNREACHABLE_CODE_PATTERN = /^(?:ENOTFOUND|FailedToOpenSocket)$/i;
+const UNREACHABLE_TEXT_PATTERN = /\b(?:ENOTFOUND|FailedToOpenSocket|getaddrinfo)\b/i;
+const REFUSED_CODE_PATTERN = /^(?:ECONNREFUSED|ConnectionRefused)$/i;
+const REFUSED_TEXT_PATTERN = /\bECONNREFUSED\b|\bConnectionRefused\b|\bUnable to connect\b/i;
+const TLS_CODE_PATTERN = /^(?:CERT_|SELF_SIGNED|UNABLE_TO_GET_ISSUER_CERT|UNABLE_TO_VERIFY|DEPTH_ZERO_SELF_SIGNED_CERT|ERR_TLS_CERT)/i;
+const TLS_TEXT_PATTERN = /unable to verify|certificate verif(?:y|ication)|self[- ]signed certificate|\bCERT_[A-Z_]+\b|\bSELF_SIGNED[A-Z_]*\b|\bUNABLE_TO_GET_ISSUER_CERT[A-Z_]*\b|\bUNABLE_TO_VERIFY_LEAF_SIGNATURE\b/i;
+const GETADDRINFO_HOST_PATTERN = /\bgetaddrinfo\s+[A-Z_]+\s+([^\s,)]+)/i;
+const CONNECT_HOST_PATTERN = /\b(?:connect|connection to)\s+[A-Z_]+\s+([^\s,)]+?)(?::\d+)?(?=[\s,)]|$)/i;
+const BARE_HOST_PATTERN = /\b((?:[a-z0-9-]+\.)+[a-z]{2,})\b/i;
+const GETADDRINFO_DETAIL_PATTERN = /\bgetaddrinfo\s+[A-Z_]+/i;
+const ERRNO_DETAIL_PATTERN = /\b(?:ETIMEOUT|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|FailedToOpenSocket)\b/i;
+const HOST_PATTERNS = [
+	GETADDRINFO_HOST_PATTERN,
+	CONNECT_HOST_PATTERN,
+	BARE_HOST_PATTERN
+];
+function kindOf(code, message) {
+	if (code !== void 0 && TLS_CODE_PATTERN.test(code)) return "tls";
+	if (message !== void 0 && TLS_TEXT_PATTERN.test(message)) return "tls";
+	if (code !== void 0 && REFUSED_CODE_PATTERN.test(code)) return "refused";
+	if (message !== void 0 && REFUSED_TEXT_PATTERN.test(message)) return "refused";
+	if (code !== void 0 && OFFLINE_CODE_PATTERN.test(code)) return "offline";
+	if (message !== void 0 && OFFLINE_TEXT_PATTERN.test(message)) return "offline";
+	if (code !== void 0 && UNREACHABLE_CODE_PATTERN.test(code)) return "unreachable";
+	if (message !== void 0 && UNREACHABLE_TEXT_PATTERN.test(message)) return "unreachable";
+}
+/** First host named by any message seen so far, most specific pattern first. */
+function hostFromTexts(texts) {
+	for (const pattern of HOST_PATTERNS) for (const text of texts) {
+		const host = pattern.exec(text)?.[1];
+		if (host) return host;
+	}
+}
+function detailOf(kind, code, message) {
+	if (kind === "refused") return void 0;
+	if (kind === "tls" && code !== void 0) return code;
+	const matched = message === void 0 ? void 0 : (kind === "tls" ? TLS_TEXT_PATTERN : GETADDRINFO_DETAIL_PATTERN).exec(message)?.[0];
+	if (matched !== void 0) return matched.replace(/\s+/g, " ").trim().slice(0, MAX_DETAIL_LENGTH);
+	if (kind === "tls") return void 0;
+	return code ?? (message === void 0 ? void 0 : ERRNO_DETAIL_PATTERN.exec(message)?.[0]);
+}
+/**
+* Walk an error's `cause`/`errors` graph (bounded depth, cycle-safe) and report
+* the outermost link that describes a local transport failure. Returns
+* `undefined` for anything else, including HTTP-level provider errors.
+*/
+function classifyNetworkCause(err) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [{
+		value: err,
+		depth: 0
+	}];
+	const texts = [];
+	let links = 0;
+	while (links < MAX_LINKS) {
+		const link = queue.shift();
+		if (link === void 0) break;
+		links++;
+		const { value, depth } = link;
+		let code;
+		let message;
+		const isObject = typeof value === "object" && value !== null;
+		if (typeof value === "string") message = value;
+		else if (isObject) {
+			if (seen.has(value)) continue;
+			seen.add(value);
+			if ("code" in value && typeof value.code === "string") code = value.code;
+			if ("message" in value && typeof value.message === "string") message = value.message;
+		} else continue;
+		if (message !== void 0) texts.push(message);
+		const kind = kindOf(code, message);
+		if (kind !== void 0) return {
+			kind,
+			code,
+			detail: detailOf(kind, code, message),
+			host: hostFromTexts(texts)
+		};
+		if (!isObject || depth >= MAX_CAUSE_DEPTH) continue;
+		if ("cause" in value) queue.push({
+			value: value.cause,
+			depth: depth + 1
+		});
+		if ("errors" in value && Array.isArray(value.errors)) for (const nested of value.errors.slice(0, MAX_AGGREGATE_BRANCH)) queue.push({
+			value: nested,
+			depth: depth + 1
+		});
+	}
+}
+/**
+* User-visible sentence for a network failure, or `undefined` when the error is
+* not one. `requestUrl` wins over any host parsed out of the error text.
+*/
+function networkFailureMessage(err, requestUrl) {
+	const failure = classifyNetworkCause(err);
+	if (failure === void 0) return void 0;
+	let urlHost;
+	if (typeof requestUrl === "string" && requestUrl.length > 0) try {
+		const { host } = new URL(requestUrl);
+		if (host.length > 0) urlHost = host;
+	} catch {
+		urlHost = void 0;
+	}
+	const host = urlHost ?? failure.host ?? UNKNOWN_HOST;
+	const detail = failure.detail === void 0 ? "" : ` (${failure.detail})`;
+	switch (failure.kind) {
+		case "offline": return `No internet connection: couldn't reach ${host}${detail}. Check your network or proxy and try again.`;
+		case "unreachable": return `Couldn't reach ${host}${detail}. Check the URL, your network, or proxy.`;
+		case "refused": return `Couldn't connect to ${host} (connection refused). Check that the server is running and reachable.`;
+		case "tls": return `TLS certificate verification failed for ${host}${detail}. If you're behind a TLS-inspecting proxy, its CA may need to be trusted.`;
+	}
+}
+/**
+* Re-describe a rejected `fetch` with {@link networkFailureMessage}, keeping the
+* original error as `cause`. Anything that is not a local transport failure is
+* returned untouched, so provider/HTTP errors keep their identity.
+*/
+function networkFailureError(err, requestUrl) {
+	const message = networkFailureMessage(err, requestUrl);
+	return message === void 0 ? err : new Error(message, { cause: err });
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/classes.ts
 /** Prefix on errors raised when an Anthropic SSE stream envelope is malformed. */
 const STREAM_ENVELOPE_ERROR_PREFIX = "Anthropic stream envelope error:";
 /** Non-2xx HTTP response from a provider. */
@@ -410,8 +561,12 @@ let anthropicErrorBodyReadTimeoutMs = DEFAULT_ANTHROPIC_ERROR_BODY_READ_TIMEOUT_
 /** Non-2xx response from the Anthropic API. */
 var AnthropicApiError = class AnthropicApiError extends ProviderHttpError {
 	requestId;
-	constructor(status, message, headers) {
-		super(message, status, { headers });
+	constructor(status, message, headers, options) {
+		super(message, status, {
+			headers,
+			code: options?.code,
+			cause: options?.cause
+		});
 		this.name = "AnthropicApiError";
 		this.requestId = headers.get("request-id");
 	}
@@ -486,13 +641,24 @@ var AnthropicApiError = class AnthropicApiError extends ProviderHttpError {
 			reader.releaseLock();
 		}
 		const detail = bodyChunks.join("").trim() || "status code (no body)";
-		return new AnthropicApiError(response.status, `${response.status} ${detail}`, response.headers);
+		let code;
+		try {
+			const parsed = JSON.parse(detail);
+			if (parsed && typeof parsed === "object" && "error" in parsed) {
+				const err = parsed.error;
+				if (err && typeof err === "object") {
+					if ("details" in err && err.details && typeof err.details === "object" && "error_code" in err.details && typeof err.details.error_code === "string") code = err.details.error_code;
+					else if ("type" in err && typeof err.type === "string") code = err.type;
+				}
+			}
+		} catch {}
+		return new AnthropicApiError(response.status, `${response.status} ${detail}`, response.headers, { code });
 	}
 };
 /** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
 var AnthropicConnectionError = class extends Error {
-	constructor(cause) {
-		super("Connection error.", { cause });
+	constructor(cause, requestUrl) {
+		super(networkFailureMessage(cause, requestUrl) ?? "Connection error.", { cause });
 		this.name = "AnthropicConnectionError";
 	}
 };
@@ -532,11 +698,13 @@ var OllamaApiError = class extends ProviderHttpError {
 	name = "OllamaApiError";
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/rate-limit.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/rate-limit.ts
 const ACCOUNT_RATE_LIMIT_PATTERN = /\baccount(?:'s)?\b[^\n]{0,80}\brate.?limit\b|\brate.?limit\b[^\n]{0,80}\baccount\b/i;
 const INSUFFICIENT_BALANCE_PATTERN = /insufficient.?balance/i;
 const CREDITS_EXHAUSTED_PATTERN = /\b(?:exceed\w*|insufficient|not enough)\b[^\n]{0,40}\bcredits?\b|\bcredits?\b[^\n]{0,40}\b(?:exhausted|depleted)\b/i;
-const SPEND_LIMIT_PATTERN = /spend.?limit/i;
+const ANTHROPIC_CREDITS_REQUIRED_PATTERN = /\busage credits are required\b|\bcredits_required\b/i;
+const PREPAID_BALANCE_EXHAUSTED_PATTERN = /\busage_pricing_required\b|\bprepaid balance\b[^\n]{0,40}\b(?:used up|exhausted|depleted)\b/i;
+const SPEND_LIMIT_PATTERN = /spend(?:ing)?[\s_-]?(?:limit|cap)\b/i;
 const SUBSCRIPTION_CAP_PATTERN = /\b(?:subscription|plan|membership)\b[^\n]{0,80}\b(?:rate.?limits?|quota|cap)\b|\b(?:rate.?limits?|quota|cap)\b[^\n]{0,80}\b(?:subscription|plan|membership)\b/i;
 const TRANSIENT_INTERVAL_RATE_LIMIT_PATTERN = /\bper\s+(?:second|minute)\b/i;
 function matchesSubscriptionCapText(errorMessage) {
@@ -547,7 +715,7 @@ const CLINE_PASS_QUOTA_PATTERN = /clinepass limit|free limit reached on model/i;
 const RESOURCE_EXHAUSTED_PATTERN = /resource.?exhausted/gi;
 const CONCURRENT_LIMIT_PATTERN = /\btoo many\s+concurren\w*\s+(?:requests?|invocations?)\b|\bconcurren\w*\b[^\n]{0,60}\b(?:limit|quota|exceed\w*|reach\w*)\b|\b(?:limit|quota|exceed\w*|reach\w*)\b[^\n]{0,60}\bconcurren\w*\b|\bconcurren[a-z]*[-_](?:[a-z]+[_-])*(?:limit|quota|exceed\w*|reach\w*)/i;
 const ACCOUNT_SCOPED_403_PATTERN = /\b(?:overall|account|organization|team|workspace)\b[^\n]{0,40}\b(?:message |request )?rate.?limit\b|\byour\b[^\n]{0,30}\b(?:limit )?will reset\b/i;
-const CN_QUOTA_EXHAUSTED_PATTERN = /使用.{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
+const CN_QUOTA_EXHAUSTED_PATTERN = /(?:使用|用量).{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
 const CN_TRANSIENT_CAP_PATTERN = /速率.{0,30}上限|频率.{0,30}上限|每分钟.{0,30}上限|并发.{0,30}上限|使用.{0,30}(?:速率|频率|每分钟|并发).{0,30}上限/;
 const CN_THROTTLE_PATTERN = /速率(?:限制|过快)|频率(?:过高|过快)|过于频繁|稍后[重再]试/;
 const DASHSCOPE_TOKEN_LIMIT_DOC_PATTERN = /error-code[^()\s]*#token-limit/i;
@@ -556,6 +724,7 @@ const DASHSCOPE_TOKEN_LIMIT_MESSAGE_PATTERN = /\byou exceeded your current quota
 function isDashScopeTokenLimitText(errorMessage) {
 	return DASHSCOPE_TOKEN_LIMIT_DOC_PATTERN.test(errorMessage) && DASHSCOPE_TOKEN_LIMIT_MESSAGE_PATTERN.test(errorMessage);
 }
+const TPM_RPM_THROTTLE_PATTERN = /\b(?:tpm|rpm)\b[^\n]{0,40}\b(?:exhaust\w*|exceed\w*|limit\w*|throttl\w*|reach\w*)\b|\b(?:exhaust\w*|exceed\w*|limit\w*|throttl\w*|reach\w*)\b[^\n]{0,40}\b(?:tpm|rpm)\b|\bRateLimitExceeded\.(?:Endpoint)?(?:TPM|RPM)\w*/i;
 const GOOGLE_RPC_ERROR_INFO_TYPE = "type.googleapis.com/google.rpc.ErrorInfo";
 const ANTIGRAVITY_MODEL_QUOTA_PATTERN = /\bexhausted your capacity on this model\b/i;
 const LONG_RATE_LIMIT_DELAY_MS = 3e5;
@@ -602,8 +771,9 @@ function isQuotaExhaustedReason(reason) {
 * Classify a rate-limit error message into a reason category.
 * Priority order: explicit details in a resource-exhausted error > QUOTA
 * (Antigravity "quota will reset") > CN quota > DASHSCOPE_TOKEN_LIMIT (TPM/TPS
-* throttle) > CONCURRENT_LIMIT > MODEL_CAPACITY > QUOTA (account) > RATE_LIMIT >
-* QUOTA (generic) > SERVER_ERROR > bare resource-exhausted > UNKNOWN.
+* throttle) > CONCURRENT_LIMIT > MODEL_CAPACITY > QUOTA (account) > RATE_LIMIT
+* (including TPM/RPM rolling windows) > QUOTA (generic) > SERVER_ERROR > bare
+* resource-exhausted > UNKNOWN.
 *
 * Bare "resource exhausted" / "resource_exhausted" maps to MODEL_CAPACITY (transient, short wait).
 * Explicit details such as "quota exceeded" retain their normal classification.
@@ -624,28 +794,31 @@ function parseRateLimitReason(errorMessage) {
 	if (matchesSubscriptionCapText(errorMessage)) return "QUOTA_EXHAUSTED";
 	if (OPENROUTER_DAILY_FREE_LIMIT_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
 	if (CLINE_PASS_QUOTA_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
-	if (lower.includes("per minute") || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("presque")) return "RATE_LIMIT_EXCEEDED";
-	if (lower.includes("exhausted") || lower.includes("quota") || lower.includes("usage limit") || lower.includes("run out of credits") || lower.includes("out of credits") || lower.includes("spending-limit") || lower.includes("spending limit") || INSUFFICIENT_BALANCE_PATTERN.test(errorMessage) || CREDITS_EXHAUSTED_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (ANTHROPIC_CREDITS_REQUIRED_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (PREPAID_BALANCE_EXHAUSTED_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (lower.includes("per minute") || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("presque") || TPM_RPM_THROTTLE_PATTERN.test(errorMessage)) return "RATE_LIMIT_EXCEEDED";
+	if (lower.includes("exhausted") || lower.includes("quota") || lower.includes("usage limit") || lower.includes("run out of credits") || lower.includes("out of credits") || lower.includes("spending-limit") || lower.includes("spending limit") || lower.includes("access_terminated_error") || INSUFFICIENT_BALANCE_PATTERN.test(errorMessage) || CREDITS_EXHAUSTED_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
 	if (lower.includes("500") || lower.includes("internal error") || lower.includes("internal server error")) return "SERVER_ERROR";
 	if (hasResourceExhaustedStatus) return "MODEL_CAPACITY_EXHAUSTED";
 	return "UNKNOWN";
 }
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
-const USAGE_LIMIT_PATTERN = /usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|spending[- _]?limit|personal-team-blocked|clinepass limit|free limit reached on model/i;
+const USAGE_LIMIT_PATTERN = /usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|out of (?:extra )?usage|spending[- _]?limit|personal-team-blocked|clinepass limit|free limit reached on model|access_terminated_error/i;
 /**
 * HTTP status codes that, absent richer body classification, represent an
 * account-local usage cap rather than a bad credential or a transient blip.
 * HTTP 402 Payment Required represents an account-billing cap (xAI
 * Grok Build "usage balance exhausted", DeepSeek "Insufficient Balance",
-* OpenRouter credit exhaustion) when opaque, payment/deactivation/balance-worded,
-* or QUOTA_EXHAUSTED/CONCURRENT_LIMIT, while informative non-quota 402s (e.g.
+* OpenCode Go "Insufficient account funds", OpenRouter credit exhaustion)
+* when opaque, payment/deactivation/balance/funds-worded, or
+* QUOTA_EXHAUSTED/CONCURRENT_LIMIT. Informative non-quota 402s (e.g.
 * endpoint subscription requirements) remain non-usage-limits. Always combine
 * with {@link isUsageLimitOutcome} when a message is available.
 */
 function isUsageLimitStatus(status) {
 	return status === 429 || status === 402;
 }
-const STATUS_402_QUOTA_PATTERN = /\b(?:payment(?:\s+is)?[-_.\s]*required|deactivated_workspace|insufficient.?balance)\b/i;
+const STATUS_402_QUOTA_PATTERN = /\b(?:payment(?:\s+is)?[-_.\s]*required|deactivated_workspace|insufficient.?(?:balance|account.?funds))\b/i;
 function is402BillingCapBody(message) {
 	if (message === void 0 || isOpaqueStatusBody(message)) return true;
 	if (STATUS_402_QUOTA_PATTERN.test(message)) return true;
@@ -673,7 +846,8 @@ function matchesUsageLimitText(errorMessage) {
 	const structuredReason = parseGoogleRpcRateLimitReason(errorMessage);
 	if (structuredReason !== void 0) return isQuotaExhaustedReason(structuredReason);
 	if (isDashScopeTokenLimitText(errorMessage)) return false;
-	return USAGE_LIMIT_PATTERN.test(errorMessage) || CREDITS_EXHAUSTED_PATTERN.test(errorMessage) || CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage) || SPEND_LIMIT_PATTERN.test(errorMessage) || ACCOUNT_RATE_LIMIT_PATTERN.test(errorMessage) || matchesSubscriptionCapText(errorMessage) || OPENROUTER_DAILY_FREE_LIMIT_PATTERN.test(errorMessage);
+	if (TPM_RPM_THROTTLE_PATTERN.test(errorMessage) && parseRateLimitReason(errorMessage) === "RATE_LIMIT_EXCEEDED") return false;
+	return USAGE_LIMIT_PATTERN.test(errorMessage) || ANTHROPIC_CREDITS_REQUIRED_PATTERN.test(errorMessage) || PREPAID_BALANCE_EXHAUSTED_PATTERN.test(errorMessage) || CREDITS_EXHAUSTED_PATTERN.test(errorMessage) || CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage) || SPEND_LIMIT_PATTERN.test(errorMessage) || ACCOUNT_RATE_LIMIT_PATTERN.test(errorMessage) || matchesSubscriptionCapText(errorMessage) || OPENROUTER_DAILY_FREE_LIMIT_PATTERN.test(errorMessage);
 }
 /**
 * Account-scoped cap phrasing delivered on a 403 (or a statusless Connect
@@ -686,7 +860,7 @@ function isAccountScopedCapText(message) {
 	return ACCOUNT_SCOPED_403_PATTERN.test(message);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/flags.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/flags.ts
 const Flag = {
 	Class: 4096,
 	ThinkingLoop: 65536,
@@ -711,10 +885,20 @@ const Flag = {
 	FastModeUnsupported: 536870912,
 	/** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
 	OAuthExpiry: 1073741824,
+	/**
+	* An Anthropic-compatible endpoint rejected the `cache_control` field with a
+	* 400, so prompt-cache breakpoints must be dropped for it.
+	*
+	* Every bit from {@link Flag.Class} up is already taken, so this claims a low
+	* bit instead. Those belong to the raw-status lane — an unclassified id is an
+	* HTTP status (100-599, see `statusFromId`) — and 0x800 is 2048, above every
+	* status value, so no raw status id can set it.
+	*/
+	CacheControlUnsupported: 2048,
 	/** HTTP 413 byte/media rejection — token compaction cannot shrink bytes or media budgets (#9235). */
 	PayloadRejected: 2147483648
 };
-const KIND_MASK = Flag.ThinkingLoop | Flag.Transient | Flag.Timeout | Flag.UsageLimit | Flag.StaleResponsesItem | Flag.MalformedFunctionCall | Flag.ProviderFinishError | Flag.EmptyResponse | Flag.ContentBlocked | Flag.AccountPolicy | Flag.ContextOverflow | Flag.AuthFailed | Flag.PayloadRejected | Flag.SilentAbort | Flag.UserInterrupt | Flag.Abort | Flag.Grammar | Flag.FastModeUnsupported | Flag.OAuthExpiry;
+const KIND_MASK = Flag.ThinkingLoop | Flag.Transient | Flag.Timeout | Flag.UsageLimit | Flag.StaleResponsesItem | Flag.MalformedFunctionCall | Flag.ProviderFinishError | Flag.EmptyResponse | Flag.ContentBlocked | Flag.AccountPolicy | Flag.ContextOverflow | Flag.AuthFailed | Flag.PayloadRejected | Flag.SilentAbort | Flag.UserInterrupt | Flag.Abort | Flag.Grammar | Flag.FastModeUnsupported | Flag.CacheControlUnsupported | Flag.OAuthExpiry;
 const RETRIABLE_KINDS = Flag.Transient | Flag.UsageLimit | Flag.ThinkingLoop | Flag.StaleResponsesItem | Flag.ProviderFinishError | Flag.EmptyResponse;
 const CONTEXT_OVERFLOW_EVIDENCE_PATTERNS = [
 	/prompt is too long/i,
@@ -725,6 +909,8 @@ const CONTEXT_OVERFLOW_EVIDENCE_PATTERNS = [
 	/reduce the length of the messages/i,
 	/maximum context length is \d+ tokens/i,
 	/exceeds the available context size/i,
+	/\bprompt\s*\(\s*\d+\s+tokens\s*\)\s*\+\s*max\s+tokens\s*\(\s*\d+\s*\)\s+exceeds\s+the\s+context\s*\(\s*\d+\s*\)/i,
+	/\bprompt\s*\(\s*\d+\s+tokens\s*\)\s+leaves\s+no\s+room\s+to\s+answer\s+in\s+the\s+context\s*\(\s*\d+\s*\)/i,
 	/requested tokens?.*exceed.*context (window|length|size)/i,
 	/context (window|length|size).*(exceeded|overflow|too small)/i,
 	/(prompt|input).*(too long|too large).*(context|n_ctx)/i,
@@ -786,19 +972,66 @@ function matchesPayloadRejectionText(text) {
 }
 const TIMEOUT_PATTERN = /\b(?:operation\s+)?timed?\s*out\b|\btimeout\b|\bstream stall\b/i;
 const TRANSIENT_ENVELOPE_PATTERN = /anthropic stream envelope error:/i;
-const TRANSIENT_ENVELOPE_TRUNCATION_PATTERN = /before message_(?:start|stop)/i;
+const TRANSIENT_ENVELOPE_TRUNCATION_PATTERN = /before message_(?:start|delta|stop)/i;
 const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
 /** Python h2/httpx diagnostics forwarded through provider or proxy error events. */
 const PYTHON_HTTP2_STREAM_RESET_PATTERN = /<StreamReset stream_id:\d+, error_code:(?:2|7), remote_reset:True>/;
 /** Python h11/httpx EOF while reading an HTTP/1.1 chunked response body. */
 const PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN = /peer closed connection without sending complete message body \(incomplete chunked read\)/;
-const TRANSIENT_TRANSPORT_PATTERN = /\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|auth-gateway\s+5\d{2}(?=[:\s]|$)|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|malformed.?function.?call/i;
+/** reqwest body-frame failures forwarded by the Codex HTTP proxy. */
+const CODEX_HTTP_BODY_READ_ERROR_PATTERN = /\btransport error reading codex response body\b/i;
+const RESPONSES_REQUEST_BODY_READ_TIMEOUT_PATTERN = /\btimed out reading request body\b/i;
+/** Exact HTTP request-body-read timeout diagnostic. */
+function isRequestBodyReadTimeout(status, message) {
+	return status === 408 && RESPONSES_REQUEST_BODY_READ_TIMEOUT_PATTERN.test(message ?? "");
+}
+/**
+* Codex code for the experimental native turn lane refusing a mid-response
+* `response.steer`; the server then drops the in-flight response and closes
+* the socket.
+*/
+const CODEX_NATIVE_LANE_STEER_REJECTED_CODE = "unsupported_native_inflight_message";
+/**
+* A Codex turn the native turn lane dropped because omp steered it. The
+* rejection answers our own `response.steer`, not the model's health: the
+* provider stops steering the session, so the same model replays cleanly.
+*/
+function isCodexSteerRejection(message) {
+	return message.api === "openai-codex-responses" && message.errorMessage?.includes(`code=unsupported_native_inflight_message`) === true;
+}
+/**
+* Transport-failure wording that marks an error transient. Covers
+* diagnostics forwarded verbatim by gateways/proxies in other runtimes, e.g.
+* undici's "other side closed" and Go's `net.ErrClosed` ("use of closed
+* network connection", #15385). Also covers OMP's own network-failure
+* sentences from `networkFailureMessage` (offline / unreachable / refused /
+* TLS), which must stay at least as retryable as the bare `Connection error.`
+* text they replaced.
+*/
+const TRANSIENT_TRANSPORT_PATTERN = /\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|auth-gateway\s+5\d{2}(?=[:\s]|$)|\b(?:429|500|502|503|504)\b|service.?unavailable|temporar(?:y|ily)[ _-]?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|use of closed network connection|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|\bE(?:TIMEOUT|NOTFOUND|NETUNREACH|HOSTUNREACH)\b|\bFailedToOpenSocket\b|no internet connection|couldn.?t reach|couldn.?t connect to|tls certificate verification failed|malformed.?function.?call/i;
 const AUTH_FAILURE_PATTERN = /\b(?:401|403|unauthorized|forbidden|authentication|auth[_ ]?unavailable|no auth available|(?:invalid|no)[_ ]?api[_ ]?key)\b/i;
 const MALFORMED_FUNCTION_CALL_PATTERN = /\bmalformed.?function.?call\b/i;
 const PROVIDER_FINISH_ERROR_PATTERN = /\bProvider (?:returned error finish_reason|finish_reason:\s*error)\b/i;
 const EMPTY_RESPONSE_PATTERN = /\bthought-only response without final output\b/i;
 const CONTENT_FILTER_PATTERN = /\b(?:incomplete:\s*)?content_filter\b/i;
 const ACCOUNT_POLICY_PATTERN = /\bcyber_policy\b|trusted access for cyber/i;
+const ANTHROPIC_ACCOUNT_POLICY_PATTERN = /\b(?:oauth_not_allowed_for_organization|permission_error)\b|\bOAuth authentication is currently not allowed for this organization\b/i;
+/** Whether an error message represents an Anthropic account-scoped permission/policy denial. */
+function isAnthropicAccountPolicyText(text, provider, statusArg) {
+	if (provider !== void 0 && provider !== "anthropic") return false;
+	const statusCandidate = statusArg ?? (text ? status({ message: text }) : void 0);
+	if (statusCandidate !== void 0 && statusCandidate !== 403) return false;
+	return ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(text);
+}
+const IMMUTABLE_LATEST_THINKING_PATTERN = /messages\.\d+\.content\.\d+.*\b(?:thinking|redacted_thinking)\b.*\blatest assistant message cannot be modified\b/is;
+/**
+* Anthropic's rejection of a replayed latest assistant turn whose `thinking` or
+* `redacted_thinking` blocks no longer verify. Resending the same turn fails the
+* same way; only a request that changes that turn's reasoning can succeed.
+*/
+function isImmutableLatestThinkingText(text) {
+	return IMMUTABLE_LATEST_THINKING_PATTERN.test(text);
+}
 const CODEX_CHATGPT_ACCOUNT_MODEL_POLICY_PATTERN = /\bThe ['"]([^'"\r\n]+)['"] model is not supported when using Codex with a ChatGPT account\./i;
 const CODEX_CHATGPT_ACCOUNT_MODEL_MAX_LENGTH = 256;
 const CURSOR_PLAN_POLICY_MARKER_PATTERN = /\bERROR_RATE_LIMITED_CHANGEABLE\b/i;
@@ -843,14 +1076,20 @@ const STRUCTURED_OUTPUTS_PATTERN = /structured[_ -]?outputs?/i;
 const FEATURE_NOT_SUPPORTED_PATTERN = /not (?:supported|available|enabled)|unsupported|does(?: not|n'?t) support/i;
 const ANTHROPIC_STRICT_FIELD_PATTERN = /\btools\.\d+\.custom\.strict\b/i;
 const EXTRA_INPUTS_NOT_PERMITTED_PATTERN = /extra inputs? (?:are|is) not permitted/i;
+const STRICT_TOOL_SCHEMA_REJECTION_PATTERN = /invalid schema for function|invalid tool parameters schema/i;
 const FAST_MODE_SPEED_PARAM_PATTERN = /\bspeed\b/i;
 const FAST_MODE_NOT_SUPPORTED_PATTERN = /not support/i;
 const FAST_MODE_RATE_LIMIT_PATTERN = /rate_limit_error/i;
 const FAST_MODE_ENTITLEMENT_PATTERN = /fast mode/i;
+const CACHE_CONTROL_FIELD_PATTERN = /\bcache_control\b/i;
+const CACHE_CONTROL_REJECTION_PATTERN = /\bunexpected\b|\bunrecognized\b|\bnot permitted\b|\bnot allowed\b|\bnot recognized\b|\bnot supported\b|\bunsupported\b|\binvalid[_ ]field\b|\bextra (?:inputs?|fields?)\b/i;
+const CACHE_CONTROL_MEMBER_REFUSAL_PATTERN = /\b(?:un(?:known|permitted|supported|recognized|expected)|invalid|bad|not (?:an? )?(?:known|valid|accepted|supported|permitted|allowed|recognized))[_ -](?:field|name|param(?:eter)?|argument|key|propert(?:y|ies)|attribute|member|option|input)s?\b/i;
+const CACHE_CONTROL_EMPTY_TEXT_PATTERN = /empty text block|text content block.*non-(?:empty|whitespace)|text.{0,40}must (?:be non-empty|not be empty)/i;
 function matchesStrictToolsRejection(message, errorStatus) {
 	if (errorStatus !== 400) return false;
 	if (ANTHROPIC_STRICT_FIELD_PATTERN.test(message) && EXTRA_INPUTS_NOT_PERMITTED_PATTERN.test(message)) return true;
 	if (STRUCTURED_OUTPUTS_PATTERN.test(message) && FEATURE_NOT_SUPPORTED_PATTERN.test(message)) return true;
+	if (STRICT_TOOL_SCHEMA_REJECTION_PATTERN.test(message)) return true;
 	if (!INVALID_REQUEST_PATTERN.test(message)) return false;
 	const grammarTooLarge = GRAMMAR_TOO_LARGE_PATTERN.test(message) && GRAMMAR_TOO_LARGE_DETAIL_PATTERN.test(message);
 	const schemaTooComplex = SCHEMA_TOO_COMPLEX_PATTERN.test(message) && SCHEMA_TOO_COMPLEX_DETAIL_PATTERN.test(message) && SCHEMA_COMPILE_PATTERN.test(message);
@@ -861,6 +1100,12 @@ function matchesFastModeUnsupported(message, errorStatus) {
 	if (errorStatus === 400 && INVALID_REQUEST_PATTERN.test(message) && FAST_MODE_SPEED_PARAM_PATTERN.test(message) && FAST_MODE_NOT_SUPPORTED_PATTERN.test(message)) return true;
 	return errorStatus === 429 && FAST_MODE_RATE_LIMIT_PATTERN.test(message) && FAST_MODE_ENTITLEMENT_PATTERN.test(message);
 }
+function matchesCacheControlRejection(message, errorStatus) {
+	if (errorStatus !== 400) return false;
+	if (!CACHE_CONTROL_FIELD_PATTERN.test(message)) return false;
+	if (CACHE_CONTROL_EMPTY_TEXT_PATTERN.test(message)) return false;
+	return CACHE_CONTROL_REJECTION_PATTERN.test(message) || CACHE_CONTROL_MEMBER_REFUSAL_PATTERN.test(message);
+}
 Flag.ThinkingLoop, Flag.Transient, Flag.Timeout, Flag.UsageLimit, Flag.StaleResponsesItem, Flag.MalformedFunctionCall, Flag.ProviderFinishError, Flag.EmptyResponse, Flag.ContentBlocked, Flag.AccountPolicy, Flag.ContextOverflow, Flag.PayloadRejected, Flag.AuthFailed, Flag.SilentAbort, Flag.UserInterrupt, Flag.Abort;
 const STATUS_MESSAGE_PATTERNS = [
 	/\bstatus(?:_code)?[:=]\s*(\d{3})\b/i,
@@ -899,6 +1144,7 @@ function statusInternal(error, depth) {
 		const errObj = error;
 		if (typeof errObj.status === "number" && errObj.status >= 100 && errObj.status <= 599) return errObj.status;
 		if (typeof errObj.statusCode === "number" && errObj.statusCode >= 100 && errObj.statusCode <= 599) return errObj.statusCode;
+		if (typeof errObj.errorStatus === "number" && errObj.errorStatus >= 100 && errObj.errorStatus <= 599) return errObj.errorStatus;
 		if (typeof errObj.response === "object" && errObj.response !== null) {
 			const resp = errObj.response;
 			if (typeof resp.status === "number" && resp.status >= 100 && resp.status <= 599) return resp.status;
@@ -946,6 +1192,16 @@ function isContentBlockedText(text) {
 function matchesOverflowText(text) {
 	return OVERFLOW_PATTERNS.some((p) => p.test(text)) || OVERFLOW_NO_BODY_PATTERN.test(text);
 }
+/**
+* A 4xx the provider rejected as a deterministic client error — every 4xx
+* except 408 (Request Timeout) and 429 (Too Many Requests), the retryable
+* pair. Mirrors the 4xx policy in {@link isProviderRetryableError}: such a
+* request replays identically, so a transient signal riding on it (e.g. a
+* truncation phrase in the body) must not flip it to retryable.
+*/
+function isTerminalClientErrorStatus(status) {
+	return status !== void 0 && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
 function classifyText(errorMessage, errorStatus, priorTokenOverflowEvidence = false, api, provider, modelId) {
 	let kinds = 0;
 	if (errorMessage) {
@@ -955,22 +1211,31 @@ function classifyText(errorMessage, errorStatus, priorTokenOverflowEvidence = fa
 		if (isProviderFinishErrorText(errorMessage)) kinds |= Flag.ProviderFinishError;
 		if (EMPTY_RESPONSE_PATTERN.test(errorMessage)) kinds |= Flag.EmptyResponse | Flag.Transient;
 		if (isContentBlockedText(errorMessage)) kinds |= Flag.ContentBlocked;
+		const statusClean = errorStatus ? errorStatus : status({ message: errorMessage }) ?? void 0;
 		if (ACCOUNT_POLICY_PATTERN.test(errorMessage) || isCodexChatGPTAccountPolicyText(errorMessage, provider, modelId) || provider === "cursor" && isCursorPlanPolicyText(errorMessage)) kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
+		if (isAnthropicAccountPolicyText(errorMessage, provider, statusClean)) kinds |= Flag.AccountPolicy;
 		if (isAuthFailureText(errorMessage)) kinds |= Flag.AuthFailed;
-		const statusClean = errorStatus ? errorStatus : status({ message: errorMessage }) ?? void 0;
 		const cleanMessage = errorMessage;
 		const isOpaque = isOpaqueStatusBody(cleanMessage);
 		const isLimitStatus = isUsageLimitStatus(statusClean);
 		const reason = parseRateLimitReason(cleanMessage);
 		const is402BillingCap = statusClean === 402 && is402BillingCapBody(cleanMessage);
 		if (!(reason === "CONCURRENT_LIMIT" && statusClean !== 402) && (is402BillingCap || matchesUsageLimitText(cleanMessage) || (statusClean === 403 || statusClean === void 0) && isAccountScopedCapText(cleanMessage) || isLimitStatus && (isOpaque || reason === "QUOTA_EXHAUSTED"))) kinds |= Flag.UsageLimit;
-		if (isTimeoutText(errorMessage)) kinds |= Flag.Transient | Flag.Timeout;
-		else if (isTransientErrorText(errorMessage)) kinds |= Flag.Transient;
+		if (!isTerminalClientErrorStatus(statusClean)) {
+			if (isTimeoutText(errorMessage)) kinds |= Flag.Transient | Flag.Timeout;
+			else if (isTransientErrorText(errorMessage)) kinds |= Flag.Transient;
+			if (isTransientStreamParseError(errorMessage) || isTransientStreamDropError(errorMessage) || CODEX_HTTP_BODY_READ_ERROR_PATTERN.test(errorMessage)) kinds |= Flag.Transient;
+		}
 		if (reason === "CONCURRENT_LIMIT") kinds |= Flag.Transient;
 		if ((api === "openai-responses" || api === "openai-codex-responses") && isStaleResponsesText(errorMessage)) kinds |= Flag.StaleResponsesItem;
+		if (isCodexSteerRejection({
+			api,
+			errorMessage
+		})) kinds |= Flag.Transient;
 		if (statusClean === 400 && GENERATION_NAN_PATTERN.test(cleanMessage)) kinds |= Flag.Transient;
 		if (matchesStrictToolsRejection(cleanMessage, statusClean)) kinds |= Flag.Grammar;
 		if (matchesFastModeUnsupported(cleanMessage, statusClean)) kinds |= Flag.FastModeUnsupported;
+		if (matchesCacheControlRejection(cleanMessage, statusClean)) kinds |= Flag.CacheControlUnsupported;
 	}
 	const statusEvidence = errorStatus ?? (errorMessage ? status({ message: errorMessage }) : void 0);
 	if (statusEvidence === 413 && !priorTokenOverflowEvidence && !(errorMessage && hasTokenContextOverflowEvidence(errorMessage))) kinds |= Flag.PayloadRejected;
@@ -985,12 +1250,16 @@ function classify(error, api) {
 	const seen = /* @__PURE__ */ new Set();
 	const causeTokenEvidence = hasCauseTokenContextOverflowEvidence(error);
 	let link = error;
+	let governingTerminalStatus;
 	while (link !== void 0 && link !== null) {
 		if (typeof link === "object") {
 			if (seen.has(link)) break;
 			seen.add(link);
 			if ("errorId" in link && typeof link.errorId === "number") kinds |= link.errorId & KIND_MASK;
-			if ("code" in link && typeof link.code === "string" && ACCOUNT_POLICY_PATTERN.test(link.code)) kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
+			if ("code" in link && typeof link.code === "string") {
+				if (ACCOUNT_POLICY_PATTERN.test(link.code)) kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
+				else if (ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(link.code)) kinds |= Flag.AccountPolicy;
+			}
 		}
 		if (link instanceof AwsCredentialsError) kinds |= Flag.AuthFailed;
 		else if (link instanceof AnthropicConnectionTimeoutError) kinds |= Flag.Timeout | Flag.Transient;
@@ -1000,8 +1269,9 @@ function classify(error, api) {
 		else if (link instanceof ProviderHttpError) {
 			let linkKinds = 0;
 			const { status: codeStatus, code } = link;
-			if (code === "usage_limit_reached" || code === "insufficient_quota" && !isDashScopeTokenLimitText(link.message) || codeStatus === 402 && (code === "payment_required" || code === "deactivated_workspace" || is402BillingCapBody(link.message))) linkKinds |= Flag.UsageLimit;
+			if (code === "usage_limit_reached" || code === "insufficient_quota" && !isDashScopeTokenLimitText(link.message) || codeStatus === 402 && (is402BillingCapBody(link.message) || code !== void 0 && !isOpaqueStatusBody(code) && is402BillingCapBody(code))) linkKinds |= Flag.UsageLimit;
 			if (code === "overloaded_error" || code === "rate_limit_error") linkKinds |= Flag.Transient;
+			if (code === "oauth_not_allowed_for_organization" || code === "permission_error" || codeStatus === 403 && ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(link.message)) linkKinds |= Flag.AccountPolicy;
 			if ((codeStatus === 401 || codeStatus === 403) && !(codeStatus === 403 && parseRateLimitReason(link.message) === "CONCURRENT_LIMIT")) linkKinds |= Flag.AuthFailed;
 			else if (codeStatus === 429) {
 				if ((linkKinds & Flag.UsageLimit) === 0) linkKinds |= Flag.Transient;
@@ -1011,9 +1281,14 @@ function classify(error, api) {
 		let linkMessage;
 		if (link instanceof Error) linkMessage = link.message;
 		else if (typeof link === "string") linkMessage = link;
-		else if (typeof link === "object" && "message" in link && typeof link.message === "string") linkMessage = link.message;
-		const textId = classifyText(linkMessage, status(link), causeTokenEvidence, api);
+		else if (typeof link === "object") {
+			if ("message" in link && typeof link.message === "string") linkMessage = link.message;
+			else if ("errorMessage" in link && typeof link.errorMessage === "string") linkMessage = link.errorMessage;
+		}
+		const linkStatus = status(link);
+		const textId = classifyText(linkMessage, linkStatus ?? governingTerminalStatus, causeTokenEvidence, api);
 		kinds |= textId & KIND_MASK;
+		if (isTerminalClientErrorStatus(linkStatus)) governingTerminalStatus = linkStatus;
 		link = typeof link === "object" && "cause" in link ? link.cause : void 0;
 	}
 	return kinds !== 0 ? create(kinds) : status(error) ?? 0;
@@ -1042,6 +1317,22 @@ function isGrammarError(error) {
 function isFastModeUnsupported(error) {
 	return is(classify(error), Flag.FastModeUnsupported);
 }
+/**
+* An Anthropic-compatible endpoint returned a 400 rejecting something about
+* `cache_control`. Whether it refused the field or one nested option is not
+* decidable here (see {@link CACHE_CONTROL_FIELD_PATTERN}); the caller's retry
+* ladder settles it by replaying.
+* Accessor for {@link Flag.CacheControlUnsupported}.
+*
+* Unlike the high-bit accessors this also requires a classified id. The flag
+* sits in the raw-status lane (see {@link Flag.CacheControlUnsupported}), and
+* while no HTTP status reaches 0x800, `is` is a bare bit test — the extra gate
+* keeps a stray non-HTTP status out of the retry path.
+*/
+function isCacheControlUnsupported(error) {
+	const id = classify(error);
+	return isClassified(id) && is(id, Flag.CacheControlUnsupported);
+}
 const CLINE_PASS_SURFACE_GATE_PATTERN = /only available via cline product surfaces/i;
 /**
 * Cline's gateway gates some roster entries (certain free-tier models) to its
@@ -1087,6 +1378,28 @@ function isTransientStreamParseError(error) {
 	if (typeof error === "string") return STREAM_PARSE_DIAGNOSTIC_PATTERN.test(error);
 	return error instanceof Error && STREAM_PARSE_TRUNCATION_PATTERN.test(error.message);
 }
+/**
+* Transport-level stream drops: the connection or upstream stream ended before a
+* terminal event, with no JSON-parse signal and no retryable status attached.
+*
+* Distinct from {@link STREAM_PARSE_TRUNCATION_PATTERN} (mid-body JSON
+* truncation) — these name the transport itself dropping (proxy/gateway closing
+* the SSE stream, socket dying before the TLS handshake completes). The wording
+* is the statusless twin of a `408 stream disconnected`, which the status path
+* already retries; an identical replay recovers it, so callers under a
+* non-terminal status treat it as transient (#11805).
+*/
+const STREAM_DROP_PATTERN = /stream disconnected before completion|(?:stream|websocket) closed before response\.completed|stream was interrupted|stream ended before (?:terminal (?:chunk|completion event)|message_(?:start|delta|stop))|socket disconnected before secure tls connection/i;
+/**
+* Transport stream-drop diagnostic (see {@link STREAM_DROP_PATTERN}). Unlike
+* {@link isTransientStreamParseError}, one pattern serves both the live `Error`
+* and the persisted-string forms: the phrasings are high-signal enough to trust
+* detached from a transport `Error`.
+*/
+function isTransientStreamDropError(error) {
+	if (typeof error === "string") return STREAM_DROP_PATTERN.test(error);
+	return error instanceof Error && STREAM_DROP_PATTERN.test(error.message);
+}
 /** Any malformed stream-envelope error (prefix-tagged or out-of-order events). */
 function isStreamEnvelopeError(error) {
 	return error instanceof Error && (error.message.includes("Anthropic stream envelope error:") || STREAM_EVENT_ORDER_PATTERN.test(error.message));
@@ -1096,7 +1409,7 @@ function isRetryableStreamEnvelopeError(error) {
 	return error instanceof Error && STREAM_EVENT_ORDER_PATTERN.test(error.message);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/abort.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/abort.ts
 /**
 * A request was cancelled — by the caller's `AbortSignal` or a provider-local
 * watchdog. Carries the {@link Flag.Abort} classification structurally so retry
@@ -1114,7 +1427,7 @@ var AbortError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/auth.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/auth.ts
 /**
 * No API key / credential was available to dispatch a request.
 *
@@ -1158,7 +1471,7 @@ var LoginCancelledError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/oauth.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/oauth.ts
 /**
 * A failure inside an interactive OAuth / device-code login flow. The `kind`
 * pinpoints the stage. Timeout/polling are classified transient; everything
@@ -1179,7 +1492,259 @@ var OAuthError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/retry-after.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/provider.ts
+/**
+* A non-HTTP provider failure: a truncated stream, an error stop reason, an
+* empty body, a malformed envelope, or a runtime fault. For non-2xx HTTP
+* responses use {@link ProviderHttpError} (or a provider subclass) instead.
+*/
+var ProviderResponseError = class extends Error {
+	provider;
+	kind;
+	constructor(message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "ProviderResponseError";
+		this.provider = options.provider;
+		this.kind = options.kind ?? "output";
+		if (this.kind === "content-blocked") attach(this, create(Flag.ContentBlocked));
+		else if (this.kind === "empty-output") attach(this, create(Flag.Transient, Flag.EmptyResponse));
+		else if (this.kind === "incomplete-stream" || this.kind === "empty-body") attach(this, create(Flag.Transient));
+	}
+};
+/** Non-2xx response from the Devin API. */
+var DevinApiError = class extends ProviderHttpError {
+	name = "DevinApiError";
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/body-error.ts
+/**
+* In-band provider failures: upstream 429/5xx payloads that arrive inside an
+* HTTP 200 response body, or mid-stream after the SSE headers were already sent.
+*
+* Providers that front a retry/queue layer — Azure OpenAI, LiteLLM-style
+* aggregators, Bedrock-compatible shims — answer a throttled request with
+* `200 OK` + `text/event-stream` and put the real status in the payload:
+* `data: {"error":{"type":"rate_limit_error"}}`, `data: {"code":429}`, or a bare
+* non-JSON frame such as `data: 429 Too Many Requests` / an nginx throttle page.
+* Those bodies used to be either dropped silently (the stream then looked like a
+* successful empty completion) or surfaced as an unclassified
+* {@link ProviderResponseError} whose `errorId` stayed 0 — so `AIError.retriable`
+* answered "terminal" and `retry.fallbackChains` never advanced, pinning the
+* session on a provider that was merely busy.
+*
+* Both probes hand the classifier the structured signal it already trusts for an
+* out-of-band failure: a {@link ProviderHttpError} carrying a status the upstream
+* *reported*, so the two routes reach one code path. The invariants that make
+* that safe, and that callers rely on:
+*
+*  - **No invented HTTP metadata.** A status is taken only from an error
+*    `status`/`code` *field* (numeric, or a 3-digit string as compat hosts send)
+*    or from {@link RETRYABLE_STATUS_BY_CODE}, and only for `429`/`5xx`. A status
+*    mentioned inside error prose is never promoted to a status: 401/403 wording
+*    stays text and cannot route the failure into the auth-retry lane.
+*  - **No credential rotation on an unreadable body.** A `429` whose body is
+*    empty, `{}`, or framing-only is opaque, and an opaque 429 is the conservative
+*    rotate-to-a-sibling-credential signal. That verdict belongs to a body the
+*    server actually sent, not to a payload we synthesised, so
+*    {@link formatInBandMessage} substitutes {@link IN_BAND_DETAIL_PLACEHOLDER}
+*    and the composed message always stays informative.
+*  - **Unknown envelopes fall through.** Anything without a retryable status
+*    field, a retryable code, or unambiguous throttle wording returns
+*    `undefined` and keeps its pre-existing handling and message.
+*
+* Where no numeric status exists, the returned error keeps the upstream wording
+* and code visible in its message instead of asserting HTTP metadata the provider
+* never sent, and carries {@link Flag.Transient} directly: throttle spellings like
+* `Throttled` / `Please retry` are what this probe recognises but the transport
+* text pattern is not required to match, so the retry decision is stated rather
+* than hoped for.
+*/
+/** Cap on synthesized message length, mirroring the transport-level `MAX_DETAIL_CHARS`. */
+const MAX_IN_BAND_DETAIL_CHARS = 4096;
+/**
+* Filler used when an in-band failure frame carries no readable detail. It has
+* to be informative prose on purpose: an opaque message on a `429` is read as
+* "the server gave us nothing" and rotates a credential, and that judgement must
+* never be triggered by wording of ours.
+*/
+const IN_BAND_DETAIL_PLACEHOLDER = "Provider returned an in-band provider error";
+/**
+* Machine error codes that mean "shed this request and back off", mapped to the
+* HTTP status the upstream would have used had it not wrapped the failure in a
+* 200. Keys are compared after lower-casing, splitting camel/Pascal word
+* boundaries, and collapsing `_`/`-`/`.`/spaces, so `Throttling.AllocationQuota`
+* and `ThrottlingAllocationQuota` both resolve. The list is deliberately limited
+* to throttle/overload spellings so an unlisted code keeps its pre-existing
+* classification: request-validation failures (`invalid_request_error`) and
+* account caps (`insufficient_quota`, `usage_limit_reached`) are never
+* reinterpreted as retries.
+*/
+const RETRYABLE_STATUS_BY_CODE = {
+	rate_limit_error: 429,
+	rate_limit_exceeded: 429,
+	rate_limit: 429,
+	rate_limit_reached: 429,
+	rate_limited: 429,
+	ratelimit: 429,
+	too_many_requests: 429,
+	request_throttled: 429,
+	throttled: 429,
+	throttling: 429,
+	throttling_error: 429,
+	throttling_exception: 429,
+	throttling_allocation_quota: 429,
+	request_limit_exceeded: 429,
+	retry_later: 429,
+	overloaded_error: 503,
+	server_overloaded: 503,
+	model_overloaded: 503,
+	overloaded: 503,
+	service_unavailable: 503,
+	server_busy: 503,
+	high_demand: 503,
+	capacity_exceeded: 503
+};
+/**
+* Wording that identifies a throttle/overload in an error code or body. Kept as
+* an explicit list rather than reusing the classifier's pattern, so this probe
+* stays independent of the text rules it feeds.
+*/
+const IN_BAND_RETRYABLE_TEXT_PATTERN = /\brate.?limit|too many requests|too\s+many\s+concurren|service.{0,20}unavailable|temporarily\s+unavailable|server.?error|internal.?error|overloaded|capacity|throttl|retry\s+(?:your\s+)?request|please\s+retry/i;
+/**
+* A status in the position a proxy error page puts it: the very first token,
+* optionally after an `HTTP/1.1 ` prefix. Delimited by a word boundary so
+* identifiers (`chatcmpl-500321`, `gpt-500x`, `req500502`) cannot fabricate a
+* status — the same hazard `error-transient-status-boundary.test.ts` guards.
+* Prose that merely *mentions* a number (`Too many requests (401 from …)`) is
+* deliberately not read as status metadata.
+*/
+const LEADING_STATUS_PATTERN = /^\s*(?:HTTP[/.]\d(?:\.\d)?\s+)?([45]\d{2})(?:\b|$)/i;
+/** Codes that mean a persistent account/billing cap or a bad request; never shed-and-retry. */
+const NON_RETRYABLE_CODE_PATTERN = /insufficient.?quota|usage.?limit|quota.?(?:exceeded|reached|insufficient)|invalid_request|content_filter|context_length|context_window|billing|balance/i;
+/** Flags this module asserts for a body it has itself recognised as shed-and-retry. */
+const IN_BAND_FLAGS = create(Flag.Transient);
+function normalizeCodeToken(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value !== "string") return void 0;
+	const collapsed = value.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[-.\s]+/g, "_").replace(/_+/g, "_");
+	return collapsed.length > 0 ? collapsed : void 0;
+}
+function readInBandDetail(value) {
+	if (typeof value !== "string") return void 0;
+	const flattened = value.replace(/<[^>]*>/g, " ").replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+	if (flattened.length === 0) return void 0;
+	return flattened.length > MAX_IN_BAND_DETAIL_CHARS ? flattened.slice(0, MAX_IN_BAND_DETAIL_CHARS) : flattened;
+}
+/** A numeric HTTP status field, accepting the `"429"` string form compat hosts emit. */
+function readStatusField(value) {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599) return value;
+	if (typeof value === "string" && /^\d{3}$/.test(value.trim())) {
+		const parsed = Number(value.trim());
+		return Number.isInteger(parsed) && parsed >= 100 && parsed <= 599 ? parsed : void 0;
+	}
+}
+/** Only `429` and genuine server faults are shed-and-retry; 4xx of any other kind is not. */
+function isRetryableStatus(status) {
+	return status === 429 || status !== void 0 && status >= 500 && status <= 599;
+}
+function readLeadingStatus(text) {
+	if (text === void 0) return void 0;
+	const match = LEADING_STATUS_PATTERN.exec(text);
+	return match?.[1] ? Number(match[1]) : void 0;
+}
+/**
+* Pull the failure signal out of an OpenAI-wire frame. Accepts the nested
+* `{ error: { code, type, status, message } }` shape, the `response.error`
+* position of Responses-API terminal events, the flat `{ code, status, message }`
+* bodies compat hosts emit, and string envelopes (`{ error: "..." }`).
+*
+* `undefined` means "not an in-band failure worth retrying". The probe is
+* intentionally narrow: a bare `type` is present on every Responses event and so
+* never counts as a signal by itself, statuses come only from fields (never from
+* prose), and a frame with neither a retryable status nor throttle wording is
+* left to the caller's existing handling.
+*/
+function readInBandSignal(frame) {
+	if (typeof frame !== "object" || frame === null || Array.isArray(frame)) return void 0;
+	const root = frame;
+	const nested = root.error ?? root.response?.error;
+	let error;
+	if (typeof nested === "object" && nested !== null) {
+		error = nested;
+		for (let depth = 0; depth < 2; depth++) {
+			const inner = error.error;
+			if (typeof inner !== "object" || inner === null) break;
+			error = inner;
+		}
+	}
+	const code = normalizeCodeToken(error?.code ?? root.code) ?? normalizeCodeToken(error?.type ?? root.type);
+	if (code !== void 0 && NON_RETRYABLE_CODE_PATTERN.test(code)) return void 0;
+	if (!(code !== void 0 && IN_BAND_RETRYABLE_TEXT_PATTERN.test(code)) && nested === void 0 && root.status === void 0 && root.code === void 0 && root.message === void 0) return;
+	const detail = readInBandDetail(error?.message) ?? readInBandDetail(root.message) ?? (typeof nested === "string" ? readInBandDetail(nested) : void 0);
+	const holder = error ?? root;
+	const status = (holder === root ? [root.status, root.code] : [
+		holder.status,
+		holder.code,
+		root.status,
+		root.code
+	]).map(readStatusField).find(isRetryableStatus) ?? (code !== void 0 && Object.hasOwn(RETRYABLE_STATUS_BY_CODE, code) ? readStatusField(RETRYABLE_STATUS_BY_CODE[code]) : void 0);
+	if (status !== void 0) return {
+		status,
+		code,
+		detail
+	};
+	if (detail === void 0 || !IN_BAND_RETRYABLE_TEXT_PATTERN.test(detail)) return void 0;
+	return {
+		code,
+		detail
+	};
+}
+/**
+* Compose the message for a status-bearing in-band failure. The numeric status
+* leads (matching `captureOpenAIHttpError`'s `"<status> <detail>"` phrasing)
+* unless the detail already carries it as its leading token; the machine code is
+* appended only when it adds information the text classifier or a human reader
+* can use. A detail that leaves the whole line opaque is replaced by the
+* placeholder, so a body we generated can never be read as "the server said
+* nothing".
+*/
+function formatInBandMessage(status, detail, code) {
+	const body = detail ?? IN_BAND_DETAIL_PLACEHOLDER;
+	const suffix = code !== void 0 && !/^\d+$/.test(code) && !body.toLowerCase().includes(code.toLowerCase()) ? ` (${code})` : "";
+	let message = readLeadingStatus(body) === status ? body : `${status} ${body}`;
+	if (isOpaqueStatusBody(message)) message = `${status} ${IN_BAND_DETAIL_PLACEHOLDER}`;
+	return `${message}${suffix}`;
+}
+/**
+* Build the classified error for an in-band failure frame, or `undefined` when
+* the frame is not a retryable in-band failure (in which case the caller keeps
+* its existing handling and message).
+*
+* @param frame decoded SSE `data:` payload, or the `{ error, response }` subset of one
+*/
+function createInBandProviderError(frame) {
+	const signal = readInBandSignal(frame);
+	if (!signal) return void 0;
+	const { status, code, detail } = signal;
+	if (isRetryableStatus(status)) return attach(new ProviderHttpError(formatInBandMessage(status, detail, code), status, { code }), IN_BAND_FLAGS);
+	if (detail === void 0 && code === void 0) return void 0;
+	return attach(new ProviderResponseError(`${detail ?? IN_BAND_DETAIL_PLACEHOLDER}${code ? ` (${code})` : ""}`, { kind: "runtime" }), IN_BAND_FLAGS);
+}
+/**
+* Build the classified error for a non-JSON SSE frame: gateways and reverse
+* proxies that answer `data: 429 Too Many Requests` or an HTML throttle page
+* instead of an OpenAI envelope. `undefined` when the text is not recognisable
+* as a throttle, so genuinely malformed payloads keep failing loudly.
+*/
+function createInBandProviderErrorFromText(text) {
+	const detail = readInBandDetail(text);
+	if (detail === void 0 || !IN_BAND_RETRYABLE_TEXT_PATTERN.test(detail)) return void 0;
+	const status = readLeadingStatus(detail);
+	if (isRetryableStatus(status)) return attach(new ProviderHttpError(formatInBandMessage(status, detail, void 0), status), IN_BAND_FLAGS);
+	return attach(new ProviderResponseError(detail, { kind: "runtime" }), IN_BAND_FLAGS);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/retry-after.ts
 const RETRY_AFTER_HINT = "retry-after-ms=";
 function formatErrorMessageWithRetryAfter(error, headers) {
 	const message = error instanceof Error ? error.message : JSON.stringify(error);
@@ -1255,15 +1820,17 @@ function parseResetHeader(value, unit) {
 	return Math.ceil(targetMs - nowMs);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/http-inspector.ts
-const SENSITIVE_HEADERS = [
-	"authorization",
-	"x-api-key",
-	"api-key",
-	"cookie",
-	"set-cookie",
-	"proxy-authorization"
-];
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/utils/http-inspector.ts
+/**
+* Matches any header name whose value carries a credential, so a persisted dump
+* never leaks one. A substring match — not a hand-maintained allow-list — so
+* provider-specific auth headers (`x-goog-api-key`, `x-amz-security-token`, …)
+* are redacted without enumerating every provider's spelling; the fixed list it
+* replaced silently leaked any auth header it did not name. Redacting a benign
+* header that happens to match is harmless: dumps exist to diagnose the request
+* body, not its transport headers.
+*/
+const SENSITIVE_HEADER_PATTERN = /key|token|secret|auth|credential|cookie/i;
 /**
 * Build the JSON persisted for a rejected request. Request fields stay at the
 * top level (so existing dump parsers still read `body`); the provider's error
@@ -1289,16 +1856,72 @@ function shouldDumpRejectedRequest(error) {
 	const status$1 = status(error);
 	return status$1 === 400 || status$1 === 413;
 }
+const RAW_HTTP_REQUEST_LINE = "raw-http-request=";
+const RAW_HTTP_REQUEST_SAVE_FAILED_LINE = "raw-http-request-save-failed=";
 async function appendRawHttpRequestDumpFor400(message, error, dump) {
 	if (!dump || isBunTestRuntime() || !shouldDumpRejectedRequest(error)) return message;
 	const payload = buildHttp400DumpPayload(dump, error, message);
 	const fileName = `${Date.now()}-${Bun.hash(JSON.stringify(payload)).toString(36)}.json`;
-	const filePath = path$1.join(getLogsDir(), "http-400-requests", fileName);
+	const dumpDir = path$1.join(getLogsDir(), HTTP_DUMP_DIR_NAME);
+	const filePath = path$1.join(dumpDir, fileName);
 	try {
 		await Bun.write(filePath, `${JSON.stringify(payload, null, 2)}\n`);
-		return `${message}\nraw-http-request=${filePath}`;
+		pruneHttpRequestDumps(dumpDir, { keep: fileName }).catch((err) => {
+			warn("Failed to prune HTTP request dumps", {
+				dir: dumpDir,
+				err
+			});
+		});
+		return `${message}\n${RAW_HTTP_REQUEST_LINE}${filePath}`;
 	} catch (writeError) {
-		return `${message}\nraw-http-request-save-failed=${writeError instanceof Error ? writeError.message : String(writeError)}`;
+		const writeMessage = writeError instanceof Error ? writeError.message : String(writeError);
+		return `${message}\n${RAW_HTTP_REQUEST_SAVE_FAILED_LINE}${writeMessage}`;
+	}
+}
+const HTTP_DUMP_DIR_NAME = "http-400-requests";
+const HTTP_DUMP_MAX_AGE_MS = 6048e5;
+const HTTP_DUMP_MAX_TOTAL_BYTES = 67108864;
+/**
+* Bound the rejected-request dump directory: delete `*.json` dumps older than
+* the age limit, then the oldest survivors until the total fits the size cap.
+*/
+async function pruneHttpRequestDumps(dir, retention = {}) {
+	const maxAgeMs = retention.maxAgeMs ?? HTTP_DUMP_MAX_AGE_MS;
+	const maxTotalBytes = retention.maxTotalBytes ?? HTTP_DUMP_MAX_TOTAL_BYTES;
+	const now = retention.now ?? Date.now();
+	let names;
+	try {
+		names = await fs_promises_shim_exports.readdir(dir);
+	} catch (err) {
+		if (isEnoent(err)) return;
+		throw err;
+	}
+	const dumps = [];
+	for (const name of names) {
+		if (!name.endsWith(".json")) continue;
+		try {
+			const stat = await fs_promises_shim_exports.stat(path$1.join(dir, name));
+			if (stat.isFile()) dumps.push({
+				name,
+				mtimeMs: stat.mtimeMs,
+				size: stat.size
+			});
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+	}
+	dumps.sort((a, b) => b.mtimeMs - a.mtimeMs || (a.name < b.name ? 1 : a.name > b.name ? -1 : 0));
+	let retainedBytes = 0;
+	for (const dump of dumps) {
+		if (dump.name === retention.keep) {
+			retainedBytes += dump.size;
+			continue;
+		}
+		if (now - dump.mtimeMs <= maxAgeMs && retainedBytes + dump.size <= maxTotalBytes) {
+			retainedBytes += dump.size;
+			continue;
+		}
+		await fs_promises_shim_exports.rm(path$1.join(dir, dump.name), { force: true });
 	}
 }
 async function finalizeErrorMessage(error, rawRequestDump, capturedErrorResponse) {
@@ -1360,14 +1983,34 @@ function rewriteClinePassError(errorMessage, provider) {
 function sanitizeDump(dump) {
 	return {
 		...dump,
+		url: redactUrlQuery(dump.url),
 		headers: redactHeaders(dump.headers)
 	};
 }
+/**
+* Strips a persisted dump's query string entirely rather than picking sensitive
+* params by name: a configurable `baseUrl` (e.g. Bedrock's gateway routing) can
+* carry an arbitrary query-based credential the way `SENSITIVE_HEADER_PATTERN`
+* matches arbitrary header names, and dumps exist to diagnose the request body,
+* not the query.
+*/
+function redactUrlQuery(url) {
+	if (!url) return url;
+	try {
+		const parsed = new URL(url);
+		if (!parsed.search) return url;
+		parsed.search = "";
+		return `${parsed.toString()}[redacted-query]`;
+	} catch {
+		return url;
+	}
+}
+/** Copy of `headers` with every credential value replaced by `[redacted]`; shared by every persisted dump. */
 function redactHeaders(headers) {
 	if (!headers) return;
 	const redacted = {};
 	for (const [key, value] of Object.entries(headers)) {
-		if (SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+		if (SENSITIVE_HEADER_PATTERN.test(key)) {
 			redacted[key] = "[redacted]";
 			continue;
 		}
@@ -1396,28 +2039,25 @@ function formatCapturedHttpError(captured) {
 	return extras.length > 0 ? `${message} (${extras.join(" ")})` : message;
 }
 function parseCapturedErrorPayload(captured) {
-	if (isObject(captured.bodyJson)) return captured.bodyJson;
+	if (isRecord(captured.bodyJson)) return captured.bodyJson;
 	if (!captured.bodyText) return void 0;
 	try {
 		const parsed = JSON.parse(captured.bodyText);
-		return isObject(parsed) ? parsed : void 0;
+		return isRecord(parsed) ? parsed : void 0;
 	} catch {
 		return;
 	}
 }
 function getObjectProperty(value, key) {
 	const property = value[key];
-	return isObject(property) ? property : void 0;
+	return isRecord(property) ? property : void 0;
 }
 function getStringProperty(value, key) {
 	const property = value[key];
 	return typeof property === "string" && property.trim().length > 0 ? property : void 0;
 }
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/format.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/format.ts
 function rewriteOllamaToolCallJsonError(message) {
 	if (!LLAMA_CPP_TOOL_CALL_PARSE_PATTERN.test(message)) return message;
 	return `Local Ollama model emitted malformed tool-call JSON and llama.cpp rejected it (HTTP 500). This is usually a deterministic model-output failure after context degradation, not a transient server outage; reload the model or reduce context, then retry.\n${message}`;
@@ -1439,7 +2079,7 @@ async function formatMessage(error, opts = {}) {
 	return message;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/finalize.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/finalize.ts
 /**
 * Build the complete error bundle for a provider catch block, replacing the
 * `stopReason` / `errorStatus` / `errorId` / `errorMessage` boilerplate.
@@ -1451,19 +2091,24 @@ async function formatMessage(error, opts = {}) {
 */
 async function finalize(error, opts = {}) {
 	const aborted = opts.abortTracker ? opts.abortTracker.wasCallerAbort() : opts.signal?.aborted === true;
-	const currentStatus = status(error) ?? opts.capturedErrorResponse?.status;
+	const errorStatus = status(error);
+	const currentStatus = errorStatus ?? opts.capturedErrorResponse?.status;
 	let message;
 	try {
 		message = (opts.abortTracker?.getLocalAbortReason())?.message ?? await formatMessage(error, opts);
 	} catch {
 		message = error instanceof Error ? error.message : String(error);
 	}
+	const classificationError = errorStatus === void 0 && currentStatus !== void 0 ? {
+		status: currentStatus,
+		cause: error
+	} : error;
 	return {
 		id: classifyMessage({
 			api: opts.api,
 			provider: opts.provider,
 			model: opts.model,
-			errorId: classify(error, opts.api),
+			errorId: classify(classificationError, opts.api),
 			errorMessage: message,
 			errorStatus: currentStatus
 		}),
@@ -1473,31 +2118,7 @@ async function finalize(error, opts = {}) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/provider.ts
-/**
-* A non-HTTP provider failure: a truncated stream, an error stop reason, an
-* empty body, a malformed envelope, or a runtime fault. For non-2xx HTTP
-* responses use {@link ProviderHttpError} (or a provider subclass) instead.
-*/
-var ProviderResponseError = class extends Error {
-	provider;
-	kind;
-	constructor(message, options = {}) {
-		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
-		this.name = "ProviderResponseError";
-		this.provider = options.provider;
-		this.kind = options.kind ?? "output";
-		if (this.kind === "content-blocked") attach(this, create(Flag.ContentBlocked));
-		else if (this.kind === "empty-output") attach(this, create(Flag.Transient, Flag.EmptyResponse));
-		else if (this.kind === "incomplete-stream" || this.kind === "empty-body") attach(this, create(Flag.Transient));
-	}
-};
-/** Non-2xx response from the Devin API. */
-var DevinApiError = class extends ProviderHttpError {
-	name = "DevinApiError";
-};
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/retryable.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/retryable.ts
 /**
 * Whether a numeric HTTP status is in the canonical transient/retryable set:
 * 408 (Request Timeout), 429 (Too Many Requests), and any 5xx.
@@ -1529,11 +2150,11 @@ function isProviderRetryableError(error) {
 	const httpStatus = status(error);
 	if (httpStatus !== void 0 && httpStatus >= 400 && httpStatus < 500 && httpStatus !== 408 && httpStatus !== 429) return false;
 	const msg = error.message.toLowerCase();
-	if (isUnexpectedSocketCloseMessage(msg) || isTransientTransportMessage(msg) || TRANSIENT_TRANSPORT_PATTERN.test(msg) || PROVIDER_TRANSIENT_EXTRA_PATTERN.test(msg) || isTransientStreamParseError(error) || isRetryableStreamEnvelopeError(error)) return true;
+	if (isUnexpectedSocketCloseMessage(msg) || isTransientTransportMessage(msg) || TRANSIENT_TRANSPORT_PATTERN.test(msg) || CODEX_HTTP_BODY_READ_ERROR_PATTERN.test(msg) || PROVIDER_TRANSIENT_EXTRA_PATTERN.test(msg) || isTransientStreamParseError(error) || isTransientStreamDropError(error) || isRetryableStreamEnvelopeError(error)) return true;
 	return isRetryableError(error);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/error/validation.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.12.6/node_modules/@oh-my-pi/pi-ai/src/error/validation.ts
 /**
 * Caller-supplied input failed validation before/while building a provider
 * request: bad request body, malformed tool arguments, unsupported content
@@ -1567,4 +2188,4 @@ var StreamTimeoutError = class extends Error {
 	}
 };
 //#endregion
-export { isTransientStreamParseError as A, OpenAIHttpError as B, classify as C, isFastModeUnsupported as D, is as E, AnthropicStreamEnvelopeError as F, fetchWithRetry as G, AwsCredentialsError as H, BedrockApiError as I, GeminiCliApiError as L, AnthropicApiError as M, AnthropicConnectionError as N, isGrammarError as O, AnthropicConnectionTimeoutError as P, GoogleApiError as R, attach as S, create as T, EventStreamFrameError as U, ProviderHttpError as V, extractHttpStatusFromError as W, AbortError as _, isTransientStatus as a, PYTHON_HTTP2_STREAM_RESET_PATTERN as b, finalize as c, getRetryAfterMsFromHeaders as d, OAuthError as f, OnPromptRequiredError as g, MissingApiKeyError as h, isProviderRetryableError as i, retriable as j, isStreamEnvelopeError as k, finalizeErrorMessage as l, LoginCancelledError as m, StreamTimeoutError as n, DevinApiError as o, ApiKeyRequiredError as p, ValidationError as r, ProviderResponseError as s, ConfigurationError as t, getHeadersFromError as u, Flag as v, classifyMessage as w, PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN as x, LLAMA_CPP_TOOL_CALL_PARSE_PATTERN as y, OllamaApiError as z };
+export { EventStreamFrameError as $, is as A, isUsageLimitStatus as B, LLAMA_CPP_TOOL_CALL_PARSE_PATTERN as C, classify as D, attach as E, isRequestBodyReadTimeout as F, BedrockApiError as G, AnthropicConnectionError as H, isStreamEnvelopeError as I, OllamaApiError as J, GeminiCliApiError as K, isTransientStreamParseError as L, isFastModeUnsupported as M, isGrammarError as N, classifyMessage as O, isImmutableLatestThinkingText as P, AwsCredentialsError as Q, retriable as R, Flag as S, PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN as T, AnthropicConnectionTimeoutError as U, AnthropicApiError as V, AnthropicStreamEnvelopeError as W, ProviderHttpError as X, OpenAIHttpError as Y, networkFailureError as Z, LoginCancelledError as _, isTransientStatus as a, AbortError as b, redactHeaders as c, createInBandProviderError as d, extractHttpStatusFromError as et, createInBandProviderErrorFromText as f, ApiKeyRequiredError as g, OAuthError as h, isProviderRetryableError as i, isCacheControlUnsupported as j, create as k, getHeadersFromError as l, ProviderResponseError as m, StreamTimeoutError as n, fetchWithRetry as nt, finalize as o, DevinApiError as p, GoogleApiError as q, ValidationError as r, isUnexpectedSocketCloseMessage as rt, finalizeErrorMessage as s, ConfigurationError as t, extractRetryHint as tt, getRetryAfterMsFromHeaders as u, MissingApiKeyError as v, PYTHON_HTTP2_STREAM_RESET_PATTERN as w, CODEX_NATIVE_LANE_STEER_REJECTED_CODE as x, OnPromptRequiredError as y, status as z };