@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-re8hpzwn.js

@@ -0,0 +1,104 @@
+import {
+  claudeCodeVersion2,
+  usesClaudeSubscription2
+} from "./account-limits-cache-ks1sjym9.js";
+import {
+  limitWindow2,
+  fetchAccountUsage2
+} from "./account-limits-cache-ehy0ze2b.js";
+
+// src/providers/anthropic-limits.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var AccountResetSchema = Type.Optional(Type.Union([Type.Number(), Type.String(), Type.Null()]));
+var ClaudeUsageResponseSchema = Type.Record(Type.String(), Type.Unknown());
+var ClaudeUsageWindowSchema = Type.Object({
+  utilization: Type.Number(),
+  resets_at: AccountResetSchema
+});
+var ClaudeScopedUsageWindowSchema = Type.Object({
+  kind: Type.Literal("weekly_scoped"),
+  scope: Type.Object({ model: Type.Object({ display_name: Type.String() }) }),
+  percent: Type.Number(),
+  resets_at: AccountResetSchema
+});
+function resetAtMs(value) {
+  if (value === null || value === undefined)
+    return;
+  if (typeof value === "number") {
+    return value < 1000000000000 ? value * 1000 : value;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function accountLimitWindow(id, label, percent, reset, windowMinutes) {
+  return limitWindow2(id, label, percent, resetAtMs(reset), windowMinutes);
+}
+var CLAUDE_USAGE_WINDOWS = [
+  { id: "five_hour", label: "5-hour", windowMinutes: 5 * 60 },
+  { id: "seven_day", label: "Weekly", windowMinutes: 7 * 24 * 60 },
+  { id: "seven_day_sonnet", label: "Sonnet weekly", windowMinutes: 7 * 24 * 60 },
+  { id: "seven_day_opus", label: "Opus weekly", windowMinutes: 7 * 24 * 60 }
+];
+function claudeHeaderLimits2(headers, providerId) {
+  const windows = [];
+  for (const [id, label, suffix, windowMinutes] of [
+    ["five_hour", "5-hour", "5h", 5 * 60],
+    ["seven_day", "Weekly", "7d", 7 * 24 * 60]
+  ]) {
+    const utilization = Number(headers[`anthropic-ratelimit-unified-${suffix}-utilization`]);
+    if (!Number.isFinite(utilization))
+      continue;
+    const reset = Number(headers[`anthropic-ratelimit-unified-${suffix}-reset`]);
+    windows.push(accountLimitWindow(id, label, utilization * 100, Number.isFinite(reset) ? reset : undefined, windowMinutes));
+  }
+  return windows.length === 0 ? undefined : { providerId, windows, observedAt: Date.now() };
+}
+function claudeUsageWindows(usage) {
+  const windows = [];
+  for (const definition of CLAUDE_USAGE_WINDOWS) {
+    const window = usage[definition.id];
+    if (!Value.Check(ClaudeUsageWindowSchema, window))
+      continue;
+    windows.push(accountLimitWindow(definition.id, definition.label, window.utilization, window.resets_at, definition.windowMinutes));
+  }
+  const scoped = usage["limits"];
+  for (const window of Array.isArray(scoped) ? scoped : []) {
+    if (!Value.Check(ClaudeScopedUsageWindowSchema, window))
+      continue;
+    const name = window.scope.model.display_name;
+    if (name.trim() === "")
+      continue;
+    windows.push(accountLimitWindow(`seven_day_${name}`, `${name} weekly`, window.percent, window.resets_at, 7 * 24 * 60));
+  }
+  return windows;
+}
+async function fetchAnthropicAccountLimits2(model, options) {
+  const apiKey = options?.apiKey;
+  if (!apiKey || !usesClaudeSubscription2(apiKey)) {
+    throw new Error("Claude usage requires Anthropic OAuth");
+  }
+  const headers = new Headers({
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "User-Agent": `claude-cli/${claudeCodeVersion2}`,
+    "anthropic-beta": "oauth-2025-04-20"
+  });
+  for (const source of [model.headers, options?.headers]) {
+    for (const [name, value] of Object.entries(source ?? {})) {
+      if (value === null)
+        headers.delete(name);
+      else
+        headers.set(name, value);
+    }
+  }
+  const baseUrl = (model.baseUrl?.trim() || "https://api.anthropic.com").replace(/\/+$/, "").replace(/\/v1$/, "");
+  const decoded = await fetchAccountUsage2(`${baseUrl}/api/oauth/usage`, headers, options, ClaudeUsageResponseSchema, "Claude");
+  return {
+    providerId: model.provider,
+    windows: claudeUsageWindows(decoded),
+    observedAt: Date.now()
+  };
+}
+
+export { claudeHeaderLimits2, fetchAnthropicAccountLimits2 };

package/dist/chunks/account-limits-cache-rz8p1g5y.js

@@ -0,0 +1,9 @@
+// src/utils/nyte-home.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+function defaultNyteHome2() {
+  return process.env["NYTE_HOME"] ?? join(homedir(), ".nyte");
+}
+
+export { defaultNyteHome2 };

package/dist/chunks/account-limits-cache-skbfmzqe.js

@@ -0,0 +1,7 @@
+// src/utils/typebox-helpers.ts
+import { Type } from "typebox";
+function StringEnum2(values, options) {
+  return Type.Enum(values, { type: "string", ...options });
+}
+
+export { StringEnum2 };

package/dist/chunks/account-limits-cache-tc38g0ca.js

@@ -0,0 +1,20 @@
+// src/auth/oauth/pkce.ts
+function base64urlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+async function generatePKCE2() {
+  const verifierBytes = new Uint8Array(32);
+  crypto.getRandomValues(verifierBytes);
+  const verifier = base64urlEncode(verifierBytes);
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const challenge = base64urlEncode(new Uint8Array(hashBuffer));
+  return { verifier, challenge };
+}
+
+export { generatePKCE2 };

package/dist/chunks/account-limits-cache-v4n30az2.js

@@ -0,0 +1,24 @@
+// src/auth/oauth/load.ts
+var registeredFlows = new Map;
+function registerOAuthFlow2(id, flow) {
+  registeredFlows.set(id, flow);
+}
+async function importOAuthModule(specifier) {
+  try {
+    await import(specifier);
+  } catch (error) {
+    throw new Error(`OAuth flow module ${specifier} is not loadable at runtime. Bundled hosts must register flows up front with registerBunOAuthFlows.`, { cause: error });
+  }
+}
+async function loadOAuthFlow(id, specifier) {
+  if (!registeredFlows.has(id))
+    await importOAuthModule(specifier);
+  const flow = registeredFlows.get(id);
+  if (flow === undefined)
+    throw new Error(`OAuth flow module ${specifier} did not register its flow`);
+  return flow;
+}
+var loadAnthropicOAuth2 = () => loadOAuthFlow("anthropic", "@nyte-ai/ai/auth/oauth/anthropic");
+var loadOpenAICodexOAuth2 = () => loadOAuthFlow("openaiCodex", "@nyte-ai/ai/auth/oauth/openai-codex");
+
+export { registerOAuthFlow2, loadAnthropicOAuth2, loadOpenAICodexOAuth2 };

package/dist/chunks/account-limits-cache-vwgfz727.js

@@ -0,0 +1,281 @@
+import {
+  applyServiceTierPricing2
+} from "./account-limits-cache-f9z00x8c.js";
+import {
+  CodexFrameJson2,
+  readText2,
+  readBoolean2,
+  readNumber2,
+  readRecord2,
+  TERMINAL_RESPONSE_TYPES2
+} from "./account-limits-cache-fvadc36m.js";
+import {
+  codexFrameLimits2
+} from "./account-limits-cache-hj3ek3ty.js";
+import {
+  splitDeferredTools2
+} from "./account-limits-cache-8s8bz4dr.js";
+import {
+  formatThrownValue2
+} from "./account-limits-cache-9wqk28n5.js";
+import {
+  iterateServerSentEvents2
+} from "./account-limits-cache-me1x57bs.js";
+import {
+  getSystemMessageText2
+} from "./account-limits-cache-b4edaybk.js";
+import {
+  getDeclaredTools2,
+  getInitialSystemMessage2,
+  resolveTranscriptTools2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  createGrammarToolInputProperties2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  convertResponsesMessages2,
+  convertResponsesTools2
+} from "./account-limits-cache-n3yk6g5c.js";
+
+// src/api/openai-codex-protocol.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CodexResponseStatusSchema = Type.Union([
+  Type.Literal("completed"),
+  Type.Literal("incomplete"),
+  Type.Literal("failed"),
+  Type.Literal("cancelled"),
+  Type.Literal("queued"),
+  Type.Literal("in_progress")
+]);
+var DEFAULT_MAX_RETRIES2 = 0;
+var REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
+var CODEX_TOOL_CALL_PROVIDERS2 = new Set([
+  "openai",
+  "openai-codex",
+  "opencode"
+]);
+function compressRequestBodyZstd2(bodyJson) {
+  if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+    return null;
+  }
+  try {
+    const zlib = process.getBuiltinModule("node:zlib");
+    const compressed = zlib.zstdCompressSync(bodyJson, {
+      params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL }
+    });
+    return new Uint8Array(compressed);
+  } catch {
+    return null;
+  }
+}
+function buildRequestBody2(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
+  const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
+  const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
+  const deferredToolsMode = model.compat?.supportsAdditionalTools ? "additional-tools" : model.compat?.supportsToolSearch ? "tool-search" : undefined;
+  const transcriptTools = resolveTranscriptTools2(context.messages, deferredToolsMode !== undefined);
+  const toolPlacement = splitDeferredTools2({ messages: context.messages, tools: transcriptTools.requestTools }, deferredToolsMode !== undefined);
+  const messages = convertResponsesMessages2(model, context, CODEX_TOOL_CALL_PROVIDERS2, {
+    includeSystemPrompt: false,
+    grammarToolInputProperties,
+    supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+    deferredTools: toolPlacement.deferred,
+    deferredToolsMode,
+    toolOptions: {
+      strict: null,
+      supportsStrictMode,
+      supportsOpenAIGrammarTools
+    }
+  });
+  const initialSystemMessage = getInitialSystemMessage2(context.messages);
+  const instructions = initialSystemMessage ? getSystemMessageText2(initialSystemMessage) : "";
+  const body = {
+    model: model.id,
+    store: false,
+    stream: true,
+    instructions: instructions || "You are a helpful assistant.",
+    input: messages,
+    text: { verbosity: options?.textVerbosity || "low" },
+    include: ["reasoning.encrypted_content"],
+    prompt_cache_key: cacheSessionId,
+    tool_choice: options?.toolChoice ?? "auto",
+    parallel_tool_calls: true
+  };
+  if (options?.temperature !== undefined) {
+    body.temperature = options.temperature;
+  }
+  if (options?.serviceTier !== undefined) {
+    body.service_tier = options.serviceTier;
+  }
+  if (toolPlacement.immediate.length > 0) {
+    body.tools = convertResponsesTools2(toolPlacement.immediate, {
+      strict: null,
+      supportsStrictMode,
+      supportsOpenAIGrammarTools
+    });
+  }
+  if (options?.reasoningEffort !== undefined) {
+    const effort = options.reasoningEffort === "none" ? model.thinkingLevelMap?.off === undefined ? "none" : model.thinkingLevelMap.off : model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+    if (effort !== null) {
+      body.reasoning = {
+        effort,
+        summary: options.reasoningSummary ?? "auto"
+      };
+    }
+  } else if (model.reasoning && model.thinkingLevelMap?.off !== null) {
+    body.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+  }
+  return body;
+}
+function resolveCodexServiceTier2(responseServiceTier, requestServiceTier) {
+  if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) {
+    return requestServiceTier;
+  }
+  return responseServiceTier ?? requestServiceTier;
+}
+function codexStreamOptions2(request) {
+  return {
+    serviceTier: request.options?.serviceTier,
+    grammarToolInputProperties: request.grammarToolInputProperties,
+    resolveServiceTier: resolveCodexServiceTier2,
+    applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing2(usage, serviceTier, request.model)
+  };
+}
+
+class CodexRequestError2 extends Error {
+  status;
+  headers;
+  retryable;
+  constructor(message, status, headers, retryable, options) {
+    super(message, options);
+    this.name = "CodexRequestError";
+    this.status = status;
+    this.headers = headers;
+    this.retryable = retryable;
+  }
+}
+function retryableCodexRequest2(error) {
+  return error instanceof CodexRequestError2 && error.retryable;
+}
+
+class CodexApiError2 extends Error {
+  code;
+  payload;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "CodexApiError";
+    this.code = options?.code;
+    this.payload = options?.payload;
+  }
+}
+
+class CodexProtocolError2 extends Error {
+  payload;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "CodexProtocolError";
+    this.payload = options?.payload;
+  }
+}
+function extractCodexEventError2(event) {
+  const nested = readRecord2(event.error);
+  return {
+    code: readText2(event.code) ?? readText2(nested?.code),
+    message: readText2(event.message) ?? readText2(nested?.message)
+  };
+}
+async function reportFrameLimits(frame, providerId, onAccountLimits) {
+  const limits = codexFrameLimits2(frame, providerId);
+  if (limits !== undefined)
+    await onAccountLimits(limits);
+}
+async function* mapCodexEvents2(events, output, onAccountLimits) {
+  for await (const event of events) {
+    const { type } = event;
+    if (type === "codex.rate_limits") {
+      if (onAccountLimits !== undefined) {
+        await reportFrameLimits(event, output.provider, onAccountLimits).catch(() => {
+          return;
+        });
+      }
+      continue;
+    }
+    if (type === "error") {
+      const { code, message } = extractCodexEventError2(event);
+      throw new CodexApiError2(`Codex error: ${message || code || JSON.stringify(event)}`, {
+        code,
+        payload: event
+      });
+    }
+    if (TERMINAL_RESPONSE_TYPES2.has(type)) {
+      const response = readRecord2(event.response);
+      const endTurn = readBoolean2(response?.end_turn);
+      const status = response?.status;
+      if (endTurn !== undefined) {
+        output.endTurn = endTurn;
+      }
+      yield {
+        ...event,
+        type: "response.completed",
+        response: {
+          ...response,
+          status: type === "response.failed" ? "failed" : Value.Check(CodexResponseStatusSchema, status) ? status : undefined
+        }
+      };
+      if (type === "response.failed") {
+        const failure = readRecord2(response?.error);
+        throw new CodexApiError2(readText2(failure?.message) || "Codex response failed", {
+          code: readText2(failure?.code),
+          payload: event
+        });
+      }
+      return;
+    }
+    yield event;
+  }
+}
+async function* parseSSE2(response, signal, idleTimeoutMs) {
+  if (!response.body)
+    return;
+  for await (const { data } of iterateServerSentEvents2(response.body, signal, idleTimeoutMs)) {
+    if (data.trim() === "" || data === "[DONE]")
+      continue;
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch (cause) {
+      throw new CodexProtocolError2(`Invalid Codex SSE JSON: ${formatThrownValue2(cause)}`, {
+        cause,
+        payload: data
+      });
+    }
+    if (Value.Check(CodexFrameJson2, frame))
+      yield frame;
+  }
+}
+function parseJsonObject(raw) {
+  try {
+    return readRecord2(JSON.parse(raw));
+  } catch {
+    return;
+  }
+}
+function parseErrorResponse2(raw, response) {
+  const fallback = raw || response.statusText || "Request failed";
+  const err = readRecord2(parseJsonObject(raw)?.error);
+  if (!err)
+    return { message: fallback };
+  const code = readText2(err.code) ?? readText2(err.type) ?? "";
+  let friendlyMessage;
+  if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
+    const planType = readText2(err.plan_type);
+    const plan = planType ? ` (${planType.toLowerCase()} plan)` : "";
+    const resetsAt = readNumber2(err.resets_at);
+    const mins = resetsAt ? Math.max(0, Math.round((resetsAt * 1000 - Date.now()) / 60000)) : undefined;
+    const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
+    friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
+  }
+  return { message: readText2(err.message) || friendlyMessage || fallback, friendlyMessage };
+}
+
+export { DEFAULT_MAX_RETRIES2, CODEX_TOOL_CALL_PROVIDERS2, compressRequestBodyZstd2, buildRequestBody2, resolveCodexServiceTier2, codexStreamOptions2, CodexRequestError2, retryableCodexRequest2, CodexApiError2, CodexProtocolError2, extractCodexEventError2, mapCodexEvents2, parseSSE2, parseErrorResponse2 };

