@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.3

package/lib/error-B3bevhrs.mjs

@@ -0,0 +1,1449 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { J as getLogsDir, R as isBunTestRuntime } from "./src-DTid0g4K.mjs";
+import * as path from "node:path";
+import { scheduler } from "node:timers/promises";
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/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;
+/**
+* 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)
+*  - `Retry-After` (numeric seconds, or HTTP date)
+*  - `x-ratelimit-reset-ms` (delta ms, or Unix epoch ms/s for large values)
+*  - `x-ratelimit-reset` (Unix epoch seconds)
+*  - `x-ratelimit-reset-after` (seconds)
+*
+* Body patterns:
+*  - `Your quota will reset after 18h31m10s` / `10m15s` / `39s`
+*  - `Please retry in 250ms` / `Please retry in 12s`
+*  - `"retryDelay": "34.074824224s"` (JSON error detail field)
+*  - `try again in 250ms` / `try again in 12s` / `try again in 5 min` / `try again in ~158 min`
+*
+* Returns `undefined` if no signal is found.
+*/
+function extractRetryHint(source, body) {
+	const headers = source instanceof Headers ? source : source?.headers ?? void 0;
+	if (headers) {
+		const retryAfterMs = headers.get("retry-after-ms");
+		if (retryAfterMs) {
+			const ms = Number(retryAfterMs);
+			if (Number.isFinite(ms) && ms >= 0) return ms;
+		}
+		const retryAfter = headers.get("retry-after");
+		if (retryAfter) {
+			const seconds = Number(retryAfter);
+			if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+			const parsedDate = Date.parse(retryAfter);
+			if (!Number.isNaN(parsedDate)) return Math.max(0, parsedDate - Date.now());
+		}
+		const rateLimitResetMs = headers.get("x-ratelimit-reset-ms");
+		if (rateLimitResetMs) {
+			const value = Number(rateLimitResetMs);
+			if (Number.isFinite(value) && value > 0) {
+				const targetMs = value > 0xe8d4a51000 ? value : value > 1e9 ? value * 1e3 : void 0;
+				if (targetMs === void 0) return value;
+				const delta = targetMs - Date.now();
+				if (delta > 0) return delta;
+			}
+		}
+		const rateLimitReset = headers.get("x-ratelimit-reset");
+		if (rateLimitReset) {
+			const resetSeconds = Number.parseInt(rateLimitReset, 10);
+			if (!Number.isNaN(resetSeconds)) {
+				const delta = resetSeconds * 1e3 - Date.now();
+				if (delta > 0) return delta;
+			}
+		}
+		const rateLimitResetAfter = headers.get("x-ratelimit-reset-after");
+		if (rateLimitResetAfter) {
+			const seconds = Number(rateLimitResetAfter);
+			if (Number.isFinite(seconds) && seconds > 0) return seconds * 1e3;
+		}
+	}
+	if (!body) return void 0;
+	const quotaMatch = QUOTA_RESET_PATTERN.exec(body);
+	if (quotaMatch) {
+		const hours = quotaMatch[1] ? Number.parseInt(quotaMatch[1], 10) : 0;
+		const minutes = quotaMatch[2] ? Number.parseInt(quotaMatch[2], 10) : 0;
+		const seconds = Number.parseFloat(quotaMatch[3]);
+		if (!Number.isNaN(seconds)) {
+			const totalMs = ((hours * 60 + minutes) * 60 + seconds) * 1e3;
+			if (totalMs > 0) return totalMs;
+		}
+	}
+	for (const pattern of [
+		WILL_RESET_IN_PATTERN,
+		PLEASE_RETRY_PATTERN,
+		RETRY_DELAY_FIELD_PATTERN,
+		TRY_AGAIN_PATTERN
+	]) {
+		const match = pattern.exec(body);
+		if (match?.[1]) {
+			const value = Number.parseFloat(match[1]);
+			if (Number.isFinite(value) && value > 0) {
+				const unitMs = unitToMs(match[2]);
+				if (unitMs !== void 0) return value * unitMs;
+			}
+		}
+	}
+}
+function unitToMs(unit) {
+	switch (unit.toLowerCase()) {
+		case "ms": return 1;
+		case "s":
+		case "sec": return 1e3;
+		case "m":
+		case "min":
+		case "mins":
+		case "minute":
+		case "minutes": return 6e4;
+		case "h":
+		case "hr":
+		case "hrs":
+		case "hour":
+		case "hours": return 36e5;
+		default: return;
+	}
+}
+const DEFAULT_MAX_DELAY_MS = 6e4;
+const DEFAULT_MAX_ATTEMPTS = 5;
+/**
+* Fetch with bounded retries and sensible defaults. Retries on any
+* `isRetryableStatus` (5xx, 408, 429) and on transient network errors. Server
+* `Retry-After`/quota hints are honoured up to `maxDelayMs`; a hint that exceeds
+* the cap returns the current response so the caller can fail fast. Aborts on
+* `init.signal` propagate as `"Request was aborted"`.
+*
+* The caller is responsible for inspecting `!response.ok` once the call returns.
+*/
+async function fetchWithRetry(url, options = {}) {
+	const { maxAttempts = DEFAULT_MAX_ATTEMPTS, maxDelayMs = DEFAULT_MAX_DELAY_MS, defaultDelayMs, prepareInit, shouldRetryResponse, fetch: fetchImpl = fetch, timeout = false, ...baseInit } = options;
+	const signal = baseInit.signal;
+	for (let attempt = 0;; attempt++) {
+		if (signal?.aborted) throw new Error("Request was aborted");
+		const requestUrl = typeof url === "function" ? url(attempt) : url;
+		const init = prepareInit ? mergeInit(baseInit, await prepareInit(attempt), timeout) : "timeout" in options ? {
+			...baseInit,
+			timeout
+		} : baseInit;
+		let response;
+		try {
+			response = await fetchImpl(requestUrl, init);
+		} catch (error) {
+			if (signal?.aborted) throw new Error("Request was aborted");
+			const wrapped = wrapNetworkError(error);
+			if (attempt + 1 >= maxAttempts) throw wrapped;
+			await waitForRetry(resolveDefaultDelay(defaultDelayMs, attempt, maxDelayMs), signal);
+			continue;
+		}
+		if (!isRetryableStatus(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);
+	}
+}
+function mergeInit(base, overlay, timeout) {
+	const merged = {
+		...base,
+		...overlay,
+		timeout
+	};
+	if (base.headers || overlay.headers) {
+		const baseHeaders = new Headers(base.headers ?? void 0);
+		new Headers(overlay.headers ?? void 0).forEach((value, key) => {
+			baseHeaders.set(key, value);
+		});
+		merged.headers = baseHeaders;
+	}
+	return merged;
+}
+async function waitForRetry(delayMs, signal) {
+	try {
+		await scheduler.wait(delayMs, { signal });
+	} catch (error) {
+		if (signal?.aborted) throw new Error("Request was aborted");
+		throw error;
+	}
+}
+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}`);
+		return error;
+	}
+	return new Error(String(error));
+}
+function resolveDefaultDelay(option, attempt, maxDelayMs) {
+	if (option === void 0) return Math.min(500 * 2 ** attempt, maxDelayMs);
+	if (typeof option === "number") return Math.min(option, maxDelayMs);
+	if (typeof option === "function") return Math.min(option(attempt), maxDelayMs);
+	return Math.min(option[Math.min(attempt, option.length - 1)] ?? 0, maxDelayMs);
+}
+/**
+* Inspect an arbitrary error value (or its `cause` chain, up to depth 2) for an
+* HTTP status code. Reads `status`, `statusCode`, and `response.status` fields,
+* coerces string values, and falls back to scanning the error message for
+* common patterns like `Error: 401`, `error (429)`, or `HTTP 503`.
+*/
+function extractHttpStatusFromError(error) {
+	return extractHttpStatusFromErrorInternal(error, 0);
+}
+function extractHttpStatusFromErrorInternal(error, depth) {
+	if (!error || typeof error !== "object" || depth > 2) return void 0;
+	const info = error;
+	const rawStatus = info.status ?? info.statusCode ?? info.response?.status;
+	let status;
+	if (typeof rawStatus === "number" && Number.isFinite(rawStatus)) status = rawStatus;
+	else if (typeof rawStatus === "string") {
+		const parsed = Number(rawStatus);
+		if (Number.isFinite(parsed)) status = parsed;
+	}
+	if (status !== void 0 && status >= 100 && status <= 599) return status;
+	if (info.message) {
+		const extracted = extractStatusFromMessage(info.message);
+		if (extracted !== void 0) return extracted;
+	}
+	if (info.cause) return extractHttpStatusFromErrorInternal(info.cause, depth + 1);
+}
+const STATUS_MESSAGE_PATTERNS$1 = [
+	/\berror\s*[:=]\s*(\d{3})\b/i,
+	/error\s*\((\d{3})\)/i,
+	/status\s*[:=]?\s*(\d{3})/i,
+	/\bhttp\s*(\d{3})\b/i,
+	/\b(\d{3})\s*(?:status|error)\b/i
+];
+function extractStatusFromMessage(message) {
+	for (const pattern of STATUS_MESSAGE_PATTERNS$1) {
+		const match = pattern.exec(message);
+		if (!match) continue;
+		const value = Number(match[1]);
+		if (Number.isFinite(value) && value >= 100 && value <= 599) return value;
+	}
+}
+/**
+* `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) {
+	return status >= 500 || status === 408 || status === 429;
+}
+/**
+* `true` if the message describes an unexpected socket closure — Bun and some
+* proxies surface these for any HTTP/2 stream reset.
+*/
+function isUnexpectedSocketCloseMessage(message) {
+	return /\b(?:the\s+)?socket connection (?:was )?closed unexpectedly\b/i.test(message);
+}
+const TRANSIENT_MESSAGE_PATTERN = /overloaded|rate.?limit|too many requests|service.?unavailable|server error|internal error|connection.?error|unable to connect|fetch failed|network error|stream stall|other side closed|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)/i;
+const VALIDATION_MESSAGE_PATTERN = /invalid|validation|bad request|unsupported|schema|missing required|not found|unauthorized|forbidden/i;
+/**
+* Identify errors that should be retried: aborts/timeouts in the error name or
+* message, retryable HTTP statuses (see `isRetryableStatus`), unexpected socket
+* closes, and the standard transient phrases. 4xx statuses other than 408/429
+* and validation-shaped messages short-circuit to `false`.
+*/
+function isRetryableError(error) {
+	const info = error;
+	const message = info?.message ?? "";
+	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 (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@17.3.5/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;
+	constructor(message, kind, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "AwsCredentialsError";
+		this.kind = kind;
+	}
+};
+/** A malformed AWS event-stream frame (bad length, CRC mismatch, unknown header type). */
+var EventStreamFrameError = class extends Error {
+	constructor(detail) {
+		super(`eventstream: ${detail}`);
+		this.name = "EventStreamFrameError";
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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. */
+var ProviderHttpError = class extends Error {
+	status;
+	headers;
+	code;
+	constructor(message, status, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "ProviderHttpError";
+		this.status = status;
+		this.headers = options?.headers;
+		this.code = options?.code;
+	}
+};
+/** Non-2xx response from an OpenAI-wire endpoint, with the decoded body attached. */
+var OpenAIHttpError = class extends ProviderHttpError {
+	captured;
+	constructor(message, captured, code, cause) {
+		super(message, captured.status, {
+			headers: captured.headers,
+			code,
+			cause
+		});
+		this.name = "OpenAIHttpError";
+		this.captured = captured;
+	}
+	/**
+	* Pull a human-readable message and machine code out of an OpenAI-style error
+	* envelope (`{ error: { message, code, type } }`), tolerating the flat shapes
+	* compat hosts return (`{ error: "..." }`, `{ message: "..." }`) and falling
+	* back to the raw body text.
+	*/
+	static parseEnvelope(bodyJson, bodyText) {
+		if (typeof bodyJson === "object" && bodyJson !== null) {
+			const envelope = bodyJson;
+			const error = envelope.error;
+			if (typeof error === "object" && error !== null) {
+				const { message, code, type } = error;
+				return {
+					detail: typeof message === "string" && message.length > 0 ? message : bodyText,
+					code: typeof code === "string" ? code : typeof type === "string" ? type : void 0
+				};
+			}
+			if (typeof error === "string" && error.length > 0) return {
+				detail: error,
+				code: void 0
+			};
+			if (typeof envelope.message === "string" && envelope.message.length > 0) return {
+				detail: envelope.message,
+				code: void 0
+			};
+		}
+		return {
+			detail: bodyText,
+			code: void 0
+		};
+	}
+};
+/** Non-2xx response from the Anthropic API. */
+const DEFAULT_ANTHROPIC_ERROR_BODY_READ_TIMEOUT_MS = 5e3;
+const MAX_ANTHROPIC_ERROR_BODY_BYTES = 65536;
+const ANTHROPIC_ERROR_BODY_TRUNCATION_MARKER = "\n[Response body truncated after 64 KiB]";
+let anthropicErrorBodyReadTimeoutMs = DEFAULT_ANTHROPIC_ERROR_BODY_READ_TIMEOUT_MS;
+/** Non-2xx response from the Anthropic API. */
+var AnthropicApiError = class AnthropicApiError extends ProviderHttpError {
+	requestId;
+	constructor(status, message, headers) {
+		super(message, status, { headers });
+		this.name = "AnthropicApiError";
+		this.requestId = headers.get("request-id");
+	}
+	static async fromResponse(response, signal) {
+		const reader = response.body?.locked ? void 0 : response.body?.getReader();
+		if (!reader) {
+			if (signal?.aborted) throw new AbortError("Request was aborted.");
+			return new AnthropicApiError(response.status, `${response.status} status code (no body)`, response.headers);
+		}
+		let aborted = false;
+		let timedOut = false;
+		let readerCancelled = false;
+		const cancelReader = () => {
+			if (readerCancelled) return;
+			readerCancelled = true;
+			reader.cancel().catch(() => {});
+		};
+		const onAbort = () => {
+			if (aborted) return;
+			aborted = true;
+			cancelReader();
+		};
+		if (signal?.aborted) onAbort();
+		else signal?.addEventListener("abort", onAbort, { once: true });
+		const deadline = performance.now() + anthropicErrorBodyReadTimeoutMs;
+		let timeout;
+		timeout = setTimeout(() => {
+			timedOut = true;
+			cancelReader();
+		}, anthropicErrorBodyReadTimeoutMs);
+		let capturedBytes = 0;
+		let truncated = false;
+		const bodyChunks = [];
+		try {
+			const decoder = new TextDecoder();
+			let cleanEof = false;
+			while (!aborted && !timedOut) {
+				if (performance.now() >= deadline) {
+					timedOut = true;
+					cancelReader();
+					break;
+				}
+				let result;
+				try {
+					result = await reader.read();
+				} catch {
+					break;
+				}
+				if (aborted || timedOut) break;
+				if (result.done) {
+					cleanEof = true;
+					break;
+				}
+				const chunk = result.value;
+				if (!chunk) break;
+				const bytesToCapture = Math.min(MAX_ANTHROPIC_ERROR_BODY_BYTES - capturedBytes, chunk.byteLength);
+				if (bytesToCapture > 0) {
+					bodyChunks.push(decoder.decode(chunk.subarray(0, bytesToCapture), { stream: true }));
+					capturedBytes += bytesToCapture;
+				}
+				if (bytesToCapture < chunk.byteLength) {
+					truncated = true;
+					cancelReader();
+					break;
+				}
+			}
+			if (aborted || signal?.aborted) throw new AbortError("Request was aborted.");
+			if (cleanEof) bodyChunks.push(decoder.decode());
+			if (truncated) bodyChunks.push(ANTHROPIC_ERROR_BODY_TRUNCATION_MARKER);
+		} finally {
+			if (timeout !== void 0) clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+			reader.releaseLock();
+		}
+		const detail = bodyChunks.join("").trim() || "status code (no body)";
+		return new AnthropicApiError(response.status, `${response.status} ${detail}`, response.headers);
+	}
+};
+/** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
+var AnthropicConnectionError = class extends Error {
+	constructor(cause) {
+		super("Connection error.", { cause });
+		this.name = "AnthropicConnectionError";
+	}
+};
+/** No response headers arrived within the configured request timeout. */
+var AnthropicConnectionTimeoutError = class extends Error {
+	constructor() {
+		super("Request timed out.");
+		this.name = "AnthropicConnectionTimeoutError";
+	}
+};
+/**
+* A malformed Anthropic SSE stream envelope — events arriving out of order
+* (before `message_start`) or otherwise violating the message-event grammar.
+* The message is prefixed with {@link STREAM_ENVELOPE_ERROR_PREFIX} so the
+* shared envelope predicates classify it.
+*/
+var AnthropicStreamEnvelopeError = class extends Error {
+	constructor(detail) {
+		super(`${STREAM_ENVELOPE_ERROR_PREFIX} ${detail}`);
+		this.name = "AnthropicStreamEnvelopeError";
+	}
+};
+/** Non-2xx response (or in-stream exception event) from the Bedrock runtime API. */
+var BedrockApiError = class extends ProviderHttpError {
+	name = "BedrockApiError";
+};
+/** Non-2xx response (or in-stream error chunk) from the Cloud Code Assist API. */
+var GeminiCliApiError = class extends ProviderHttpError {
+	name = "GeminiCliApiError";
+};
+/** Non-2xx response (or in-stream error chunk) from the Google Generative Language / Vertex API. */
+var GoogleApiError = class extends ProviderHttpError {
+	name = "GoogleApiError";
+};
+/** Non-2xx response from the Ollama `/api/chat` endpoint. */
+var OllamaApiError = class extends ProviderHttpError {
+	name = "OllamaApiError";
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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 SPEND_LIMIT_PATTERN = /spend.?limit/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) {
+	return SUBSCRIPTION_CAP_PATTERN.test(errorMessage) && !TRANSIENT_INTERVAL_RATE_LIMIT_PATTERN.test(errorMessage);
+}
+const OPENROUTER_DAILY_FREE_LIMIT_PATTERN = /\bfree[-_ ]models[-_ ]per[-_ ]day\b/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_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;
+const DASHSCOPE_TOKEN_LIMIT_MESSAGE_PATTERN = /\byou exceeded your current quota, please check your plan and billing details\b/i;
+/** True for DashScope/Bailian's documented OpenAI-compatible TPM/TPS throttle. */
+function isDashScopeTokenLimitText(errorMessage) {
+	return DASHSCOPE_TOKEN_LIMIT_DOC_PATTERN.test(errorMessage) && DASHSCOPE_TOKEN_LIMIT_MESSAGE_PATTERN.test(errorMessage);
+}
+const GOOGLE_RPC_ERROR_INFO_TYPE = "type.googleapis.com/google.rpc.ErrorInfo";
+const LONG_RATE_LIMIT_DELAY_MS = 3e5;
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function parseJsonBody(errorMessage) {
+	const start = errorMessage.indexOf("{");
+	const end = errorMessage.lastIndexOf("}");
+	if (start < 0 || end < start) return void 0;
+	try {
+		return asRecord(JSON.parse(errorMessage.slice(start, end + 1)));
+	} catch {
+		return;
+	}
+}
+/**
+* Classify structured Google RESOURCE_EXHAUSTED bodies before consulting text.
+* Cloud Code Assist prefixes the JSON with its HTTP error label, so accept an
+* embedded top-level object as well as a raw JSON body.
+*/
+function parseGoogleRpcRateLimitReason(errorMessage) {
+	const error = asRecord(parseJsonBody(errorMessage)?.error);
+	if (typeof error?.status !== "string" || error.status.trim().toUpperCase() !== "RESOURCE_EXHAUSTED") return;
+	if (!Array.isArray(error.details)) return void 0;
+	for (const value of error.details) {
+		const detail = asRecord(value);
+		if (detail?.["@type"] !== GOOGLE_RPC_ERROR_INFO_TYPE || typeof detail.reason !== "string") continue;
+		switch (detail.reason.trim().toUpperCase()) {
+			case "QUOTA_EXHAUSTED": return "QUOTA_EXHAUSTED";
+			case "INSUFFICIENT_G1_CREDITS_BALANCE": return "INSUFFICIENT_G1_CREDITS_BALANCE";
+			case "RATE_LIMIT_EXCEEDED": {
+				const retryDelayMs = extractRetryHint(void 0, errorMessage);
+				return retryDelayMs !== void 0 && retryDelayMs >= LONG_RATE_LIMIT_DELAY_MS ? "QUOTA_EXHAUSTED" : "RATE_LIMIT_EXCEEDED";
+			}
+		}
+	}
+}
+function isQuotaExhaustedReason(reason) {
+	return reason === "QUOTA_EXHAUSTED" || reason === "INSUFFICIENT_G1_CREDITS_BALANCE";
+}
+/**
+* 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.
+*
+* Bare "resource exhausted" / "resource_exhausted" maps to MODEL_CAPACITY (transient, short wait).
+* Explicit details such as "quota exceeded" retain their normal classification.
+*/
+function parseRateLimitReason(errorMessage) {
+	const structuredReason = parseGoogleRpcRateLimitReason(errorMessage);
+	if (structuredReason !== void 0) return structuredReason;
+	const lowerWithStatus = errorMessage.toLowerCase();
+	const lower = lowerWithStatus.replace(RESOURCE_EXHAUSTED_PATTERN, "");
+	const hasResourceExhaustedStatus = lower !== lowerWithStatus;
+	if (lower.includes("quota will reset") || lower.includes("exhausted your capacity")) return "QUOTA_EXHAUSTED";
+	if (CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (isDashScopeTokenLimitText(errorMessage)) return "RATE_LIMIT_EXCEEDED";
+	if (CONCURRENT_LIMIT_PATTERN.test(errorMessage)) return "CONCURRENT_LIMIT";
+	if (lower.includes("capacity") || lower.includes("overloaded") || lower.includes("529") || lower.includes("503")) return "MODEL_CAPACITY_EXHAUSTED";
+	if (ACCOUNT_RATE_LIMIT_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (SPEND_LIMIT_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (matchesSubscriptionCapText(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (OPENROUTER_DAILY_FREE_LIMIT_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)) 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/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 is categorically an account-billing cap (xAI
+* Grok Build "usage balance exhausted", DeepSeek "Insufficient Balance",
+* OpenRouter credit exhaustion) — never a transient blip or bad credential.
+* Always combine with {@link isUsageLimitOutcome} when a message is available
+* — a 429 carrying transient rate-limit wording is NOT a usage cap.
+*/
+function isUsageLimitStatus(status) {
+	return status === 429 || status === 402;
+}
+/**
+* A usage-limit status body is opaque when it carries no signal beyond the
+* status itself — empty, whitespace-only, the status digits with HTTP/JSON
+* framing, or generic punctuation. Anything else (retry hints, capacity
+* wording, error descriptions) is informative enough to defer to the
+* classifier.
+*/
+function isOpaqueStatusBody(message) {
+	const cleaned = message.replace(/\b(?:429|402)\b/g, "").replace(/\b(?:http|https|status|error|code|response|message)\b/gi, "");
+	return !/[a-z\d]{3,}/i.test(cleaned) && !CN_QUOTA_EXHAUSTED_PATTERN.test(cleaned) && !CN_TRANSIENT_CAP_PATTERN.test(cleaned) && !CN_THROTTLE_PATTERN.test(cleaned);
+}
+/**
+* Internal text matcher for usage/quota-limit phrasing. NOT part of the public
+* API — callers classify through {@link import("./flags").isUsageLimit} (the
+* flag accessor). `flags.ts` consumes this to populate `Flag.UsageLimit`, and
+* {@link isUsageLimitOutcome} uses it for the account-rotation decision.
+*/
+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) || 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
+* trailer): "Reached overall message rate limit", "Your limit will reset in …".
+* Kept separate from {@link matchesUsageLimitText} because the bare wording is
+* ambiguous without the 403 / statusless-account context; consumed by both
+* {@link isUsageLimitOutcome} (rotation decision) and `flags.ts` (Flag.UsageLimit).
+*/
+function isAccountScopedCapText(message) {
+	return ACCOUNT_SCOPED_403_PATTERN.test(message);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/error/flags.ts
+const Flag = {
+	Class: 4096,
+	ThinkingLoop: 65536,
+	Transient: 131072,
+	Timeout: 262144,
+	UsageLimit: 524288,
+	StaleResponsesItem: 1048576,
+	MalformedFunctionCall: 2097152,
+	ProviderFinishError: 4194304,
+	EmptyResponse: 8192,
+	ContentBlocked: 32768,
+	/** Account-scoped provider policy denial that may succeed with another credential. */
+	AccountPolicy: 16384,
+	ContextOverflow: 8388608,
+	AuthFailed: 16777216,
+	SilentAbort: 33554432,
+	UserInterrupt: 67108864,
+	Abort: 134217728,
+	/** Strict-tool rejection (400): grammar too large, schema too complex, or structured outputs unsupported by the model/endpoint. */
+	Grammar: 268435456,
+	/** Anthropic model/account does not support fast mode / the `speed` parameter. */
+	FastModeUnsupported: 536870912,
+	/** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
+	OAuthExpiry: 1073741824
+};
+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.SilentAbort | Flag.UserInterrupt | Flag.Abort | Flag.Grammar | Flag.FastModeUnsupported | Flag.OAuthExpiry;
+const RETRIABLE_KINDS = Flag.Transient | Flag.UsageLimit | Flag.ThinkingLoop | Flag.StaleResponsesItem | Flag.ProviderFinishError | Flag.EmptyResponse;
+const OVERFLOW_PATTERNS = [
+	/prompt is too long/i,
+	/input is too long for requested model/i,
+	/exceeds the context window/i,
+	/input token count.*exceeds the maximum/i,
+	/maximum prompt length is \d+/i,
+	/reduce the length of the messages/i,
+	/maximum context length is \d+ tokens/i,
+	/exceeds the limit of \d+/i,
+	/exceeds the available context size/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,
+	/requested tokens?.*(exceeds?|greater than).*(n_ctx|context)/i,
+	/greater than the context length/i,
+	/context window exceeds limit/i,
+	/exceeded model token limit/i,
+	/context[_ ]length[_ ]exceeded/i,
+	/too many tokens/i,
+	/token limit exceeded/i,
+	/request_too_large/i,
+	/request exceeds the maximum size/i,
+	/payload too large/i,
+	/entity too large/i,
+	/\b413\b.*\b(request|payload|entity)\b.*\btoo large\b/i,
+	/model_context_window_exceeded/i,
+	/prompt filled the context window/i
+];
+const OVERFLOW_NO_BODY_PATTERN = /\b4(00|13)\s*(status code)?\s*\(no body\)/i;
+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_BEFORE_START_PATTERN = /before message_start/i;
+const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
+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|429|500|502|503|504|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;
+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 STALE_RESPONSE_ITEM_PATTERNS = [/\bItem with id ['"][^'"]+['"] not found\.?/i, /previous[ _]?response/i];
+const STALE_RESPONSE_ITEM_DETAIL_PATTERN = /not[ _]?found|invalid|expired|stale|zero[ _-]?data[ _-]?retention/i;
+/**
+* Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
+* The model emitted invalid JSON in a tool call and the server returned HTTP 500
+* with this exact text — replaying the same prompt yields the same malformed
+* output, so callers strip {@link Flag.Transient} when this matches.
+*/
+const LLAMA_CPP_TOOL_CALL_PARSE_PATTERN = /failed to parse tool call arguments as json|\[json\.exception\.parse_error\.101\]/i;
+const COPILOT_TRANSIENT_MODEL_CODES = { model_not_supported: true };
+const COPILOT_TRANSIENT_MODEL_PATTERN = /model_not_supported/i;
+const GRAMMAR_TOO_LARGE_PATTERN = /compiled grammar/i;
+const GRAMMAR_TOO_LARGE_DETAIL_PATTERN = /too large/i;
+const SCHEMA_TOO_COMPLEX_PATTERN = /schema/i;
+const SCHEMA_TOO_COMPLEX_DETAIL_PATTERN = /too complex/i;
+const SCHEMA_COMPILE_PATTERN = /compil/i;
+const INVALID_REQUEST_PATTERN = /invalid_request_error/i;
+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 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;
+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 (!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);
+	return grammarTooLarge || schemaTooComplex;
+}
+function matchesFastModeUnsupported(message, errorStatus) {
+	if (errorStatus !== 400 && errorStatus !== 429) return false;
+	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);
+}
+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.SilentAbort, Flag.UserInterrupt, Flag.Abort;
+const STATUS_MESSAGE_PATTERNS = [
+	/\bstatus(?:_code)?[:=]\s*(\d{3})\b/i,
+	/\bstatus\s+(\d{3})\b/i,
+	/\bHTTP\s+(\d{3})\b/i,
+	/\b(?:error|failed)\s*[:=]?\s*(\d{3})\b/i,
+	/(?:^|\s)(\d{3})\s+(?:[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)/
+];
+function create(...flags) {
+	let bits = 0;
+	for (const f of flags) bits |= f;
+	return bits | Flag.Class;
+}
+function is(id, flag) {
+	return ((id ?? 0) & flag) !== 0;
+}
+function retriable(id, opts) {
+	if (is(id, Flag.ContentBlocked)) return false;
+	if (opts?.replayUnsafe) return false;
+	if (is(id, Flag.MalformedFunctionCall)) return true;
+	return ((id ?? 0) & RETRIABLE_KINDS) !== 0;
+}
+function isClassified(id) {
+	return ((id ?? 0) & Flag.Class) !== 0;
+}
+function statusFromId(id) {
+	return id && !isClassified(id) ? id : void 0;
+}
+function status(error) {
+	return statusInternal(error, 0);
+}
+function statusInternal(error, depth) {
+	if (depth > 2 || error === void 0 || error === null) return void 0;
+	if (typeof error === "object") {
+		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.response === "object" && errObj.response !== null) {
+			const resp = errObj.response;
+			if (typeof resp.status === "number" && resp.status >= 100 && resp.status <= 599) return resp.status;
+		}
+		if ("cause" in errObj) {
+			const nested = statusInternal(errObj.cause, depth + 1);
+			if (nested !== void 0) return nested;
+		}
+	}
+	if (error instanceof Error || typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string") for (const pattern of STATUS_MESSAGE_PATTERNS) {
+			const match = pattern.exec(message);
+			if (match) {
+				const code = parseInt(match[1], 10);
+				if (code >= 100 && code <= 599) return code;
+			}
+		}
+	}
+}
+function isStreamReadErrorText(text) {
+	return STREAM_READ_ERROR_PATTERN.test(text);
+}
+function isTransientErrorText(text) {
+	return isUnexpectedSocketCloseMessage(text) || isStreamReadErrorText(text) || TRANSIENT_ENVELOPE_PATTERN.test(text) && TRANSIENT_ENVELOPE_BEFORE_START_PATTERN.test(text) || TRANSIENT_TRANSPORT_PATTERN.test(text);
+}
+function isTimeoutText(text) {
+	return TIMEOUT_PATTERN.test(text);
+}
+function isAuthFailureText(text) {
+	return AUTH_FAILURE_PATTERN.test(text);
+}
+function isStaleResponsesText(text) {
+	return STALE_RESPONSE_ITEM_PATTERNS[0].test(text) || STALE_RESPONSE_ITEM_PATTERNS[1].test(text) && STALE_RESPONSE_ITEM_DETAIL_PATTERN.test(text);
+}
+function isMalformedFunctionCallText(text) {
+	return MALFORMED_FUNCTION_CALL_PATTERN.test(text);
+}
+function isProviderFinishErrorText(text) {
+	return PROVIDER_FINISH_ERROR_PATTERN.test(text);
+}
+function isContentBlockedText(text) {
+	return CONTENT_FILTER_PATTERN.test(text);
+}
+function matchesOverflowText(text) {
+	return OVERFLOW_PATTERNS.some((p) => p.test(text)) || OVERFLOW_NO_BODY_PATTERN.test(text);
+}
+function classifyText(errorMessage, errorStatus, api) {
+	let kinds = 0;
+	if (errorMessage) {
+		if (matchesOverflowText(errorMessage)) kinds |= Flag.ContextOverflow;
+		if (isMalformedFunctionCallText(errorMessage)) kinds |= Flag.MalformedFunctionCall;
+		if (isProviderFinishErrorText(errorMessage)) kinds |= Flag.ProviderFinishError;
+		if (EMPTY_RESPONSE_PATTERN.test(errorMessage)) kinds |= Flag.EmptyResponse | Flag.Transient;
+		if (isContentBlockedText(errorMessage)) kinds |= Flag.ContentBlocked;
+		if (ACCOUNT_POLICY_PATTERN.test(errorMessage)) kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
+		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 isBillingCapStatus = statusClean === 402;
+		if (!(reason === "CONCURRENT_LIMIT" && !isBillingCapStatus) && (matchesUsageLimitText(cleanMessage) || (statusClean === 403 || statusClean === void 0) && isAccountScopedCapText(cleanMessage) || isLimitStatus && (isOpaque || reason === "QUOTA_EXHAUSTED" || isBillingCapStatus && reason === "CONCURRENT_LIMIT"))) kinds |= Flag.UsageLimit;
+		if (isTimeoutText(errorMessage)) kinds |= Flag.Transient | Flag.Timeout;
+		else if (isTransientErrorText(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 (statusClean === 400 && COPILOT_TRANSIENT_MODEL_PATTERN.test(cleanMessage)) kinds |= Flag.Transient;
+		if (matchesStrictToolsRejection(cleanMessage, statusClean)) kinds |= Flag.Grammar;
+		if (matchesFastModeUnsupported(cleanMessage, statusClean)) kinds |= Flag.FastModeUnsupported;
+	}
+	if (kinds !== 0) return create(kinds);
+	const fallbackStatus = errorStatus ?? (errorMessage ? status({ message: errorMessage }) : void 0);
+	if (fallbackStatus === 401 || fallbackStatus === 403) return create(Flag.AuthFailed);
+	return fallbackStatus ?? 0;
+}
+function classify(error, api) {
+	let kinds = 0;
+	const seen = /* @__PURE__ */ new Set();
+	let link = error;
+	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 (link instanceof AwsCredentialsError) kinds |= Flag.AuthFailed;
+		else if (link instanceof AnthropicConnectionTimeoutError) kinds |= Flag.Timeout | Flag.Transient;
+		else if (link instanceof AnthropicConnectionError) kinds |= Flag.Transient;
+		else if (typeof link === "object" && "name" in link && link.name === "CodexWebSocketTransportError") kinds |= Flag.Transient;
+		else if (link instanceof Error && link.name === "CodexProviderStreamError" && "retryable" in link && link.retryable === true) kinds |= Flag.Transient;
+		else if (link instanceof ProviderHttpError) {
+			let linkKinds = 0;
+			const { status: codeStatus, code } = link;
+			if (code === "usage_limit_reached" || code === "insufficient_quota" && !isDashScopeTokenLimitText(link.message)) linkKinds |= Flag.UsageLimit;
+			if (code === "overloaded_error" || code === "rate_limit_error") linkKinds |= Flag.Transient;
+			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;
+			} else if (codeStatus >= 500) linkKinds |= Flag.Transient;
+			kinds |= linkKinds;
+		}
+		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), api);
+		kinds |= textId & KIND_MASK;
+		link = typeof link === "object" && "cause" in link ? link.cause : void 0;
+	}
+	return kinds !== 0 ? create(kinds) : status(error) ?? 0;
+}
+/**
+* Whether an error (or message string) classifies as an account usage/quota
+* limit — the persistent, credential-rotation-worthy kind. This is the public
+* accessor for {@link Flag.UsageLimit}; prefer it over re-running message
+* regexes at call sites.
+*/
+function isUsageLimit(error, api) {
+	return is(classify(error, api), Flag.UsageLimit);
+}
+/**
+* Strict-tool rejection: grammar too large, schema too complex, or structured
+* outputs unsupported by the model/endpoint.
+* Accessor for {@link Flag.Grammar}.
+*/
+function isGrammarError(error) {
+	return is(classify(error), Flag.Grammar);
+}
+/**
+* Anthropic model/account does not support fast mode / the `speed` parameter.
+* Accessor for {@link Flag.FastModeUnsupported}.
+*/
+function isFastModeUnsupported(error) {
+	return is(classify(error), Flag.FastModeUnsupported);
+}
+/**
+* Depth-bounded search for a provider error `code`. SDK error objects keep the
+* parsed response body on `.error`, and Copilot's body is itself
+* `{ error: { code } }`, so the code sits up to two envelopes below the thrown
+* error depending on which SDK produced it.
+*/
+function providerErrorCode(error) {
+	let node = error;
+	for (let depth = 0; depth < 3; depth++) {
+		if ("code" in node && typeof node.code === "string") return node.code;
+		if (!("error" in node)) return void 0;
+		const nested = node.error;
+		if (!nested || typeof nested !== "object") return void 0;
+		node = nested;
+	}
+}
+/**
+* GitHub Copilot 400 `model_not_supported` response for a model advertised by
+* `/models` — transient fleet skew, not a malformed request. Reads the
+* structural `code` through the SDK/body envelopes, then falls back to the
+* stringified body both SDK families put in `message`.
+*/
+function isCopilotTransientModelError(error) {
+	if (!error || typeof error !== "object" || status(error) !== 400) return false;
+	const code = providerErrorCode(error);
+	if (code !== void 0 && Object.hasOwn(COPILOT_TRANSIENT_MODEL_CODES, code)) return true;
+	const message = "message" in error ? error.message : void 0;
+	return typeof message === "string" && COPILOT_TRANSIENT_MODEL_PATTERN.test(message);
+}
+function classifyMessage(message) {
+	const existingId = message.errorId;
+	const currentStatus = message.errorStatus ?? statusFromId(existingId);
+	const textId = classifyText(message.errorMessage, currentStatus, message.api);
+	let kinds = ((existingId ?? 0) | textId) & KIND_MASK;
+	if (message.errorMessage && LLAMA_CPP_TOOL_CALL_PARSE_PATTERN.test(message.errorMessage)) kinds &= ~Flag.Transient;
+	const id = kinds !== 0 ? create(kinds) : statusFromId(textId) ?? statusFromId(existingId) ?? currentStatus ?? 0;
+	message.errorId = id;
+	return id;
+}
+function attach(error, id) {
+	Object.defineProperty(error, "errorId", {
+		value: id,
+		enumerable: false,
+		configurable: true
+	});
+	return error;
+}
+const STREAM_PARSE_TRUNCATION_PATTERN = /unterminated string|unexpected end of json input|unexpected end of data|unexpected eof|end of file|eof while parsing|truncated/i;
+const STREAM_PARSE_DIAGNOSTIC_PATTERN = /(?:json parse error:\s*(?:unterminated string|unexpected end of json input|unexpected end of data|unexpected eof|end of file|eof while parsing|truncated)|json\.parse:\s*(?:unterminated string|unexpected end of data)|unexpected end of json input|unexpected eof|eof while parsing)/i;
+const STREAM_EVENT_ORDER_PATTERN = /stream event order|before message_start/i;
+/**
+* Transient stream corruption where the response was truncated mid-JSON.
+*
+* Strings (persisted `stopDetails.explanation`/`errorMessage` diagnostics) are matched with the
+* stricter {@link STREAM_PARSE_DIAGNOSTIC_PATTERN} — bare "truncated"/"end of file" text is too
+* low-signal to trust once detached from a live transport `Error`, which keeps the broad pattern.
+*/
+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);
+}
+/** 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));
+}
+/** Stream-envelope errors safe to retry against the provider (event ordering only). */
+function isRetryableStreamEnvelopeError(error) {
+	return error instanceof Error && STREAM_EVENT_ORDER_PATTERN.test(error.message);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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
+* logic does not have to regex the message text.
+*
+* The default message is kept byte-identical to the historical
+* `"Request was aborted"` string so any remaining text-based matchers keep
+* working through the migration.
+*/
+var AbortError = class extends Error {
+	constructor(message = "Request was aborted", options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "AbortError";
+		attach(this, create(Flag.Abort));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/error/auth.ts
+/**
+* No API key / credential was available to dispatch a request.
+*
+* The default message preserves the historical `"No API key for provider: X"`
+* wording, which {@link Flag.AuthFailed}'s regex (`no api key`) keys off — but
+* the flag is also attached structurally so classification never depends on the
+* exact phrasing.
+*/
+var MissingApiKeyError = class extends Error {
+	provider;
+	constructor(provider, message) {
+		super(message ?? (provider ? `No API key for provider: ${provider}` : "No API key available"));
+		this.name = "MissingApiKeyError";
+		this.provider = provider;
+		attach(this, create(Flag.AuthFailed));
+	}
+};
+/** A user-facing login flow required an `onPrompt` callback that was not supplied. */
+var OnPromptRequiredError = class extends Error {
+	constructor(providerLabel) {
+		super(`${providerLabel} login requires onPrompt callback`);
+		this.name = "OnPromptRequiredError";
+	}
+};
+/** An interactive login asked for an API key but the user supplied an empty value. */
+var ApiKeyRequiredError = class extends Error {
+	constructor(message = "API key is required") {
+		super(message);
+		this.name = "ApiKeyRequiredError";
+	}
+};
+/**
+* A user cancelled an interactive login / device flow. Classified as an abort
+* so it is never surfaced as a retryable transient failure.
+*/
+var LoginCancelledError = class extends Error {
+	constructor(message = "Login cancelled") {
+		super(message);
+		this.name = "LoginCancelledError";
+		attach(this, create(Flag.Abort));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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);
+	if (message.includes(RETRY_AFTER_HINT)) return message;
+	const retryAfterMs = getRetryAfterMsFromHeaders(headers ?? getHeadersFromError(error));
+	if (retryAfterMs === void 0) return message;
+	return `${message} ${RETRY_AFTER_HINT}${retryAfterMs}`;
+}
+function getRetryAfterMsFromHeaders(headers) {
+	if (!headers) return void 0;
+	const candidates = [
+		parseRetryAfterMsHeader(getHeaderValue(headers, "retry-after-ms")),
+		parseRetryAfterHeader(getHeaderValue(headers, "retry-after")),
+		parseResetHeader(getHeaderValue(headers, "x-ratelimit-reset-ms"), "ms"),
+		parseResetHeader(getHeaderValue(headers, "x-ratelimit-reset"), "s")
+	].filter((value) => value !== void 0);
+	if (candidates.length === 0) return void 0;
+	return Math.max(...candidates);
+}
+function getHeadersFromError(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const record = error;
+	const direct = extractHeaders(record.headers) ?? extractHeaders(record.response?.headers);
+	if (direct) return direct;
+	if (record.cause) return getHeadersFromError(record.cause);
+}
+function extractHeaders(value) {
+	if (!value) return void 0;
+	if (value instanceof Headers) return value;
+	if (typeof value === "object") return value;
+}
+function getHeaderValue(headers, name) {
+	if (headers instanceof Headers) return headers.get(name) ?? void 0;
+	const target = name.toLowerCase();
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === target && typeof value === "string") return value;
+}
+/** `retry-after-ms` (Anthropic-style): a plain millisecond delta. */
+function parseRetryAfterMsHeader(value) {
+	if (!value) return void 0;
+	const ms = Number(value.trim());
+	if (!Number.isFinite(ms) || ms <= 0) return void 0;
+	return Math.ceil(ms);
+}
+function parseRetryAfterHeader(value) {
+	if (!value) return void 0;
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	const numeric = Number(trimmed);
+	if (Number.isFinite(numeric)) {
+		if (numeric <= 0) return void 0;
+		return Math.ceil(numeric * 1e3);
+	}
+	const dateMs = Date.parse(trimmed);
+	if (!Number.isNaN(dateMs)) {
+		const delay = dateMs - Date.now();
+		return delay > 0 ? Math.ceil(delay) : void 0;
+	}
+}
+function parseResetHeader(value, unit) {
+	if (!value) return void 0;
+	const numeric = Number(value);
+	if (!Number.isFinite(numeric) || numeric <= 0) return void 0;
+	const nowMs = Date.now();
+	let targetMs;
+	if (unit === "ms") {
+		if (numeric > 0xe8d4a51000) targetMs = numeric;
+		else if (numeric > 1e9) targetMs = numeric * 1e3;
+		else return Math.ceil(numeric);
+	} else if (numeric > 0xe8d4a51000) targetMs = numeric;
+	else if (numeric > 1e9) targetMs = numeric * 1e3;
+	else return Math.ceil(numeric * 1e3);
+	if (targetMs <= nowMs) return void 0;
+	return Math.ceil(targetMs - nowMs);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/retry.ts
+const COPILOT_MODEL_RETRY_MAX_ATTEMPTS = 8;
+const COPILOT_GENERIC_RETRY_MAX_ATTEMPTS = 3;
+const COPILOT_MODEL_RETRY_BASE_DELAY_MS = 400;
+/** Longest server-requested backoff we are willing to sit out before giving up. */
+const COPILOT_RETRY_AFTER_MAX_WAIT_MS = 3e4;
+/**
+* Wrap an initial Copilot request so transient `model_not_supported` 400s are
+* retried a small number of times. No-op for non-Copilot providers.
+*
+* The callback **MUST** create a fresh in-flight request each invocation — a
+* once-consumed AsyncIterable cannot be re-iterated.
+*/
+async function callWithCopilotModelRetry(fn, options) {
+	if (options.provider !== "github-copilot") return fn();
+	let lastError;
+	const retryBaseDelayMs = options.retryBaseDelayMs ?? COPILOT_MODEL_RETRY_BASE_DELAY_MS;
+	for (let attempt = 0; attempt < COPILOT_MODEL_RETRY_MAX_ATTEMPTS; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error;
+		if (options.signal?.aborted) throw error;
+		const transientModelError = isCopilotTransientModelError(error);
+		if (!transientModelError && !isRetryableError(error)) throw error;
+		if (attempt >= (transientModelError ? COPILOT_MODEL_RETRY_MAX_ATTEMPTS : COPILOT_GENERIC_RETRY_MAX_ATTEMPTS) - 1) break;
+		let delayMs = transientModelError ? retryBaseDelayMs : retryBaseDelayMs * (attempt + 1);
+		if (!transientModelError) {
+			if (status(error) !== void 0) {
+				const retryAfterMs = getRetryAfterMsFromHeaders(getHeadersFromError(error));
+				if (retryAfterMs === void 0 || retryAfterMs > COPILOT_RETRY_AFTER_MAX_WAIT_MS) throw error;
+				delayMs = Math.max(delayMs, retryAfterMs);
+			}
+		}
+		await scheduler.wait(delayMs, { signal: options.signal });
+	}
+	throw lastError;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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"
+];
+/**
+* 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
+* is added under `errorResponse` so a failed request is diagnosable from the
+* dump file rather than the request alone.
+*/
+function buildHttp400DumpPayload(dump, error, message) {
+	return {
+		...sanitizeDump(dump),
+		errorResponse: {
+			status: status(error),
+			message
+		}
+	};
+}
+/** HTTP statuses whose rejected request we persist for post-hoc diagnosis: the
+*  request-content rejections that wedge a session. 400 (bad request) and 413
+*  (payload too large — an oversized image / snapcompact frame payload that 413s
+*  and empties the turn). Auth (401/403), not-found (404), rate limits and 5xx
+*  are excluded: 429/5xx are retried, so persisting them here would write one
+*  dump per attempt. */
+function shouldDumpRejectedRequest(error) {
+	const status$2 = status(error);
+	return status$2 === 400 || status$2 === 413;
+}
+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.join(getLogsDir(), "http-400-requests", fileName);
+	try {
+		await Bun.write(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+		return `${message}\nraw-http-request=${filePath}`;
+	} catch (writeError) {
+		return `${message}\nraw-http-request-save-failed=${writeError instanceof Error ? writeError.message : String(writeError)}`;
+	}
+}
+async function finalizeErrorMessage(error, rawRequestDump, capturedErrorResponse) {
+	let message = formatErrorMessageWithRetryAfter(error, capturedErrorResponse?.headers);
+	const capturedMessage = formatCapturedHttpError(capturedErrorResponse);
+	if (capturedMessage) {
+		if (/\bstatus code\s*\(no body\)/i.test(message)) message = `${capturedErrorResponse?.status ?? "HTTP"} status code: ${capturedMessage}`;
+		else if (!message.includes(capturedMessage)) message = `${message}\n${capturedMessage}`;
+	}
+	return appendRawHttpRequestDumpFor400(message, error, rawRequestDump);
+}
+/**
+* Rewrite error message for GitHub Copilot request failures.
+* Must run AFTER finalizeErrorMessage since it replaces the message entirely.
+*
+* 400 `model_not_supported` = Copilot fleet skew. A model that `/models`
+*        advertises can flap between 200 and 400 because only part of
+*        Copilot's fleet has it in the integrator allowlist. After the
+*        in-request retry exhausts, surface guidance rather than the raw error.
+* 401 = token invalid/expired → credential removal is safe, prompt re-login.
+* 403 = token valid but access denied (plan, model policy, org restriction) →
+*       do NOT reuse the auth-failed string (which triggers credential removal).
+*/
+function rewriteCopilotError(errorMessage, error, provider) {
+	if (provider !== "github-copilot") return errorMessage;
+	const status$1 = status(error);
+	if (status$1 === 401) return `GitHub Copilot authentication failed (HTTP 401). Your token may have been revoked. Please re-login with /login github-copilot`;
+	if (status$1 === 403) return `GitHub Copilot access denied (HTTP 403). Your account may not have access to this model or feature. Check your Copilot plan or model policy settings.`;
+	if (isCopilotTransientModelError(error)) return `GitHub Copilot rejected this model (HTTP 400) after retries: only part of its fleet currently serves this model id, even though /models advertises it. Try again in a few seconds or switch to a model Copilot serves fleet-wide (claude-opus-4.7, claude-sonnet-4.5, gpt-4.1).`;
+	return errorMessage;
+}
+function sanitizeDump(dump) {
+	return {
+		...dump,
+		headers: redactHeaders(dump.headers)
+	};
+}
+function redactHeaders(headers) {
+	if (!headers) return;
+	const redacted = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+			redacted[key] = "[redacted]";
+			continue;
+		}
+		redacted[key] = value;
+	}
+	return redacted;
+}
+function formatCapturedHttpError(captured) {
+	if (!captured) return void 0;
+	const bodyText = captured.bodyText?.trim();
+	if (!bodyText) return void 0;
+	const payload = parseCapturedErrorPayload(captured);
+	if (!payload) return bodyText;
+	const errorPayload = getObjectProperty(payload, "error") ?? payload;
+	const stringError = errorPayload === payload ? getStringProperty(payload, "error") : void 0;
+	const message = getStringProperty(errorPayload, "message") ?? getStringProperty(payload, "message") ?? stringError ?? bodyText;
+	const extras = [
+		getStringProperty(errorPayload, "type") ?? getStringProperty(payload, "type"),
+		getStringProperty(errorPayload, "param") ?? getStringProperty(payload, "param"),
+		getStringProperty(errorPayload, "code") ?? getStringProperty(payload, "code")
+	].filter(Boolean).map((value, index) => {
+		if (index === 0) return `type=${value}`;
+		if (index === 1) return `param=${value}`;
+		return `code=${value}`;
+	});
+	return extras.length > 0 ? `${message} (${extras.join(" ")})` : message;
+}
+function parseCapturedErrorPayload(captured) {
+	if (isObject(captured.bodyJson)) return captured.bodyJson;
+	if (!captured.bodyText) return void 0;
+	try {
+		const parsed = JSON.parse(captured.bodyText);
+		return isObject(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function getObjectProperty(value, key) {
+	const property = value[key];
+	return isObject(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@17.3.5/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}`;
+}
+/**
+* Format a provider error into a user-facing message, unifying the three
+* formatters: lightweight retry-after extraction, the raw-dump finalizer, and
+* the copilot rewrite.
+*
+* Selection is driven by inputs, not a mode flag: a `rawRequestDump` routes
+* through {@link finalizeErrorMessage} (retry-after + raw dump + captured body),
+* otherwise the lightweight {@link formatErrorMessageWithRetryAfter} is used.
+*/
+async function formatMessage(error, opts = {}) {
+	let message = opts.rawRequestDump ? await finalizeErrorMessage(error, opts.rawRequestDump, opts.capturedErrorResponse) : formatErrorMessageWithRetryAfter(error);
+	if (opts.provider === "github-copilot") message = rewriteCopilotError(message, error, opts.provider);
+	if (opts.provider === "ollama") message = rewriteOllamaToolCallJsonError(message);
+	return message;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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.
+*
+* `stopReason` comes from the abort tracker (caller intent dominates) or, when
+* no tracker is supplied, the raw `signal.aborted`. A local abort reason (e.g. a
+* first-event timeout) supersedes the formatted message. Message formatting is
+* wrapped so a formatter throw can never skip the caller's `stream.end()`.
+*/
+async function finalize(error, opts = {}) {
+	const aborted = opts.abortTracker ? opts.abortTracker.wasCallerAbort() : opts.signal?.aborted === true;
+	const currentStatus = status(error) ?? opts.capturedErrorResponse?.status;
+	let message;
+	try {
+		message = (opts.abortTracker?.getLocalAbortReason())?.message ?? await formatMessage(error, opts);
+	} catch {
+		message = error instanceof Error ? error.message : String(error);
+	}
+	return {
+		id: classifyMessage({
+			api: opts.api,
+			errorId: classify(error, opts.api),
+			errorMessage: message,
+			errorStatus: currentStatus
+		}),
+		status: currentStatus,
+		stopReason: aborted ? "aborted" : "error",
+		message
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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
+* else is a hard auth failure so the credential layer does not silently retry.
+*/
+var OAuthError = class extends Error {
+	kind;
+	provider;
+	status;
+	constructor(message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "OAuthError";
+		this.kind = options.kind ?? "http";
+		this.provider = options.provider;
+		this.status = options.status;
+		attach(this, this.kind === "timeout" || this.kind === "polling" ? create(Flag.Transient) : create(Flag.AuthFailed));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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@17.3.5/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.
+*
+* This is a pure predicate over a status code already in hand — distinct from
+* {@link classify}, which inspects a whole error (including message text) and
+* may match more. Use this when you only have a `status: number`.
+*/
+function isTransientStatus(status) {
+	return status !== void 0 && (status === 408 || status === 429 || status >= 500);
+}
+const PROVIDER_TRANSIENT_EXTRA_PATTERN = /bad record mac|stream error.*received from peer|1302/i;
+function isTransientTransportMessage(message) {
+	return message.includes("tls: bad record mac") || message.includes("type=server_error");
+}
+/**
+* Whether a provider stream error should be retried against the same credential.
+*
+* Account-level usage/quota limits are deliberately treated as **non**-retryable
+* here — they are owned by the credential-rotation layer (auth-gateway /
+* `streamSimple` a/b/c policy), not this seconds-scale provider backoff.
+*
+* Provider-specific transient cases are injected via {@link ProviderRetryableHooks}
+* so this stays free of provider imports.
+*/
+function isProviderRetryableError(error, hooks = {}) {
+	if (!(error instanceof Error)) return false;
+	if (hooks.isProviderTransient?.(error)) return true;
+	if (isUsageLimit(error)) return false;
+	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;
+	return isRetryableError(error);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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
+* type, a schema that cannot be normalized, an unknown tool, etc.
+*
+* This is a programmer/config/contract error, not a transient provider fault —
+* it is never retried.
+*/
+var ValidationError = class extends Error {
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "ValidationError";
+	}
+};
+/**
+* Provider/auth configuration was missing or malformed (env var pointing at a
+* missing file, missing projectId, bad bind string, mTLS half-configured, …).
+*/
+var ConfigurationError = class extends Error {
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "ConfigurationError";
+	}
+};
+/** A request was abandoned because it exceeded a stream/idle/first-event deadline. */
+var StreamTimeoutError = class extends Error {
+	constructor(message = "Request timed out.", options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "StreamTimeoutError";
+		attach(this, create(Flag.Transient, Flag.Timeout));
+	}
+};
+//#endregion
+export { isTransientStreamParseError as A, OpenAIHttpError as B, classifyMessage as C, isFastModeUnsupported as D, isCopilotTransientModelError 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, classify as S, is as T, EventStreamFrameError as U, ProviderHttpError as V, extractHttpStatusFromError as W, OnPromptRequiredError as _, isTransientStatus as a, LLAMA_CPP_TOOL_CALL_PARSE_PATTERN as b, OAuthError as c, callWithCopilotModelRetry as d, getHeadersFromError as f, MissingApiKeyError as g, LoginCancelledError as h, isProviderRetryableError as i, retriable as j, isStreamEnvelopeError as k, finalize as l, ApiKeyRequiredError as m, StreamTimeoutError as n, DevinApiError as o, getRetryAfterMsFromHeaders as p, ValidationError as r, ProviderResponseError as s, ConfigurationError as t, finalizeErrorMessage as u, AbortError as v, create as w, attach as x, Flag as y, OllamaApiError as z };