agent-accelerator 0.5.8 → 0.6.0

package/src/providers/openrouter.ts

@@ -46,12 +46,11 @@ import { buildSessionHeaders, setHeaderCaseInsensitive } from "../utils/headers.
 import { normalizeMediaInput } from "../utils/media.ts";
 import { safeStringify } from "../utils/serialization.ts";
 import { toConciseProviderError, assertModalitiesSupported } from "../utils/errors.ts";
-import { isAbortError } from "../types/errors.ts";
+import { ConfigError, isAbortError } from "../types/errors.ts";
 import {
   newToolCallId,
   redactedHeaders,
   readErrorPayload,
-  incompleteStreamError,
   hasUnfinishedToolCall,
   linkStreamAbort,
   withAbortTimer,
@@ -123,7 +122,10 @@ interface ChatRequestBody {
   service_tier?: string;
   session_id?: string;
   cache_control?: { type: "ephemeral"; ttl: "5m" | "1h" };
-  response_format?: { type: "json_schema"; json_schema: { name: string; schema: Record<string, unknown>; strict: boolean; description?: string } };
+  response_format?: {
+    type: "json_schema";
+    json_schema: { name: string; schema: Record<string, unknown>; strict: boolean; description?: string };
+  };
   stream?: boolean;
   [k: string]: unknown;
 }
@@ -173,7 +175,13 @@ function cleanModelId(model: string | ModelSpec): string {
 }
 
 // The HTTP status of an error chunk inside a stream (the HTTP status itself is 200): its numeric `code`, else the status of its retryable `error_type` (errors-and-debugging.md, "Typed Error Codes"); in: the chunk's error, out: streamInto, where it makes the error retryable.
-const RETRYABLE_ERROR_TYPE_STATUS: Record<string, number> = { rate_limit_exceeded: 429, provider_overloaded: 503, provider_unavailable: 502, timeout: 504, server: 500 };
+const RETRYABLE_ERROR_TYPE_STATUS: Record<string, number> = {
+  rate_limit_exceeded: 429,
+  provider_overloaded: 503,
+  provider_unavailable: 502,
+  timeout: 504,
+  server: 500,
+};
 // HTTP-like status of an error chunk inside a stream, or undefined when unknown; in: streamInto's error branch, out: the status that makes the error retryable.
 function midStreamStatus(code: unknown, errorType: unknown): number | undefined {
   if (typeof code === "number" && Number.isInteger(code) && code >= 100 && code <= 599) return code;
@@ -195,7 +203,18 @@ function toOpenRouterTools(tools?: StandardToolDeclaration[]): Array<Record<stri
 }
 
 // The `input_audio.format` for a MIME type: Chat Completions takes any format string the provider supports (audio.md: wav, mp3, aiff, aac, ogg, flac, m4a, pcm16 ...), so the real format is sent, never a guess; in: an audio part's MIME type, out: contentPartsToBlocks.
-const AUDIO_FORMAT: Record<string, string> = { wav: "wav", wave: "wav", mpeg: "mp3", mp3: "mp3", mp4: "m4a", m4a: "m4a", aac: "aac", ogg: "ogg", flac: "flac", aiff: "aiff" };
+const AUDIO_FORMAT: Record<string, string> = {
+  wav: "wav",
+  wave: "wav",
+  mpeg: "mp3",
+  mp3: "mp3",
+  mp4: "m4a",
+  m4a: "m4a",
+  aac: "aac",
+  ogg: "ogg",
+  flac: "flac",
+  aiff: "aiff",
+};
 // The `input_audio.format` for an audio MIME type (see AUDIO_FORMAT above); in: contentPartsToBlocks, out: the format string.
 function audioFormatFor(mimeType?: string): string {
   const subtype = (mimeType || "").toLowerCase().split(";")[0]!.split("/")[1]?.replace(/^x-/, "") ?? "";
@@ -203,7 +222,12 @@ function audioFormatFor(mimeType?: string): string {
 }
 
 // `ImagePart.resolution` as OpenRouter's `image_url.detail` (api-ref ChatContentImage: auto, low, high, original; `original` is downgraded to `high` where unsupported); videos have no such field; in: an image part, out: contentPartsToBlocks.
-const IMAGE_DETAIL: Record<string, "low" | "auto" | "high" | "original"> = { low: "low", medium: "auto", high: "high", ultra_high: "original" };
+const IMAGE_DETAIL: Record<string, "low" | "auto" | "high" | "original"> = {
+  low: "low",
+  medium: "auto",
+  high: "high",
+  ultra_high: "original",
+};
 
 // True when a request's messages carry an image or video by web link (the router fetches those itself); in: the built messages, out: throwIfError's hint.
 function hasRemoteMedia(messages: ChatMessage[]): boolean {
@@ -211,7 +235,9 @@ function hasRemoteMedia(messages: ChatMessage[]): boolean {
     (m) =>
       Array.isArray(m.content) &&
       (m.content as ChatContentPart[]).some((p) => {
-        const url = (p as { image_url?: { url?: string }; video_url?: { url?: string } }).image_url?.url ?? (p as { video_url?: { url?: string } }).video_url?.url;
+        const url =
+          (p as { image_url?: { url?: string }; video_url?: { url?: string } }).image_url?.url ??
+          (p as { video_url?: { url?: string } }).video_url?.url;
         return typeof url === "string" && /^https?:\/\//.test(url);
       })
   );
@@ -258,10 +284,7 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<ChatContentPa
       const mimeType = (part as { mimeType?: string }).mimeType;
       // OpenAI chat audio shape (router parsed it live; capability routing
       // decides per model). Always inline — `input_audio` carries data only.
-      const norm = await normalizeMediaInput(
-        raw as string | Uint8Array | ArrayBuffer,
-        mimeType
-      );
+      const norm = await normalizeMediaInput(raw as string | Uint8Array | ArrayBuffer, mimeType);
       blocks.push({
         type: "input_audio",
         input_audio: { data: norm.base64Data, format: audioFormatFor(norm.mimeType) },
@@ -273,7 +296,12 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<ChatContentPa
       const fileData =
         typeof raw === "string" && (raw.startsWith("http://") || raw.startsWith("https://"))
           ? raw
-          : (await normalizeMediaInput(raw as string | Uint8Array | ArrayBuffer, (part as { mimeType?: string }).mimeType)).dataUrl;
+          : (
+              await normalizeMediaInput(
+                raw as string | Uint8Array | ArrayBuffer,
+                (part as { mimeType?: string }).mimeType
+              )
+            ).dataUrl;
       blocks.push({
         type: "file",
         file: { ...(typeof filename === "string" && filename ? { filename } : {}), file_data: fileData },
@@ -329,10 +357,16 @@ async function fullHistoryMessages(context: ProviderContext): Promise<ChatMessag
         messages.push({ role: "assistant", content: "I have processed the tool results." });
       }
       if (typeof m.content === "string") {
-        if (m.content) { messages.push({ role: "user", content: m.content }); lastRole = "user"; }
+        if (m.content) {
+          messages.push({ role: "user", content: m.content });
+          lastRole = "user";
+        }
       } else {
         const blocks = await contentPartsToBlocks(m.content);
-        if (blocks.length > 0) { messages.push({ role: "user", content: blocks }); lastRole = "user"; }
+        if (blocks.length > 0) {
+          messages.push({ role: "user", content: blocks });
+          lastRole = "user";
+        }
       }
     } else if (m.role === "assistant") {
       if (typeof m.content === "string") {
@@ -414,7 +448,8 @@ function mapUsage(raw?: ChatUsage): TokenUsage {
     cacheWriteTokens: raw?.prompt_tokens_details?.cache_write_tokens ?? 0,
     thinkingTokens: raw?.completion_tokens_details?.reasoning_tokens ?? 0,
   };
-  if (typeof raw?.cost === "number" && raw.cost >= 0) { // an explicit 0 (a free model, a response-cache hit) is a known cost, not a missing one
+  if (typeof raw?.cost === "number" && raw.cost >= 0) {
+    // an explicit 0 (a free model, a response-cache hit) is a known cost, not a missing one
     usage.cost = { totalCost: raw.cost };
   }
   return usage;
@@ -460,7 +495,12 @@ export class OpenRouterChatCompletionsProvider implements Provider {
     const { effort } = mapThinkingLevelToOpenRouterChat(options?.thinking?.level);
     const serviceTier = mapServiceTierToOpenRouter(options?.serviceTier);
     // Anthropic models take a top-level `cache_control` TTL; every other route caches implicitly (docs: prompt-caching.md).
-    const cache = resolveCache("openrouter", options?.cache, /^~?anthropic\//.test(modelId) ? ["implicit", "5m", "1h"] : ["implicit"], `openrouter/${modelId}`);
+    const cache = resolveCache(
+      "openrouter",
+      options?.cache,
+      /^~?anthropic\//.test(modelId) ? ["implicit", "5m", "1h"] : ["implicit"],
+      `openrouter/${modelId}`
+    );
     warnIgnoredMediaResolution("openrouter", context.messages, `openrouter/${modelId}`, ["video"]);
 
     // Structured outputs: native `response_format` when supported, else
@@ -485,7 +525,8 @@ export class OpenRouterChatCompletionsProvider implements Provider {
         provider: "openrouter",
         capability: "structured output",
         requested: `${outputSpec.name} (openrouter/${modelId})`,
-        reason: "the catalog reports structured_output: false for this model, so native response_format is unsupported.",
+        reason:
+          "the catalog reports structured_output: false for this model, so native response_format is unsupported.",
         fallback: "emulated JSON instruction + client validation (no response_format is sent)",
       });
     }
@@ -505,7 +546,7 @@ export class OpenRouterChatCompletionsProvider implements Provider {
     if (serviceTier) body.service_tier = serviceTier;
     if (cache === "5m" || cache === "1h") body.cache_control = { type: "ephemeral", ttl: cache };
     // Documented Chat Completions generation controls (only those the caller set).
-    Object.assign(body, mapGenerationParamsToChat(options, "openrouter", `openrouter/${modelId}`));
+    Object.assign(body, mapGenerationParamsToChat(options));
     // Structured outputs: Chat Completions `response_format{type:json_schema,json_schema}`.
     // Skipped when emulated (unsupported model): instruction already in messages.
     if (outputSpec && !outputEmulated) {
@@ -537,11 +578,7 @@ export class OpenRouterChatCompletionsProvider implements Provider {
   ): RequestInit {
     // Attribution + session headers mirror the previous transport exactly
     // (HTTP-Referer / X-Title / x-session-id / x-client-request-id).
-    const headers: Record<string, string> = buildSessionHeaders(
-      "openrouter",
-      options?.headers,
-      sessionId
-    );
+    const headers: Record<string, string> = buildSessionHeaders("openrouter", options?.headers, sessionId);
     setHeaderCaseInsensitive(headers, "Content-Type", "application/json");
     if (apiKey !== "unused") setHeaderCaseInsensitive(headers, "Authorization", `Bearer ${apiKey}`);
     return { method: "POST", headers, body: JSON.stringify(body), signal };
@@ -593,10 +630,16 @@ export class OpenRouterChatCompletionsProvider implements Provider {
     options?: ProviderRequestOptions
   ): Promise<ProviderGenerateResult> {
     // The whole call stays bounded by `timeoutMs`; the stream's own timer only covers the wait for its first byte.
-    const { signal, cleanup } = combinedSignal(options?.signal, timeoutFor(options as { timeoutMs?: number } | undefined));
+    const { signal, cleanup } = combinedSignal(
+      options?.signal,
+      timeoutFor(options as { timeoutMs?: number } | undefined)
+    );
     try {
       // Nobody reads the deltas here, so the stream keeps none (a burst of frames would overflow its buffer for nothing).
-      const events = this.streamInto(new AssistantMessageEventStream({ buffer: false }), model, context, { ...options, signal });
+      const events = this.streamInto(new AssistantMessageEventStream({ buffer: false }), model, context, {
+        ...options,
+        signal,
+      });
       const res = await events.result();
       return {
         text: res.text,
@@ -648,7 +691,7 @@ export class OpenRouterChatCompletionsProvider implements Provider {
       try {
         const apiKey = resolveApiKey(options);
         if (!apiKey) {
-          throw new Error(
+          throw new ConfigError(
             "[Agent Accelerator] Missing OpenRouter API key. Set OPENROUTER_API_KEY or pass apiKey."
           );
         }
@@ -675,9 +718,14 @@ export class OpenRouterChatCompletionsProvider implements Provider {
         // Transient failures (429/5xx/network) are retried here, before the
         // first byte; once the stream is live it is never retried.
         const res = await openStreamResponse({
-          fetchOnce: () => withAbortTimer(linked, streamTimeoutMs, () => (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, linked.signal))),
-          onHttpError: (r, text) => this.throwIfError(r.status, url, text, clean, headersToRecord(r.headers), hasRemoteMedia(body.messages)),
-          noBodyError: () => toConciseProviderError(new Error("OpenRouter streaming response had no body"), "openrouter", clean),
+          fetchOnce: () =>
+            withAbortTimer(linked, streamTimeoutMs, () =>
+              (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, linked.signal))
+            ),
+          onHttpError: (r, text) =>
+            this.throwIfError(r.status, url, text, clean, headersToRecord(r.headers), hasRemoteMedia(body.messages)),
+          noBodyError: () =>
+            toConciseProviderError(new Error("OpenRouter streaming response had no body"), "openrouter", clean),
           retry: retryOptionsFrom(options),
           signal: linked.signal,
           label: { providerId: "openrouter", modelId: clean },
@@ -686,7 +734,11 @@ export class OpenRouterChatCompletionsProvider implements Provider {
         res.headers.forEach((v, k) => {
           responseHeaders[k] = v;
         });
-        const responseMeta: Record<string, unknown> & { status: number; statusText: string; headers: Record<string, string> } = { status: res.status, statusText: res.statusText, headers: responseHeaders };
+        const responseMeta: Record<string, unknown> & {
+          status: number;
+          statusText: string;
+          headers: Record<string, string>;
+        } = { status: res.status, statusText: res.statusText, headers: responseHeaders };
         eventStream.push({ type: "start", raw: { request: rawRequest } } as never);
 
         let text = "";
@@ -721,7 +773,9 @@ export class OpenRouterChatCompletionsProvider implements Provider {
           }
           // Mid-stream provider error: top-level `error`, HTTP stays 200.
           // Must surface — resolving empty success hides it.
-          const topError = msg["error"] as { message?: string; code?: string | number; metadata?: { error_type?: string } } | undefined;
+          const topError = msg["error"] as
+            | { message?: string; code?: string | number; metadata?: { error_type?: string } }
+            | undefined;
           if (topError && typeof topError === "object") {
             const message =
               typeof topError.message === "string" && topError.message
@@ -738,7 +792,8 @@ export class OpenRouterChatCompletionsProvider implements Provider {
           if (typeof msg["id"] === "string" && !responseId) {
             responseId = msg["id"] as string;
           }
-          const choice = (Array.isArray(msg["choices"]) ? (msg["choices"] as Record<string, unknown>[])[0] : undefined) ?? {};
+          const choice =
+            (Array.isArray(msg["choices"]) ? (msg["choices"] as Record<string, unknown>[])[0] : undefined) ?? {};
           const delta = (choice["delta"] as Record<string, unknown>) ?? {};
           // Text delta (content-free accounting frames carry "" — ignored).
           // Refusal deltas surface as text with a `refusal` finish.

package/src/providers/registry.ts

@@ -1,3 +1,4 @@
+import { ConfigError } from "../types/errors.ts";
 import type { Provider, ProviderId, ModelSpec } from "../types/model.ts";
 import type { ThinkingLevel } from "../types/core.ts";
 import { OpenAICompatibleChatProvider } from "./openai-compat.ts";
@@ -30,12 +31,7 @@ providerRegistry.set("openai", openaiProvider);
 //   MODEL="cerebras/gpt-oss-120b"      + CEREBRAS_API_KEY + CEREBRAS_BASE_URL
 //   MODEL="ollama/qwen2.5-coder"        + OLLAMA_BASE_URL (key optional for local)
 // ---------------------------------------------------------------------------
-const FIRST_CLASS = new Set([
-  "google",
-  "gemini",
-  "openrouter",
-  "openai",
-]);
+const FIRST_CLASS = new Set(["google", "gemini", "openrouter", "openai"]);
 
 // Removed providers: fail loudly instead of misrouting. OpenCode free models
 // are harness-only since 2026, so the opencode/opencode-go prefixes no longer
@@ -54,7 +50,7 @@ function removedProviderMessage(id: string): string {
 /** Throws for removed provider prefixes. */
 function assertProviderNotRemoved(id: string): void {
   if (REMOVED_PROVIDERS.has(id.trim().toLowerCase())) {
-    throw new Error(removedProviderMessage(id.trim()));
+    throw new ConfigError(removedProviderMessage(id.trim()));
   }
 }
 
@@ -83,7 +79,7 @@ export function ensureCustomProvider(
   const id = normalizeProviderPrefix(prefix) as ProviderId;
   if (FIRST_CLASS.has(id.toLowerCase())) {
     if (opts?.baseUrl !== undefined || opts?.apiKey !== undefined) {
-      throw new Error(
+      throw new ConfigError(
         `[Agent Accelerator] Provider "${id}" is first-class and cannot be replaced with custom baseUrl/apiKey. Pass baseUrl/apiKey per-Agent instead.`
       );
     }
@@ -93,7 +89,7 @@ export function ensureCustomProvider(
   if (existing) {
     const prevBase = (existing as { configuredBaseUrl?: string }).configuredBaseUrl;
     if (opts?.baseUrl !== undefined && prevBase !== undefined && prevBase !== opts.baseUrl) {
-      throw new Error(
+      throw new ConfigError(
         `[Agent Accelerator] Conflicting re-registration for provider "${id}". Registry is immutable after creation.`
       );
     }
@@ -120,7 +116,7 @@ export function getProvider(id: ProviderId | string): Provider {
   const provider = providerRegistry.get(key);
   if (provider) return provider;
   if (!key) {
-    throw new Error(
+    throw new ConfigError(
       `Provider '' is not supported or not registered. Available first-support providers: google, openrouter, openai — or any custom prefix via {PREFIX}_API_KEY + {PREFIX}_BASE_URL.`
     );
   }
@@ -146,7 +142,7 @@ export interface ResolvedModel {
  */
 export function resolveModel(model: string | ModelSpec): ResolvedModel {
   if (!model || (typeof model === "string" && !model.trim())) {
-    throw new Error(
+    throw new ConfigError(
       "[Agent Accelerator] No model specified. Please specify 'model' in Agent configuration or set the MODEL environment variable."
     );
   }
@@ -167,9 +163,7 @@ export function resolveModel(model: string | ModelSpec): ResolvedModel {
   // Try catalog first for any provider/model
   const tryCatalogLookup = (prov: string, mid: string): ModelSpec | undefined => {
     return (
-      getModelFromCatalog(prov, mid) ||
-      getModelFromCatalog(prov.toLowerCase(), mid) ||
-      getModelFromCatalog(mid, mid)
+      getModelFromCatalog(prov, mid) || getModelFromCatalog(prov.toLowerCase(), mid) || getModelFromCatalog(mid, mid)
     );
   };
 
@@ -193,11 +187,7 @@ export function resolveModel(model: string | ModelSpec): ResolvedModel {
     }
 
     // 2. Unified layer: any non-first-class prefix routes to auto-created custom provider
-    const isExplicitOther = [
-      "google",
-      "gemini",
-      "openrouter",
-    ].includes(providerPrefix);
+    const isExplicitOther = ["google", "gemini", "openrouter"].includes(providerPrefix);
 
     if (!isExplicitOther && providerPrefix !== "openai") {
       const envName = providerPrefix.toUpperCase().replace(/[^A-Z0-9]/g, "_");
@@ -209,8 +199,7 @@ export function resolveModel(model: string | ModelSpec): ResolvedModel {
         getEnv(`${envName}_BASE_API_KEY`)
       );
 
-      const looksLikeOpenRouterScope =
-        parts.length === 2 && modelStr.includes(":") && !hasDedicatedEnv;
+      const looksLikeOpenRouterScope = parts.length === 2 && modelStr.includes(":") && !hasDedicatedEnv;
 
       if (!looksLikeOpenRouterScope) {
         const custom = ensureCustomProvider(providerPrefix);
@@ -250,9 +239,7 @@ export function resolveModel(model: string | ModelSpec): ResolvedModel {
     }
 
     // Check catalog for this exact provider/model
-    const catalogSpec =
-      tryCatalogLookup(providerPrefix, remainingModel) ||
-      tryCatalogLookup(providerPrefix, modelStr);
+    const catalogSpec = tryCatalogLookup(providerPrefix, remainingModel) || tryCatalogLookup(providerPrefix, modelStr);
     if (catalogSpec) {
       const internalProvider = getProvider(catalogSpec.provider);
       return { provider: internalProvider, modelId: catalogSpec.id, modelSpec: catalogSpec };
@@ -276,8 +263,7 @@ export function resolveModel(model: string | ModelSpec): ResolvedModel {
 
     // Fallback custom provider
     const fallbackCustom = ensureCustomProvider(providerPrefix);
-    const fallbackSpec =
-      fallbackCustom.getModel(remainingModel) || fallbackCustom.getModel(modelStr);
+    const fallbackSpec = fallbackCustom.getModel(remainingModel) || fallbackCustom.getModel(modelStr);
     return {
       provider: fallbackCustom,
       modelId: remainingModel,

package/src/providers/shared.ts

@@ -28,9 +28,7 @@ export function parseArguments(raw: string | undefined): Record<string, unknown>
 
 /** Trims/collapses assembled thinking parts (no edge-tripling). */
 export function normalizeThinkingParts(parts: string[]): string | undefined {
-  const cleaned = parts
-    .map((p) => p.replace(/\n{3,}/g, "\n\n").trim())
-    .filter((p) => p.length > 0);
+  const cleaned = parts.map((p) => p.replace(/\n{3,}/g, "\n\n").trim()).filter((p) => p.length > 0);
   return cleaned.length > 0 ? cleaned.join("\n") : undefined;
 }
 
@@ -49,21 +47,35 @@ export function redactedHeaders(headers: Record<string, string>): Record<string,
  * OpenAI `type`, OpenRouter `metadata.error_type` + `metadata.raw` + `metadata.limit_source`, and Google
  * `status` code shapes; unknown bodies degrade to a 300-char slice.
  */
-export function readErrorPayload(
-  bodyText: string
-): { message: string; code?: string | number; errorType?: string; raw?: string; limitSource?: string } {
+export function readErrorPayload(bodyText: string): {
+  message: string;
+  code?: string | number;
+  errorType?: string;
+  raw?: string;
+  limitSource?: string;
+} {
   try {
     const parsed: unknown = JSON.parse(bodyText);
     const first = Array.isArray(parsed) ? parsed[0] : parsed;
-    const err = (first as { error?: { message?: string; code?: string | number; type?: string; status?: string | number; metadata?: { error_type?: string; raw?: unknown; limit_source?: unknown } } })?.error;
+    const err = (
+      first as {
+        error?: {
+          message?: string;
+          code?: string | number;
+          type?: string;
+          status?: string | number;
+          metadata?: { error_type?: string; raw?: unknown; limit_source?: unknown };
+        };
+      }
+    )?.error;
     if (err && typeof err.message === "string") {
       const code = err.code ?? err.status;
-      const errorType =
-        err.type ?? err.metadata?.error_type ?? (first as { error_type?: string })?.error_type;
+      const errorType = err.type ?? err.metadata?.error_type ?? (first as { error_type?: string })?.error_type;
       const rawCandidate =
         (err as { metadata?: { raw?: unknown } }).metadata?.raw ??
         (first as { metadata?: { raw?: unknown } })?.metadata?.raw;
-      const raw = typeof rawCandidate === "string" && rawCandidate.trim() ? rawCandidate.trim().slice(0, 500) : undefined;
+      const raw =
+        typeof rawCandidate === "string" && rawCandidate.trim() ? rawCandidate.trim().slice(0, 500) : undefined;
       return {
         message: err.message,
         ...(code !== undefined ? { code } : {}),
@@ -78,7 +90,7 @@ export function readErrorPayload(
   }
 }
 
-/** Retryable incomplete-stream error for truncated SSE. */
+/** Retryable incomplete-stream error for truncated SSE: a `ProviderError` whose `code` is `incomplete_stream`. */
 export function incompleteStreamError(provider: string, modelId: string): Error {
   const err = toConciseProviderError(
     Object.assign(new Error("Stream ended without terminal event"), {
@@ -110,12 +122,10 @@ export function isNotFoundChainError(error: unknown): boolean {
       NaN
   );
   if (status === 404) return true;
-  const code = String(
-    (err["code"] as string | undefined) ??
-      (err["errorType"] as string | undefined) ??
-      ""
-  ).toLowerCase();
-  return code === "not_found";
+  // `providerCode` on a wrapped ProviderError (its `code` is the SDK kind), `code` on a raw error.
+  return [err["providerCode"], err["code"], err["errorType"]].some(
+    (c) => String(c ?? "").toLowerCase() === "not_found"
+  );
 }
 
 /** Per-request timeout ms from provider options. */
@@ -125,25 +135,40 @@ export function timeoutFor(options: { timeoutMs?: number } | undefined): number
 }
 
 /** Merges a parent signal with a timeout into one effective signal. Caller must call cleanup when the request settles so the timer never holds the loop open. */
-export function combinedSignal(signal?: AbortSignal, timeoutMs?: number): { signal: AbortSignal | undefined; cleanup: () => void } {
+export function combinedSignal(
+  signal?: AbortSignal,
+  timeoutMs?: number
+): { signal: AbortSignal | undefined; cleanup: () => void } {
   if (timeoutMs === undefined) return { signal, cleanup: () => {} };
   const ctrl = new AbortController();
   const timer = setTimeout(() => {
-    try { ctrl.abort(); } catch {}
+    try {
+      ctrl.abort();
+    } catch {}
   }, timeoutMs);
-  try { (timer as unknown as { unref?: () => void }).unref?.(); } catch {}
+  try {
+    (timer as unknown as { unref?: () => void }).unref?.();
+  } catch {}
   const cleanup = () => {
-    try { clearTimeout(timer); } catch {}
+    try {
+      clearTimeout(timer);
+    } catch {}
   };
   if (signal) {
     if (signal.aborted) {
       cleanup();
       ctrl.abort(signal.reason); // the caller's reason survives (`interrupt(new Error("..."))`)
     } else {
-      signal.addEventListener("abort", () => {
-        cleanup();
-        try { ctrl.abort(signal.reason); } catch {}
-      }, { once: true });
+      signal.addEventListener(
+        "abort",
+        () => {
+          cleanup();
+          try {
+            ctrl.abort(signal.reason);
+          } catch {}
+        },
+        { once: true }
+      );
     }
   }
   return { signal: ctrl.signal, cleanup };
@@ -171,7 +196,11 @@ export function hasAuthHeader(headers: Record<string, string> | undefined): bool
   if (!headers) return false;
   for (const [k, v] of Object.entries(headers)) {
     const lower = k.toLowerCase();
-    if ((lower === "authorization" || lower === "cf-aig-authorization") && typeof v === "string" && v.trim().length > 0) {
+    if (
+      (lower === "authorization" || lower === "cf-aig-authorization") &&
+      typeof v === "string" &&
+      v.trim().length > 0
+    ) {
       return true;
     }
   }
@@ -184,7 +213,10 @@ export function hasTruncatedToolArguments(args: unknown): boolean {
 }
 
 // True when a stream with no terminal event left a tool call whose arguments never fully arrived (none at all, or cut mid-JSON); in: the adapter's assembled calls and their records, out: its incomplete_stream guard.
-export function hasUnfinishedToolCall(calls: Iterable<{ startArgs: string; deltaArgs: string }>, toolCalls: Array<{ arguments: unknown }>): boolean {
+export function hasUnfinishedToolCall(
+  calls: Iterable<{ startArgs: string; deltaArgs: string }>,
+  toolCalls: Array<{ arguments: unknown }>
+): boolean {
   for (const c of calls) if (!c.startArgs.trim() && !c.deltaArgs.trim()) return true;
   return toolCalls.some((c) => isTruncatedArguments(c.arguments));
 }
@@ -224,7 +256,9 @@ export function clampToolCallId(id: string): string {
 
 // The finish reason of a turn that produced tool calls: `tool_calls`, except that a turn cut off by the output limit (`length`) keeps saying so when one of its calls was cut mid-JSON; in: the wire finish reason + the assembled calls, out: each streaming adapter.
 export function toolTurnFinishReason(finishReason: string, toolCalls: Array<{ arguments: unknown }>): string {
-  return finishReason === "length" && toolCalls.some((c) => isTruncatedArguments(c.arguments)) ? "length" : "tool_calls";
+  return finishReason === "length" && toolCalls.some((c) => isTruncatedArguments(c.arguments))
+    ? "length"
+    : "tool_calls";
 }
 
 // The JSON text of a tool call's arguments for a history message: `{}` for a call whose streamed arguments were cut off (the internal `__truncated_raw` marker was never the model's own output and is never resent); in: a stored tool call, out: each adapter's history builder.
@@ -253,7 +287,8 @@ export function parseRetryAfterMs(headers: Record<string, string> | undefined, n
     return undefined;
   };
   const ms = get("retry-after-ms");
-  if (ms !== undefined && ms.trim() !== "" && Number.isFinite(Number(ms)) && Number(ms) >= 0) return Math.round(Number(ms));
+  if (ms !== undefined && ms.trim() !== "" && Number.isFinite(Number(ms)) && Number(ms) >= 0)
+    return Math.round(Number(ms));
   const ra = get("retry-after");
   if (ra === undefined || ra.trim() === "") return undefined;
   const secs = Number(ra);
@@ -291,12 +326,16 @@ export function openStreamResponse(args: {
 }
 
 /** Retry knobs from provider request options, in the shape `withRetries` expects. */
-export function retryOptionsFrom(options: {
-  maxRetries?: number;
-  maxRetryDelayMs?: number;
-  retryBaseDelayMs?: number;
-  retryBudgetMs?: number;
-} | undefined): { maxRetries?: number; maxRetryDelayMs?: number; baseDelayMs?: number; retryBudgetMs?: number } {
+export function retryOptionsFrom(
+  options:
+    | {
+        maxRetries?: number;
+        maxRetryDelayMs?: number;
+        retryBaseDelayMs?: number;
+        retryBudgetMs?: number;
+      }
+    | undefined
+): { maxRetries?: number; maxRetryDelayMs?: number; baseDelayMs?: number; retryBudgetMs?: number } {
   return {
     maxRetries: options?.maxRetries,
     maxRetryDelayMs: options?.maxRetryDelayMs,
@@ -310,7 +349,10 @@ export function retryOptionsFrom(options: {
 // ---------------------------------------------------------------------------
 
 // Ties a provider stream to the caller's signal and to the stream's own cancel: one controller that aborts when either does; in: an adapter's stream(), out: the controller its request uses and the `release` its finally block calls.
-export function linkStreamAbort(eventStream: AssistantMessageEventStream, signal: AbortSignal | undefined): { linked: AbortController; release: () => void } {
+export function linkStreamAbort(
+  eventStream: AssistantMessageEventStream,
+  signal: AbortSignal | undefined
+): { linked: AbortController; release: () => void } {
   const linked = new AbortController();
   const forwardUserAbort = (): void => {
     try {
@@ -342,7 +384,11 @@ export function linkStreamAbort(eventStream: AssistantMessageEventStream, signal
 }
 
 // Runs one request attempt under a timer that aborts `controller` after `ms` (none when unset); in: an adapter's fetchOnce, out: its Response.
-export async function withAbortTimer<T>(controller: AbortController, ms: number | undefined, run: () => Promise<T>): Promise<T> {
+export async function withAbortTimer<T>(
+  controller: AbortController,
+  ms: number | undefined,
+  run: () => Promise<T>
+): Promise<T> {
   const timer =
     ms && ms > 0
       ? setTimeout(() => {
@@ -401,13 +447,17 @@ export function incompleteStreamCheck(a: {
 }): Error | undefined {
   if (a.hasTerminal || !(a.empty || a.unfinishedCall)) return undefined;
   const contentType = Object.entries(a.responseHeaders).find(([k]) => k.toLowerCase() === "content-type")?.[1];
-  const isSSEPayload = (typeof contentType === "string" && (contentType.includes("event-stream") || contentType.startsWith("text/"))) || a.framesSeen > 0 || a.badFrames > 0;
+  const isSSEPayload =
+    (typeof contentType === "string" && (contentType.includes("event-stream") || contentType.startsWith("text/"))) ||
+    a.framesSeen > 0 ||
+    a.badFrames > 0;
   return isSSEPayload ? incompleteStreamError(a.provider, a.modelId) : undefined;
 }
 
 // Fails a stream with the right error: an abort (the signal, the stream's cancel, or an AbortError) becomes the plain `AbortError`, anything else passes through; in: an adapter's catch block, out: the stream's result() rejection.
 export function failStream(eventStream: AssistantMessageEventStream, linked: AbortController, err: unknown): void {
   const raw = err instanceof Error ? err : new Error(String(err));
-  const isAbort = linked.signal.aborted || eventStream.isCancelled() || (raw as { name?: string }).name === "AbortError";
+  const isAbort =
+    linked.signal.aborted || eventStream.isCancelled() || (raw as { name?: string }).name === "AbortError";
   eventStream.fail(isAbort ? Object.assign(new Error("Stream aborted"), { name: "AbortError" }) : raw);
 }