package/dist/chunks/account-limits-cache-x9fvb3s5.js

@@ -0,0 +1,8 @@
+import {
+  lazyApi2
+} from "./account-limits-cache-90c9c2eb.js";
+
+// src/api/google-generative-ai.lazy.ts
+var googleGenerativeAIApi2 = () => lazyApi2(() => import("../src/api/google-generative-ai.js"));
+
+export { googleGenerativeAIApi2 };

package/dist/chunks/account-limits-cache-xds88kxd.js

@@ -0,0 +1,209 @@
+// src/utils/failure.ts
+var CONTEXT_WINDOW_PATTERNS = [
+  /prompt (?:is )?too long/i,
+  /prompt exceeds max length/i,
+  /request_too_large/i,
+  /input is too long for requested model/i,
+  /exceeds the context window/i,
+  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/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 )?maximum allowed input length of [\d,]+ tokens?/i,
+  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+  /exceeds the limit of \d+/i,
+  /exceeds the available context size/i,
+  /greater than the context length/i,
+  /context window exceeds limit/i,
+  /exceeded model token limit/i,
+  /too large for model with \d+ maximum context length/i,
+  /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+  /model_context_window_exceeded/i,
+  /prompt too long; exceeded (?:max )?context length/i,
+  /range of input length should be/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /too many tokens/i,
+  /token limit exceeded/i
+];
+var CEREBRAS_BODYLESS_CONTEXT_WINDOW_PATTERN = /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i;
+var NOT_CONTEXT_WINDOW_PATTERN = /^(Throttling error|Service unavailable):|rate limit|too many requests/i;
+function pattern(parts) {
+  return new RegExp(parts.join("|"), "i");
+}
+var QUOTA_PATTERN = pattern([
+  "GoUsageLimitError",
+  "FreeUsageLimitError",
+  "Monthly usage limit reached",
+  "available balance",
+  "insufficient[_ -]?quota",
+  "out[_ ]of[_ ]credits",
+  "out of budget",
+  "quota exceeded",
+  "billing"
+]);
+function reportsQuotaExhaustion2(text) {
+  return QUOTA_PATTERN.test(text);
+}
+var AUTH_PATTERN = pattern([
+  "\\b401\\b",
+  "unauthori[sz]ed",
+  "invalid (?:x-)?api[ _-]?key",
+  "authentication"
+]);
+var RATE_LIMIT_PATTERN = pattern([
+  "rate[_ .-]?limit",
+  "too many requests",
+  "throttl",
+  "ResourceExhausted",
+  "retry delay"
+]);
+var OVERLOADED_PATTERN = pattern([
+  "\\b529\\b",
+  "\\b5(?:00|02|03|04|20|24)\\b",
+  "overload",
+  "currently experiencing high demand",
+  "model is at capacity",
+  "service.?unavailable",
+  "temporarily unavailable",
+  "server.?error",
+  "internal.?error",
+  "provider.?returned.?error",
+  "exceeded request buffer limit while retrying upstream",
+  "you can retry your request",
+  "try your request again",
+  "please retry your request"
+]);
+var NETWORK_PATTERN = pattern([
+  "network",
+  "fetch failed",
+  "ECONN",
+  "connection.?(?:lost|refused|reset|error)",
+  "other side closed",
+  "getaddrinfo",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "upstream.?connect",
+  "reset before headers",
+  "socket hang up",
+  "socket connection was closed",
+  "timed? out",
+  "timeout",
+  "terminated",
+  "websocket.?(?:closed|error)",
+  "ended without",
+  "stream ended before message_stop",
+  "stream ended before a terminal response event",
+  "http2 request did not get a response"
+]);
+var RETRY_DELAY_PATTERN = /server requested ([0-9]+(?:\.[0-9]+)?)s retry delay(?: \(max: ([0-9]+(?:\.[0-9]+)?)s\))?/i;
+function classForStatus(status) {
+  if (status === 429)
+    return "rate_limit";
+  if (status === 401 || status === 403)
+    return "auth";
+  if (status === 402)
+    return "quota";
+  if (status === 413)
+    return "context_window";
+  if (status >= 500 && status <= 599)
+    return "overloaded";
+  return;
+}
+function structuredClass(message) {
+  for (const diagnostic of message.diagnostics ?? []) {
+    for (const value of [
+      diagnostic.details?.status,
+      diagnostic.details?.statusCode,
+      diagnostic.error?.code
+    ]) {
+      const status = typeof value === "number" ? value : typeof value === "string" && /^\d{3}$/u.test(value) ? Number(value) : Number.NaN;
+      if (!Number.isInteger(status))
+        continue;
+      const failureClass = classForStatus(status);
+      if (failureClass !== undefined)
+        return failureClass;
+    }
+  }
+  return;
+}
+function classifyText(text, provider) {
+  if (!NOT_CONTEXT_WINDOW_PATTERN.test(text) && (CONTEXT_WINDOW_PATTERNS.some((p) => p.test(text)) || provider === "cerebras" && CEREBRAS_BODYLESS_CONTEXT_WINDOW_PATTERN.test(text))) {
+    return "context_window";
+  }
+  if (reportsQuotaExhaustion2(text))
+    return "quota";
+  if (RATE_LIMIT_PATTERN.test(text))
+    return "rate_limit";
+  if (OVERLOADED_PATTERN.test(text))
+    return "overloaded";
+  if (NETWORK_PATTERN.test(text))
+    return "network";
+  if (AUTH_PATTERN.test(text))
+    return "auth";
+  if (/\b429\b/u.test(text))
+    return "rate_limit";
+  return "provider";
+}
+function retryAfterMs(message) {
+  for (const diagnostic of message.diagnostics ?? []) {
+    for (const key of ["retryAfterMs", "retryDelayMs"]) {
+      const value = diagnostic.details?.[key];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return value;
+    }
+  }
+  const match = message.errorMessage?.match(RETRY_DELAY_PATTERN);
+  const seconds = match === null || match === undefined ? Number.NaN : Number(match[1]);
+  const maximum = match === null || match === undefined ? Number.NaN : Number(match[2]);
+  if (!Number.isFinite(seconds) || seconds < 0)
+    return;
+  return Number.isFinite(maximum) && maximum > 0 && seconds > maximum ? undefined : seconds * 1000;
+}
+function silentOverflow(message, contextWindow) {
+  if (contextWindow === undefined || contextWindow === 0)
+    return false;
+  const inputTokens = message.usage.input + message.usage.cacheRead;
+  if (message.stopReason === "stop")
+    return inputTokens > contextWindow;
+  return message.stopReason === "length" && message.usage.output === 0 && inputTokens >= contextWindow * 0.99;
+}
+function classifyAssistantFailure2(message, model) {
+  if (message.stopReason === "aborted") {
+    return { class: "aborted", message: message.errorMessage ?? "Aborted" };
+  }
+  if (message.stopReason !== "error") {
+    return {
+      class: silentOverflow(message, model?.contextWindow) ? "context_window" : "provider",
+      message: message.errorMessage ?? ""
+    };
+  }
+  const text = message.errorMessage ?? "Unknown error";
+  const failure = {
+    class: reportsQuotaExhaustion2(text) ? "quota" : structuredClass(message) ?? classifyText(text, message.provider),
+    message: text
+  };
+  const delay = retryAfterMs(message);
+  return delay === undefined ? failure : { ...failure, retryAfterMs: delay };
+}
+function retryCanHelp2(failureClass) {
+  switch (failureClass) {
+    case "rate_limit":
+    case "overloaded":
+    case "network":
+      return true;
+    case "auth":
+    case "quota":
+    case "context_window":
+    case "aborted":
+    case "provider":
+    case "runner":
+      return false;
+    default: {
+      const _exhaustive = failureClass;
+      return _exhaustive;
+    }
+  }
+}
+
+export { reportsQuotaExhaustion2, classifyAssistantFailure2, retryCanHelp2 };