agent-accelerator 0.5.5 → 0.5.6

package/src/providers/shared.ts

@@ -9,6 +9,8 @@ import { toConciseProviderError } from "../utils/errors.ts";
 import { withRetries } from "../utils/retry.ts";
 import { redactHeadersCentral } from "../utils/cache.ts";
 import { TRUNCATED_ARGS_KEY, isTruncatedArguments } from "../types/tool.ts";
+import { SSEParser } from "../streaming/sse-parser.ts";
+import type { AssistantMessageEventStream } from "../streaming/event-stream.ts";
 
 /** Parses a JSON tool-argument string; non-objects degrade to the truncated-arguments marker. */
 export function parseArguments(raw: string | undefined): Record<string, unknown> {
@@ -43,17 +45,17 @@ export function redactedHeaders(headers: Record<string, string>): Record<string,
 }
 
 /**
- * Extracts `{ message, code, errorType, raw }` from a non-2xx JSON body. Handles
- * OpenAI `type`, OpenRouter `metadata.error_type` + `metadata.raw`, and Google
+ * Extracts `{ message, code, errorType, raw, limitSource }` from a non-2xx JSON body. Handles
+ * 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 } {
+): { 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 } } })?.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 =
@@ -67,6 +69,7 @@ export function readErrorPayload(
         ...(code !== undefined ? { code } : {}),
         ...(typeof errorType === "string" ? { errorType } : {}),
         ...(raw ? { raw } : {}),
+        ...(typeof err.metadata?.limit_source === "string" ? { limitSource: err.metadata.limit_source } : {}),
       };
     }
     return { message: bodyText.slice(0, 300) };
@@ -180,6 +183,12 @@ export function hasTruncatedToolArguments(args: unknown): boolean {
   return isTruncatedArguments(args);
 }
 
+// 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 {
+  for (const c of calls) if (!c.startArgs.trim() && !c.deltaArgs.trim()) return true;
+  return toolCalls.some((c) => isTruncatedArguments(c.arguments));
+}
+
 /** Short hash for tool-ID clamping (FNV-1a, 8 hex chars, no deps). */
 export function shortHashId(value: string): string {
   let h = 0x811c9dc5;
@@ -198,7 +207,10 @@ export function shortHashId(value: string): string {
 export function clampToolCallId(id: string): string {
   const clean = String(id ?? "").replace(/[^a-zA-Z0-9_-]/g, "_");
   if (!clean.includes("|")) {
-    return clean.length > 40 ? clean.slice(0, 40) : clean || "call_unknown";
+    if (clean.length <= 40) return clean || "call_unknown";
+    // A hard cut would give two long ids with the same first 40 characters the same id; a hash of the whole id keeps them apart.
+    const hash = shortHashId(id);
+    return `${clean.slice(0, 40 - hash.length - 1)}_${hash}`;
   }
   const sep = clean.indexOf("|");
   const callId = clean.slice(0, sep).replace(/_+$/, "") || "call";
@@ -210,6 +222,16 @@ export function clampToolCallId(id: string): string {
   return `${prefix}_${hash}`;
 }
 
+// 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";
+}
+
+// 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.
+export function toolArgumentsJson(args: unknown): string {
+  return isTruncatedArguments(args) ? "{}" : JSON.stringify(args || {});
+}
+
 /** Plain lower-cased header record from a fetch `Headers` object. */
 export function headersToRecord(headers: Headers): Record<string, string> {
   const out: Record<string, string> = {};
@@ -282,3 +304,110 @@ export function retryOptionsFrom(options: {
     retryBudgetMs: options?.retryBudgetMs,
   };
 }
+
+// ---------------------------------------------------------------------------
+// Streaming scaffold shared by the SSE adapters (abort linking, request timer, read loop, end-of-stream check, failure)
+// ---------------------------------------------------------------------------
+
+// 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 } {
+  const linked = new AbortController();
+  const forwardUserAbort = (): void => {
+    try {
+      linked.abort((signal as { reason?: unknown } | undefined)?.reason);
+    } catch {
+      try {
+        linked.abort();
+      } catch {}
+    }
+  };
+  if (signal?.aborted) forwardUserAbort();
+  else signal?.addEventListener("abort", forwardUserAbort, { once: true });
+  const removeStreamCancel = eventStream.onCancel(() => {
+    try {
+      linked.abort();
+    } catch {}
+  });
+  return {
+    linked,
+    release: () => {
+      try {
+        signal?.removeEventListener("abort", forwardUserAbort);
+      } catch {}
+      try {
+        removeStreamCancel();
+      } catch {}
+    },
+  };
+}
+
+// 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> {
+  const timer =
+    ms && ms > 0
+      ? setTimeout(() => {
+          try {
+            controller.abort();
+          } catch {}
+        }, ms)
+      : undefined;
+  try {
+    return await run();
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// Reads an SSE response body to its end, handing each `data:` payload to `onData`; stops with an AbortError as soon as the stream is aborted or cancelled (cancelling the body, whose rejection is absorbed); in: the opened Response body of an SSE adapter, out: calls to onData.
+export async function readSseData(
+  body: ReadableStream<Uint8Array>,
+  linked: AbortController,
+  eventStream: AssistantMessageEventStream,
+  onData: (data: string) => void
+): Promise<void> {
+  const parser = new SSEParser();
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const abort = (): Error => Object.assign(new Error("Stream aborted"), { name: "AbortError" });
+  linked.signal.addEventListener("abort", () => void reader.cancel().catch(() => {}), { once: true }); // an aborted body is already errored: its cancel() rejects, and nobody else listens
+  while (true) {
+    if (linked.signal.aborted || eventStream.isCancelled()) {
+      try {
+        await reader.cancel();
+      } catch {}
+      throw abort();
+    }
+    const { done, value } = await reader.read();
+    if (done) break;
+    for (const m of parser.feed(decoder.decode(value, { stream: true }))) onData(m.data);
+  }
+  for (const m of parser.flush()) onData(m.data);
+  try {
+    reader.releaseLock();
+  } catch {}
+  if (linked.signal.aborted || eventStream.isCancelled()) throw abort();
+}
+
+// The error to fail with when an SSE stream ended without its final event while carrying no content or an unfinished tool call (checked only for real SSE payloads, not JSON mocks); in: the adapter's state after reading, out: `eventStream.fail`, else undefined.
+export function incompleteStreamCheck(a: {
+  provider: string;
+  modelId: string;
+  hasTerminal: boolean;
+  empty: boolean;
+  unfinishedCall: boolean;
+  responseHeaders: Record<string, string>;
+  framesSeen: number;
+  badFrames: number;
+}): 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;
+  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";
+  eventStream.fail(isAbort ? Object.assign(new Error("Stream aborted"), { name: "AbortError" }) : raw);
+}

package/src/providers.ts

@@ -248,17 +248,17 @@ export function resolveCache(
   return undefined;
 }
 
-/** Warns once per provider/model that per-media `resolution` is ignored (no such control on that wire); in: an adapter's request messages, out: telemetry bus only. */
-export function warnIgnoredMediaResolution(provider: string, messages: Message[], modelRef: string): void {
+/** Warns once per provider/model that per-media `resolution` is ignored (no such control on that wire for the given kinds of media); in: an adapter's request messages, out: telemetry bus only. */
+export function warnIgnoredMediaResolution(provider: string, messages: Message[], modelRef: string, kinds: Array<"image" | "video"> = ["image", "video"]): void {
   const used = messages.some(
-    (m) => Array.isArray(m.content) && m.content.some((p) => (p.type === "image" || p.type === "video") && p.resolution)
+    (m) => Array.isArray(m.content) && m.content.some((p) => (p.type === "image" || p.type === "video") && kinds.includes(p.type) && p.resolution)
   );
   if (!used) return;
   emitProviderWarning({
     provider,
     capability: "media resolution",
     requested: modelRef,
-    reason: "this provider has no per-media detail control (Google only).",
+    reason: "this provider has no per-media detail control for this kind of media.",
     fallback: "the provider's default detail",
   });
 }
@@ -399,6 +399,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
  * @example `parseStreamedToolArguments("{}", '{"location":"Paris"}')`
  */
 export function parseStreamedToolArguments(startText: string, deltaText: string): Record<string, unknown> {
+  if (!startText.trim() && !deltaText.trim()) return {}; // no argument text at all is a call that takes none
   const candidates = [startText + deltaText, deltaText, startText].filter((c) => c && c.trim());
   for (const candidate of candidates) {
     try {
@@ -422,6 +423,7 @@ export function parseStreamedToolArguments(startText: string, deltaText: string)
  * @example `selectRawArguments("{}", '{"location":"Paris"}') // '{"location":"Paris"}'`
  */
 export function selectRawArguments(startText: string, deltaText: string): string {
+  if (!startText.trim() && !deltaText.trim()) return "{}";
   const candidates = [startText + deltaText, deltaText, startText].filter((c) => c && c.trim());
   for (const candidate of candidates) {
     try {
@@ -445,6 +447,8 @@ export interface GenerationParams {
   seed?: number;
 }
 
+/** Most stop sequences a Chat Completions request may carry (OpenRouter chat-completion api-ref `maxItems`, OpenAI the same). */
+const MAX_CHAT_STOP = 4;
 const finiteNumber = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
 
 /** Normalizes the public `stop` option (`string | string[]`) to a clean array, or undefined. */
@@ -460,11 +464,22 @@ export function normalizeStop(stop: string | string[] | undefined): string[] | u
  * `max_tokens`, `stop`, `seed`. Only set values are
  * emitted, so strict endpoints never see anything the caller did not ask for.
  */
-export function mapGenerationParamsToChat(params: GenerationParams | undefined): Record<string, unknown> {
+export function mapGenerationParamsToChat(params: GenerationParams | undefined, provider = "chat", modelRef = ""): Record<string, unknown> {
   const out: Record<string, unknown> = {};
   if (!params) return out;
   if (finiteNumber(params.maxOutputTokens) && params.maxOutputTokens > 0) out["max_tokens"] = Math.floor(params.maxOutputTokens);
-  if (params.stop && params.stop.length > 0) out["stop"] = params.stop;
+  if (params.stop && params.stop.length > 0) {
+    out["stop"] = params.stop.slice(0, MAX_CHAT_STOP);
+    if (params.stop.length > MAX_CHAT_STOP) {
+      emitProviderWarning({
+        provider,
+        capability: "stop sequences",
+        requested: `${params.stop.length} sequences (${modelRef})`,
+        reason: `Chat Completions allows at most ${MAX_CHAT_STOP} stop sequences.`,
+        fallback: `the first ${MAX_CHAT_STOP}`,
+      });
+    }
+  }
   if (finiteNumber(params.seed)) out["seed"] = Math.floor(params.seed);
   return out;
 }

package/src/session/store.ts

@@ -1391,7 +1391,7 @@ function resolveEffectivePricing(
 /**
  * Prices one usage snapshot with integer micro-USD accumulation (Q-36).
  *
- * - Provider-reported `usage.cost.totalCost > 0` wins (source `provider`).
+ * - A provider-reported `usage.cost.totalCost` (a number, 0 included: free or cached) wins (source `provider`).
  * - Else catalog pricing via `resolveEffectivePricing` (source `catalog`).
  * - Else returns `undefined` (source `unknown` is implicit) — unknown stays
  *   unknown, never a fabricated 0 object.
@@ -1408,7 +1408,7 @@ export function priceUsage(
   opts?: { serviceTier?: ServiceTier | string; modelId?: string }
 ): PricedCost | undefined {
   const reported = usage?.cost;
-  if (reported && typeof reported.totalCost === "number" && reported.totalCost > 0) {
+  if (reported && typeof reported.totalCost === "number" && reported.totalCost >= 0) {
     const micro = (d?: number): number => (typeof d === "number" && d > 0 ? Math.round(d * 1_000_000) : 0);
     const inputMicroUSD = micro(reported.inputCost);
     const outputMicroUSD = micro(reported.outputCost);
@@ -1492,7 +1492,7 @@ export function addCostToUsage(
   spec?: ModelSpec,
   opts?: { serviceTier?: ServiceTier | string }
 ): TokenUsage["cost"] | undefined {
-  if (usage?.cost && typeof usage.cost.totalCost === "number" && usage.cost.totalCost > 0) {
+  if (usage?.cost && typeof usage.cost.totalCost === "number" && usage.cost.totalCost >= 0) {
     return usage.cost;
   }
   const priced = priceUsage(usage, spec, opts);

package/src/types/message.ts

@@ -9,7 +9,7 @@ export interface TextPart {
   thoughtSignature?: string;
 }
 
-/** Detail level a provider spends on one image or video (more detail = more input tokens). Google only; other providers ignore it with a warning. */
+/** Detail level a provider spends on one image or video (more detail = more input tokens). Google (images and videos) and OpenRouter (images, as `image_url.detail`) honour it; other providers ignore it with a warning. */
 export type MediaResolution = "low" | "medium" | "high" | "ultra_high";
 
 /** Image content accepted as a URL, data, path, or binary value. */

package/src/utils/errors.ts

@@ -113,7 +113,8 @@ const PART_TO_MODALITY: Record<string, "image" | "audio" | "video" | "pdf"> = {
 
 /**
  * Fails fast — before any network call — when the catalog knows the model
- * lacks a requested input modality (image/audio/video/document). Unknown
+ * lacks a requested input modality (image/audio/video/document; files are
+ * not checked on OpenRouter, which parses them for any model). Unknown
  * models (custom providers, dynamic routers) are skipped: the provider
  * verdict stands and surfaces via toConciseProviderError instead.
  */
@@ -130,6 +131,8 @@ export function assertModalitiesSupported(
       if (mapped) needed.add(mapped);
     }
   }
+  // OpenRouter reads a file with the model's native support or its own parser, so the catalog's "pdf" flag never gates a file there.
+  if (providerId === "openrouter") needed.delete("pdf");
   if (needed.size === 0) return;
   let supported: readonly string[] | undefined;
   try {

package/src/utils/headers.ts

@@ -23,7 +23,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.5";
+  return "0.5.6";
 }
 
 function getAgentAccelUserAgent(): string {

package/src/utils/media.ts

@@ -26,6 +26,11 @@ export function inferMimeType(input: string, fallback = "application/octet-strea
   if (clean.endsWith(".mp3")) return "audio/mp3";
   if (clean.endsWith(".wav")) return "audio/wav";
   if (clean.endsWith(".ogg")) return "audio/ogg";
+  if (clean.endsWith(".flac")) return "audio/flac";
+  if (clean.endsWith(".m4a")) return "audio/m4a";
+  if (clean.endsWith(".aac")) return "audio/aac";
+  if (clean.endsWith(".aiff") || clean.endsWith(".aif")) return "audio/aiff";
+  if (clean.endsWith(".mpeg") || clean.endsWith(".mpg")) return "video/mpeg";
   if (clean.endsWith(".mp4")) return "video/mp4";
   if (clean.endsWith(".webm")) return "video/webm";
   if (clean.endsWith(".mov")) return "video/quicktime";
@@ -53,8 +58,12 @@ export function sniffMimeType(bytes: Uint8Array): string | undefined {
   if (ascii(bytes, 0, "RIFF") && ascii(bytes, 8, "WAVE")) return "audio/wav";
   if (ascii(bytes, 0, "%PDF")) return "application/pdf";
   if (ascii(bytes, 0, "OggS")) return "audio/ogg";
+  if (ascii(bytes, 0, "fLaC")) return "audio/flac";
+  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, "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;
 }