agent-accelerator 0.5.9 → 0.6.5

package/src/utils/errors.ts

@@ -21,7 +21,9 @@ export function isTransientError(error: unknown): boolean {
       NaN
   );
   if ([408, 425, 429, 500, 502, 503, 504].includes(status)) return true;
-  const code = String((err["providerCode"] as string | undefined) ?? (err["code"] as string | undefined) ?? "").toUpperCase();
+  const code = String(
+    (err["providerCode"] as string | undefined) ?? (err["code"] as string | undefined) ?? ""
+  ).toUpperCase();
   if (["ECONNRESET", "ECONNREFUSED", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT", "EPIPE", "ETIMEDOUT"].includes(code)) {
     return true;
   }
@@ -114,9 +116,7 @@ export function toConciseProviderError(error: unknown, providerId: string, model
     // Forwarded when present (e.g. OpenRouter's canonical `error_type`,
     // which disambiguates lossy native codes). Survives re-wraps so retry
     // helpers never strip it.
-    ...(typeof err?.errorType === "string"
-      ? { errorType: { value: err.errorType, enumerable: false } }
-      : {}),
+    ...(typeof err?.errorType === "string" ? { errorType: { value: err.errorType, enumerable: false } } : {}),
     // The provider's own error code (e.g. Google's `not_found` chain-eviction code, which carries no HTTP status on
     // SSE error frames); `code` itself is the SDK kind (`"provider"`). Survives re-wraps so chain detectors never lose it.
     ...((typeof err?.code === "string" || typeof err?.code === "number") && err.code !== ""
@@ -148,11 +148,7 @@ const PART_TO_MODALITY: Record<string, "image" | "audio" | "video" | "pdf"> = {
  * models (custom providers, dynamic routers) are skipped: the provider
  * verdict stands and surfaces via toConciseProviderError instead. Throws a `ValidationError`.
  */
-export function assertModalitiesSupported(
-  context: ProviderContext,
-  providerId: string,
-  modelId: string
-): void {
+export function assertModalitiesSupported(context: ProviderContext, providerId: string, modelId: string): void {
   const needed = new Set<string>();
   for (const msg of context.messages) {
     if (!Array.isArray((msg as any)?.content)) continue;
@@ -185,17 +181,13 @@ export function assertModalitiesSupported(
  * That wire has no video shape — only `input_text`/`input_image`/`input_file`
  * exist in either vendor's Responses docs — so a video part sent as
  * `input_file` lands in the router's document parser and 400s confusingly
- * (`Failed to parse the file ... Provide a PDF document`, observed live on
- * `openrouter/stealth/space-bunny-alpha` under the old Responses skin despite
- * its catalog `video` flag, which is chat-transport oriented). Fail fast with
+ * (`Failed to parse the file ... Provide a PDF document`, observed live under
+ * the old OpenRouter Responses skin despite the catalog `video` flag, which is
+ * chat-transport oriented). Fail fast with
  * a clear one-liner instead; video stays Gemini-only, and OpenRouter Chat
  * Completions carries `video_url` natively (no guard there). Throws a `ValidationError`.
  */
-export function assertNoVideoPartsOnResponses(
-  context: ProviderContext,
-  providerId: string,
-  modelId: string
-): void {
+export function assertNoVideoPartsOnResponses(context: ProviderContext, providerId: string, modelId: string): void {
   let hasVideo = false;
   for (const msg of context.messages) {
     if (!Array.isArray((msg as any)?.content)) continue;

package/src/utils/headers.ts

@@ -24,7 +24,7 @@ export function getPackageVersion(): string {
     const v = (globalThis as any).process?.env?.npm_package_version;
     if (typeof v === "string" && v) return v;
   } catch {}
-  return "0.5.9";
+  return "0.6.5";
 }
 
 // User-Agent string with version and platform; in: AGENT_ACCEL_USER_AGENT, out: a string.
@@ -93,11 +93,7 @@ function findHeaderKey(headers: Record<string, string>, name: string): string |
  * coexist on the wire.
  * @example `setHeaderCaseInsensitive(headers, "Authorization", "Bearer k");`
  */
-export function setHeaderCaseInsensitive(
-  headers: Record<string, string>,
-  name: string,
-  value: string
-): void {
+export function setHeaderCaseInsensitive(headers: Record<string, string>, name: string, value: string): void {
   const existing = findHeaderKey(headers, name);
   if (existing !== undefined && existing !== name) delete headers[existing];
   headers[name] = value;
@@ -111,10 +107,7 @@ export function setHeaderCaseInsensitive(
  * Returns true when a stored signature may be echoed on `currentProvider`:
  * untagged (legacy) echoes everywhere, tagged echoes only on a match.
  */
-export function shouldEchoSignature(
-  storedProvider: unknown,
-  currentProvider: string
-): boolean {
+export function shouldEchoSignature(storedProvider: unknown, currentProvider: string): boolean {
   if (!storedProvider) return true;
   return storedProvider === currentProvider;
 }

package/src/utils/media.ts

@@ -2,6 +2,7 @@
 // paths are loaded via a lazy dynamic import so browsers never resolve it.
 import { bytesToBase64, base64ToBytes } from "./base64.ts";
 import { fetchRemoteBytes } from "./safe-io.ts";
+import { ValidationError } from "../types/errors.ts";
 
 export interface NormalizedMedia {
   mimeType: string;
@@ -63,7 +64,12 @@ export function sniffMimeType(bytes: Uint8Array): string | undefined {
   if (ascii(bytes, 0, "FORM") && ascii(bytes, 8, "AIF")) return "audio/aiff";
   if (bytes[0] === 0xff && ((bytes[1] ?? 0) & 0xf6) === 0xf0) return "audio/aac"; // ADTS: sync bits plus layer 00 (MP3 frames have a non-zero layer)
   if (ascii(bytes, 0, "ID3") || (bytes[0] === 0xff && ((bytes[1] ?? 0) & 0xe0) === 0xe0)) return "audio/mp3";
-  if (ascii(bytes, 4, "ftyp")) return ascii(bytes, 8, "M4A") || ascii(bytes, 8, "M4B") ? "audio/m4a" : ascii(bytes, 8, "qt") ? "video/quicktime" : "video/mp4";
+  if (ascii(bytes, 4, "ftyp"))
+    return ascii(bytes, 8, "M4A") || ascii(bytes, 8, "M4B")
+      ? "audio/m4a"
+      : ascii(bytes, 8, "qt")
+        ? "video/quicktime"
+        : "video/mp4";
   if (bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 1 && bytes[3] === 0xba) return "video/mpeg"; // MPEG program stream
   if (bytes[0] === 0x1a && bytes[1] === 0x45 && bytes[2] === 0xdf && bytes[3] === 0xa3) return "video/webm";
   return undefined;
@@ -72,9 +78,15 @@ export function sniffMimeType(bytes: Uint8Array): string | undefined {
 const GENERIC_MIME = new Set(["", "application/octet-stream", "binary/octet-stream"]);
 
 /** Picks the best MIME type: explicit hint, then a specific candidate, then magic bytes, then the fallback. */
-function resolveMime(explicit: string | undefined, candidate: string | null | undefined, bytes: Uint8Array, fallback: string): string {
+function resolveMime(
+  explicit: string | undefined,
+  candidate: string | null | undefined,
+  bytes: Uint8Array,
+  fallback: string
+): string {
   if (explicit) return explicit;
-  const specific = candidate && !GENERIC_MIME.has(candidate.split(";")[0]!.trim().toLowerCase()) ? candidate : undefined;
+  const specific =
+    candidate && !GENERIC_MIME.has(candidate.split(";")[0]!.trim().toLowerCase()) ? candidate : undefined;
   return specific || sniffMimeType(bytes) || candidate || fallback;
 }
 
@@ -130,7 +142,7 @@ export async function normalizeMediaInput(
     // but redirects are re-checked and the download is size-capped.
     const response = await fetchRemoteBytes(input, { allowPrivateNetwork: true });
     if (!response.ok) {
-      throw new Error(`Failed to fetch media from URL: ${input} (${response.statusText})`);
+      throw new ValidationError(`Failed to fetch media from URL: ${input} (${response.statusText})`);
     }
     const buffer = response.bytes;
     const mimeType = resolveMime(explicitMimeType, response.contentType, buffer, inferMimeType(input));
@@ -175,10 +187,11 @@ export async function normalizeMediaInput(
         base64Data,
         dataUrl: `data:${mimeType};base64,${base64Data}`,
       };
-    } catch (err) {
+    } catch {
       // S11: don't silently return path string as base64 (would 400). Re-check if it's actually base64 with "/"
       const trimmed = input.replace(/\s/g, "");
-      const isMaybeBase64 = trimmed.length > 100 && /^[A-Za-z0-9+/=\n\r]+$/.test(trimmed.slice(0, 500)) && trimmed.length % 4 === 0;
+      const isMaybeBase64 =
+        trimmed.length > 100 && /^[A-Za-z0-9+/=\n\r]+$/.test(trimmed.slice(0, 500)) && trimmed.length % 4 === 0;
       if (isMaybeBase64) {
         const mimeType = explicitMimeType || sniffBase64(trimmed) || "image/jpeg";
         return {
@@ -187,9 +200,11 @@ export async function normalizeMediaInput(
           dataUrl: `data:${mimeType};base64,${trimmed}`,
         };
       }
-      throw new Error(`Failed to normalize media input: not a valid file path, data URL, http URL, or base64 string: ${input.slice(0, 80)}`);
+      throw new ValidationError(
+        `Failed to normalize media input: not a valid file path, data URL, http URL, or base64 string: ${input.slice(0, 80)}`
+      );
     }
   }
 
-  throw new Error(`Unsupported media input type: ${typeof input}`);
+  throw new ValidationError(`Unsupported media input type: ${typeof input}`);
 }

package/src/utils/raw-capture.ts

@@ -16,7 +16,11 @@ function byteLength(value: unknown): number {
 function toolNames(tools: unknown): string[] | undefined {
   if (!Array.isArray(tools)) return undefined;
   const names = tools
-    .map((t) => (t as { name?: unknown; function?: { name?: unknown } })?.name ?? (t as { function?: { name?: unknown } })?.function?.name)
+    .map(
+      (t) =>
+        (t as { name?: unknown; function?: { name?: unknown } })?.name ??
+        (t as { function?: { name?: unknown } })?.function?.name
+    )
     .filter((n): n is string => typeof n === "string");
   return names.length > 0 ? names : undefined;
 }
@@ -56,7 +60,10 @@ function summarizeResponseBody(body: unknown): unknown {
  *   model output never leak through `response.raw` / `toJSON()` into logs.
  * - `false`: keep only URL, method and HTTP status.
  */
-export function applyCaptureRaw(raw: ProviderRawData | undefined, mode: CaptureRawMode | undefined): ProviderRawData | undefined {
+export function applyCaptureRaw(
+  raw: ProviderRawData | undefined,
+  mode: CaptureRawMode | undefined
+): ProviderRawData | undefined {
   if (!raw || mode === true) return raw;
   const redactedMode = mode !== false; // undefined -> default "redacted"
   const request = raw.request

package/src/utils/retry.ts

@@ -13,7 +13,18 @@ export function isRetryableRun(error: unknown): boolean {
   if (!error || isAbortError(error)) return false;
   const name = (error as { name?: unknown }).name;
   if (name === "TimeoutError") return true; // the loop's own request / first-byte / idle timeouts
-  if (["BudgetExceededError", "ConfigError", "ValidationError", "SecurityPolicyError", "SessionLoadError", "ThinkingLevelError", "ToolError"].includes(String(name))) return false;
+  if (
+    [
+      "BudgetExceededError",
+      "ConfigError",
+      "ValidationError",
+      "SecurityPolicyError",
+      "SessionLoadError",
+      "ThinkingLevelError",
+      "ToolError",
+    ].includes(String(name))
+  )
+    return false;
   return isTransientError(error);
 }
 
@@ -24,8 +35,9 @@ export function readRetryAfterMs(error: unknown): number | undefined {
   const direct = err["retryAfterMs"];
   if (typeof direct === "number" && Number.isFinite(direct) && direct >= 0) return Math.min(60_000, direct);
   const raw =
-    ((err["response"] as Record<string, unknown> | undefined)?.["headers"] as Record<string, unknown> | undefined)?.["retry-after"] ??
-    ((err["headers"] as Record<string, unknown> | undefined)?.["retry-after"]);
+    ((err["response"] as Record<string, unknown> | undefined)?.["headers"] as Record<string, unknown> | undefined)?.[
+      "retry-after"
+    ] ?? (err["headers"] as Record<string, unknown> | undefined)?.["retry-after"];
   if (raw === undefined) return undefined;
   const secs = Number(Array.isArray(raw) ? raw[0] : raw);
   if (!Number.isFinite(secs) || secs < 0) return undefined;

package/src/utils/safe-io.ts

@@ -139,19 +139,31 @@ function isPrivateHostname(host: string): boolean {
 // Throws RemoteFetchError for a non-http(s) URL or, unless private hosts are allowed, a private host (also by DNS result); in: fetchRemoteBytes on every hop, out: nothing or a thrown error.
 async function assertRemoteUrlAllowed(url: URL, allowPrivateNetwork: boolean): Promise<void> {
   if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new RemoteFetchError("blocked", `[Agent Accelerator] Only http(s) URLs are allowed (got ${url.protocol}).`, url.href);
+    throw new RemoteFetchError(
+      "blocked",
+      `[Agent Accelerator] Only http(s) URLs are allowed (got ${url.protocol}).`,
+      url.href
+    );
   }
   if (allowPrivateNetwork) return;
   const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
   if (isPrivateHostname(host)) {
-    throw new RemoteFetchError("blocked", `[Agent Accelerator] Refusing to fetch private/internal host "${host}".`, url.href);
+    throw new RemoteFetchError(
+      "blocked",
+      `[Agent Accelerator] Refusing to fetch private/internal host "${host}".`,
+      url.href
+    );
   }
   if (/^[\d.]+$/.test(host) || host.includes(":")) return; // IP literal already checked
   try {
     const dns = await import("node:dns");
     const addrs = await dns.promises.lookup(host, { all: true });
     if (addrs.some((a) => isPrivateAddress(a.address))) {
-      throw new RemoteFetchError("blocked", `[Agent Accelerator] Host "${host}" resolves to a private/internal address.`, url.href);
+      throw new RemoteFetchError(
+        "blocked",
+        `[Agent Accelerator] Host "${host}" resolves to a private/internal address.`,
+        url.href
+      );
     }
   } catch (err) {
     if (err instanceof RemoteFetchError) throw err;
@@ -169,7 +181,9 @@ async function readCapped(res: Response, maxBytes: number, url: string): Promise
     );
   const declared = Number(res.headers.get("content-length"));
   if (Number.isFinite(declared) && declared > maxBytes) {
-    try { await res.body?.cancel(); } catch {}
+    try {
+      await res.body?.cancel();
+    } catch {}
     throw tooLarge();
   }
   if (!res.body) {
@@ -185,7 +199,9 @@ async function readCapped(res: Response, maxBytes: number, url: string): Promise
     if (done) break;
     total += value.byteLength;
     if (total > maxBytes) {
-      try { await reader.cancel(); } catch {}
+      try {
+        await reader.cancel();
+      } catch {}
       throw tooLarge();
     }
     chunks.push(value);
@@ -227,7 +243,11 @@ export async function fetchRemoteBytes(
     if ((res as { type?: string }).type === "opaqueredirect") {
       // Browser runtimes hide the Location header: only trusted callers may follow blindly.
       if (!allowPrivate) {
-        throw new RemoteFetchError("blocked", "[Agent Accelerator] Redirects cannot be validated in this runtime.", current.href);
+        throw new RemoteFetchError(
+          "blocked",
+          "[Agent Accelerator] Redirects cannot be validated in this runtime.",
+          current.href
+        );
       }
       const followed = await fetch(current.href, { signal: opts.signal });
       return {
@@ -240,7 +260,9 @@ export async function fetchRemoteBytes(
     }
     const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
     if (location) {
-      try { await res.body?.cancel(); } catch {}
+      try {
+        await res.body?.cancel();
+      } catch {}
       current = new URL(location, current);
       continue;
     }

package/src/utils/serialization.ts

@@ -53,10 +53,7 @@ export function toJsonSafe(value: unknown, seen = new WeakSet<object>()): unknow
     }
 
     if (value instanceof Map) {
-      return Array.from(value.entries()).map(([key, entry]) => [
-        toJsonSafe(key, seen),
-        toJsonSafe(entry, seen),
-      ]);
+      return Array.from(value.entries()).map(([key, entry]) => [toJsonSafe(key, seen), toJsonSafe(entry, seen)]);
     }
 
     if (value instanceof Set) {

package/src/utils/session.ts

@@ -15,8 +15,7 @@ export function createSessionId(prefix?: string): string {
   const head = prefix ? `${prefix}-` : "";
   let id: string;
   try {
-    const webCrypto =
-      (globalThis as any)?.crypto ?? (typeof crypto !== "undefined" ? crypto : undefined);
+    const webCrypto = (globalThis as any)?.crypto ?? (typeof crypto !== "undefined" ? crypto : undefined);
     if (webCrypto && typeof webCrypto.randomUUID === "function") {
       id = `${head}${webCrypto.randomUUID()}`;
     } else {