agent-accelerator 0.5.9 → 0.6.0

package/src/providers/google.ts

@@ -29,7 +29,7 @@ import type {
   ProviderGenerateResult,
   ProviderRawData,
 } from "../types/model.ts";
-import type { ProviderContext, Message, ContentPart, ProviderSteps, ToolResultPart, MediaResolution } from "../types/message.ts";
+import type { ProviderContext, ContentPart, ProviderSteps, ToolResultPart, MediaResolution } from "../types/message.ts";
 import type { StandardToolDeclaration, ToolCallRecord } from "../types/tool.ts";
 import type { TokenUsage } from "../types/core.ts";
 import { AssistantMessageEventStream } from "../streaming/event-stream.ts";
@@ -53,7 +53,6 @@ import {
   combinedSignal,
   timeoutFor,
   hasAuthHeader,
-  clampToolCallId,
   openStreamResponse,
   retryOptionsFrom,
   headersToRecord,
@@ -85,19 +84,70 @@ import {
 // ---------------------------------------------------------------------------
 
 /** Image MIME types Google accepts inline. */
-export const GOOGLE_IMAGE_MIME = ["image/png", "image/jpeg", "image/webp", "image/heic", "image/heif", "image/gif", "image/bmp", "image/tiff"] as const;
+export const GOOGLE_IMAGE_MIME = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/heic",
+  "image/heif",
+  "image/gif",
+  "image/bmp",
+  "image/tiff",
+] as const;
 /** Audio MIME types Google accepts inline (audio is never fetched by URL). */
-export const GOOGLE_AUDIO_MIME = ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac", "audio/mpeg", "audio/m4a", "audio/l16", "audio/opus", "audio/alaw", "audio/mulaw", "audio/webm"] as const;
+export const GOOGLE_AUDIO_MIME = [
+  "audio/wav",
+  "audio/mp3",
+  "audio/aiff",
+  "audio/aac",
+  "audio/ogg",
+  "audio/flac",
+  "audio/mpeg",
+  "audio/m4a",
+  "audio/l16",
+  "audio/opus",
+  "audio/alaw",
+  "audio/mulaw",
+  "audio/webm",
+] as const;
 /** Video MIME types Google accepts inline. */
-export const GOOGLE_VIDEO_MIME = ["video/mp4", "video/mpeg", "video/mpg", "video/mov", "video/avi", "video/x-flv", "video/webm", "video/wmv", "video/3gpp"] as const;
+export const GOOGLE_VIDEO_MIME = [
+  "video/mp4",
+  "video/mpeg",
+  "video/mpg",
+  "video/mov",
+  "video/avi",
+  "video/x-flv",
+  "video/webm",
+  "video/wmv",
+  "video/3gpp",
+] as const;
 /** Document MIME types Google accepts (the only two). */
 export const GOOGLE_DOCUMENT_MIME = ["application/pdf", "text/csv"] as const;
 /** MIME types Google fetches itself from a public `https://` URL. */
 export const GOOGLE_URL_MIME = [
-  "text/html", "text/css", "text/plain", "text/xml", "text/csv", "text/rtf", "text/javascript",
-  "application/json", "application/pdf",
-  "image/bmp", "image/jpeg", "image/png", "image/webp",
-  "video/mp4", "video/mpeg", "video/quicktime", "video/avi", "video/x-flv", "video/mpg", "video/webm", "video/wmv", "video/3gpp",
+  "text/html",
+  "text/css",
+  "text/plain",
+  "text/xml",
+  "text/csv",
+  "text/rtf",
+  "text/javascript",
+  "application/json",
+  "application/pdf",
+  "image/bmp",
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "video/mp4",
+  "video/mpeg",
+  "video/quicktime",
+  "video/avi",
+  "video/x-flv",
+  "video/mpg",
+  "video/webm",
+  "video/wmv",
+  "video/3gpp",
 ] as const;
 /** Common MIME spellings mapped to Google's inline names. */
 export const GOOGLE_INLINE_MIME_ALIASES: Readonly<Record<string, string>> = {
@@ -174,7 +224,13 @@ const YOUTUBE_URL = /^https:\/\/(www\.|m\.)?(youtube\.com|youtu\.be)\//i;
 // Interactions wire shapes (subset used by this adapter)
 // ---------------------------------------------------------------------------
 
-type MediaBlock = { type: MediaBlockType; mime_type?: string; data?: string; uri?: string; resolution?: MediaResolution };
+type MediaBlock = {
+  type: MediaBlockType;
+  mime_type?: string;
+  data?: string;
+  uri?: string;
+  resolution?: MediaResolution;
+};
 type InteractionContentBlock = { type: "text"; text: string } | MediaBlock;
 
 type InteractionInputStep =
@@ -317,7 +373,10 @@ function liveChainFor(sessionId: string | undefined, options?: ProviderRequestOp
  * below the previous turn's total (Rule 3: a caller dropped the chain without
  * rehydrating history). Never throws; observability-only.
  */
-function checkTurnTokens(sessionId: string | undefined, usage: { inputTokens: number; outputTokens: number; cachedTokens?: number }): void {
+function checkTurnTokens(
+  sessionId: string | undefined,
+  usage: { inputTokens: number; outputTokens: number; cachedTokens?: number }
+): void {
   try {
     if (!sessionId) return;
     const total = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
@@ -409,9 +468,7 @@ function toGoogleTools(tools?: StandardToolDeclaration[]): Array<Record<string,
     type: "function",
     name: t.name,
     description: t.description,
-    parameters: stripSchemaForGoogle(
-      (t.parameters || { type: "object", properties: {} }) as Record<string, unknown>
-    ),
+    parameters: stripSchemaForGoogle((t.parameters || { type: "object", properties: {} }) as Record<string, unknown>),
   }));
 }
 
@@ -443,7 +500,9 @@ function uriBlock(type: MediaBlockType, value: string, mimeType?: string): Media
   if (type === "video" && YOUTUBE_URL.test(value)) return withMime(explicit);
   const mime = explicit ?? bareMime(inferMimeType(value, ""));
   if (value.startsWith(FILES_API_PREFIX) || value.startsWith("gs://")) return withMime(mime);
-  return value.startsWith("https://") && mime && (GOOGLE_URL_MIME as readonly string[]).includes(mime) ? withMime(mime) : undefined;
+  return value.startsWith("https://") && mime && (GOOGLE_URL_MIME as readonly string[]).includes(mime)
+    ? withMime(mime)
+    : undefined;
 }
 
 // Inlines a media part as base64 under Google's MIME name, failing before the network on an unsupported type; in: any media value (bytes, data URL, path, http URL), out: contentPartsToBlocks.
@@ -452,7 +511,8 @@ async function inlineBlock(type: MediaBlockType, value: MediaValue, mimeType?: s
   const raw = bareMime(norm.mimeType) ?? "";
   const mime = GOOGLE_INLINE_MIME_ALIASES[raw] ?? raw;
   if (!INLINE_MIME[type].includes(mime)) {
-    const what = type === "document" ? "Google reads only PDF and CSV documents" : `Google does not accept ${type} type "${mime}"`;
+    const what =
+      type === "document" ? "Google reads only PDF and CSV documents" : `Google does not accept ${type} type "${mime}"`;
     throw new ValidationError(
       `[Agent Accelerator] ${what} (got "${mime}"; supported: ${INLINE_MIME[type].join(", ")}). Convert the file or pass the correct mimeType.`
     );
@@ -534,7 +594,9 @@ function functionResultStep(part: ToolResultPart): InteractionInputStep {
  * behind them. Sending only the last message would drop the tool results and
  * leave the chained interaction waiting on its function calls.
  */
-async function latestTurnInput(context: ProviderContext): Promise<string | InteractionContentBlock[] | InteractionInputStep[]> {
+async function latestTurnInput(
+  context: ProviderContext
+): Promise<string | InteractionContentBlock[] | InteractionInputStep[]> {
   const messages = context.messages;
   let lastAssistant = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -617,10 +679,11 @@ async function fullHistorySteps(context: ProviderContext): Promise<InteractionIn
           const sig = shouldEchoSignature(partProvider ?? msgProvider, "google")
             ? part.thoughtSignature || m.thoughtSignature || ""
             : "";
-          const thoughtStep: { type: "thought"; signature?: string; summary: Array<{ type: string; text?: string }> } = {
-            type: "thought",
-            summary: [{ type: "text", text: part.thinking }],
-          };
+          const thoughtStep: { type: "thought"; signature?: string; summary: Array<{ type: string; text?: string }> } =
+            {
+              type: "thought",
+              summary: [{ type: "text", text: part.thinking }],
+            };
           if (sig) thoughtStep.signature = sig;
           steps.push(thoughtStep);
         } else if (part.type === "tool_call") {
@@ -733,11 +796,7 @@ function parseInteraction(
       // truncated marker); absent args mean a zero-argument call.
       const rawArgs: unknown = step.arguments;
       const args =
-        rawArgs && typeof rawArgs === "object"
-          ? rawArgs
-          : typeof rawArgs === "string"
-            ? parseArguments(rawArgs)
-            : {};
+        rawArgs && typeof rawArgs === "object" ? rawArgs : typeof rawArgs === "string" ? parseArguments(rawArgs) : {};
       toolCalls.push({
         id: step.id || newToolCallId(),
         name: step.name || "unknown",
@@ -815,12 +874,11 @@ export class GoogleInteractionsProvider implements Provider {
       // only signatures return and canonical `thinking` would always be empty.
       // Enabled whenever thinking is active — including the default/dynamic
       // case where no explicit level is sent — and off only when disabled.
-      const thinkingActive =
-        options?.thinking?.enabled !== false && (options?.thinking?.level ?? "dynamic") !== "none";
+      const thinkingActive = options?.thinking?.enabled !== false && (options?.thinking?.level ?? "dynamic") !== "none";
       if (thinkingActive) generationConfig["thinking_summaries"] = "auto";
       if (toolChoice) generationConfig["tool_choice"] = toolChoice;
-      // max_output_tokens only; stop and seed warn+drop.
-      Object.assign(generationConfig, mapGenerationParamsToGoogle(options, `google/${modelId}`));
+      // max_output_tokens only.
+      Object.assign(generationConfig, mapGenerationParamsToGoogle(options));
 
       const body: InteractionRequestBody = {
         model: modelId,
@@ -834,7 +892,9 @@ export class GoogleInteractionsProvider implements Provider {
       let outputEmulated = false;
       let outputSpec: import("../types/model.ts").StructuredOutputSpec | undefined;
       try {
-        outputSpec = normalizeStructuredOutput(options?.output ?? (options as { outputSchema?: unknown })?.outputSchema);
+        outputSpec = normalizeStructuredOutput(
+          options?.output ?? (options as { outputSchema?: unknown })?.outputSchema
+        );
       } catch {
         outputSpec = undefined;
       }
@@ -846,7 +906,8 @@ export class GoogleInteractionsProvider implements Provider {
           provider: "google",
           capability: "structured output",
           requested: `${outputSpec.name} (google/${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)",
         });
       }
@@ -927,7 +988,10 @@ export class GoogleInteractionsProvider implements Provider {
     apiKey: string,
     signal?: AbortSignal
   ): Promise<{ status: number; statusText: string; headers: Record<string, string>; text: string }> {
-    const { signal: effective, cleanup } = combinedSignal(signal, timeoutFor(options as { timeoutMs?: number } | undefined));
+    const { signal: effective, cleanup } = combinedSignal(
+      signal,
+      timeoutFor(options as { timeoutMs?: number } | undefined)
+    );
     try {
       const res = await (options?.fetch ?? fetch)(url, this.requestInit(method, body, options, apiKey, effective));
       const text = await res.text();
@@ -944,7 +1008,6 @@ export class GoogleInteractionsProvider implements Provider {
   // Throws a concise provider error (status, code, Retry-After, key hint) for a non-2xx reply; in: every Google HTTP call, out: nothing or a thrown error.
   private throwIfError(
     status: number,
-    statusText: string,
     url: string,
     bodyText: string,
     modelId: string,
@@ -989,9 +1052,14 @@ export class GoogleInteractionsProvider implements Provider {
     modelId: string
   ): Promise<InteractionReply> {
     const res = await this.doFetch(url, method, body, options, apiKey, options?.signal);
-    this.throwIfError(res.status, res.statusText, url, res.text, modelId, res.headers);
+    this.throwIfError(res.status, url, res.text, modelId, res.headers);
     try {
-      return { status: res.status, statusText: res.statusText, headers: res.headers, interaction: JSON.parse(res.text) as InteractionObject };
+      return {
+        status: res.status,
+        statusText: res.statusText,
+        headers: res.headers,
+        interaction: JSON.parse(res.text) as InteractionObject,
+      };
     } catch {
       throw toConciseProviderError(
         Object.assign(new Error("Invalid JSON response from Google Interactions API"), {
@@ -1006,7 +1074,12 @@ export class GoogleInteractionsProvider implements Provider {
   }
 
   // Fire-and-forget cancel so an aborted background run stops billing; in: an aborted generate/stream, out: POST {id}/cancel.
-  private cancelInteraction(baseUrl: string, id: string, options: ProviderRequestOptions | undefined, apiKey: string): void {
+  private cancelInteraction(
+    baseUrl: string,
+    id: string,
+    options: ProviderRequestOptions | undefined,
+    apiKey: string
+  ): void {
     void this.doFetch(`${baseUrl}/interactions/${id}/cancel`, "POST", undefined, options, apiKey).catch(() => {});
   }
 
@@ -1060,7 +1133,10 @@ export class GoogleInteractionsProvider implements Provider {
       try {
         for (let poll = 0; isRunning(reply.interaction.status); poll++) {
           await sleep(this.pollDelaysMs[poll === 0 ? 0 : 1], options?.signal);
-          reply = await withRetries(() => this.fetchInteraction(`${url}/${id}`, "GET", undefined, options, apiKey, clean), retryOptions);
+          reply = await withRetries(
+            () => this.fetchInteraction(`${url}/${id}`, "GET", undefined, options, apiKey, clean),
+            retryOptions
+          );
         }
         return reply;
       } catch (err) {
@@ -1071,7 +1147,10 @@ export class GoogleInteractionsProvider implements Provider {
 
     // Create (retried as a whole), wait if it runs in the background, then record the chain and map the result.
     const run = async (): Promise<ProviderGenerateResult> => {
-      let reply = await withRetries(() => this.fetchInteraction(url, "POST", body, options, apiKey, clean), retryOptions);
+      let reply = await withRetries(
+        () => this.fetchInteraction(url, "POST", body, options, apiKey, clean),
+        retryOptions
+      );
       if (body.background) reply = await waitForCompletion(reply);
       const { interaction } = reply;
       if (interaction.id && sessionId && body.store !== false) {
@@ -1081,12 +1160,10 @@ export class GoogleInteractionsProvider implements Provider {
         lastTurnTotals.delete(sessionId);
       }
       noteProviderTurn(sessionId, "google");
-      const parsed = parseInteraction(
-        interaction,
-        clean,
-        Date.now() - startTime,
-        { request: rawRequest, response: { status: reply.status, statusText: reply.statusText, headers: reply.headers, body: interaction } }
-      );
+      const parsed = parseInteraction(interaction, clean, Date.now() - startTime, {
+        request: rawRequest,
+        response: { status: reply.status, statusText: reply.statusText, headers: reply.headers, body: interaction },
+      });
       checkTurnTokens(sessionId, parsed.usage);
       return parsed;
     };
@@ -1165,9 +1242,16 @@ export class GoogleInteractionsProvider implements Provider {
         // (429/5xx/network) are retried before the first byte; a live stream is never retried.
         const open = (target: string, method: "POST" | "GET"): Promise<Response> =>
           openStreamResponse({
-            fetchOnce: () => withAbortTimer(linked, streamTimeoutMs, () => (options?.fetch ?? fetch)(target, this.requestInit(method, method === "POST" ? body : undefined, options, apiKey, linked.signal))),
-            onHttpError: (r, text) => this.throwIfError(r.status, r.statusText, target, text, clean, headersToRecord(r.headers)),
-            noBodyError: () => toConciseProviderError(new Error("Google streaming response had no body"), "google", clean),
+            fetchOnce: () =>
+              withAbortTimer(linked, streamTimeoutMs, () =>
+                (options?.fetch ?? fetch)(
+                  target,
+                  this.requestInit(method, method === "POST" ? body : undefined, options, apiKey, linked.signal)
+                )
+              ),
+            onHttpError: (r, text) => this.throwIfError(r.status, target, text, clean, headersToRecord(r.headers)),
+            noBodyError: () =>
+              toConciseProviderError(new Error("Google streaming response had no body"), "google", clean),
             retry: retryOptionsFrom(options),
             signal: linked.signal,
             label: { providerId: "google", modelId: clean },
@@ -1177,7 +1261,11 @@ export class GoogleInteractionsProvider 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 reader: StreamReader | undefined;
@@ -1286,7 +1374,8 @@ export class GoogleInteractionsProvider implements Provider {
                 thinking += t;
                 eventStream.push({ type: "thinking_delta", thinkingDelta: t, partialThinking: thinking });
               }
-              if (!signature && typeof step["signature"] === "string" && step["signature"]) signature = step["signature"];
+              if (!signature && typeof step["signature"] === "string" && step["signature"])
+                signature = step["signature"];
             } else if (step["type"] === "function_call") {
               const args = step["arguments"];
               const startArgs = typeof args === "string" ? args : args ? JSON.stringify(args) : "";
@@ -1343,7 +1432,8 @@ export class GoogleInteractionsProvider implements Provider {
                 break;
               }
               if (chunk.done) break;
-              for (const m of parser.feed(decoder.decode(chunk.value, { stream: true }))) handleMessage(m.event, m.data);
+              for (const m of parser.feed(decoder.decode(chunk.value, { stream: true })))
+                handleMessage(m.event, m.data);
             }
             for (const m of parser.flush()) handleMessage(m.event, m.data);
           } finally {
@@ -1383,7 +1473,8 @@ export class GoogleInteractionsProvider implements Provider {
         }
 
         if (sessionId) {
-          if (responseId && body.store !== false) setChain(sessionId, { interactionId: responseId, model: clean, at: Date.now() });
+          if (responseId && body.store !== false)
+            setChain(sessionId, { interactionId: responseId, model: clean, at: Date.now() });
           else if (body.store === false) {
             interactionChains.delete(sessionId);
             lastTurnTotals.delete(sessionId);
@@ -1402,7 +1493,8 @@ export class GoogleInteractionsProvider implements Provider {
         const cleanThinkingEarly = thinking.replace(/\n{3,}/g, "\n\n").trim();
         const ctEntry = Object.entries(responseHeaders).find(([k]) => k.toLowerCase() === "content-type");
         const isSSEPayload =
-          (typeof ctEntry?.[1] === "string" && ((ctEntry[1] as string).includes("event-stream") || (ctEntry[1] as string).startsWith("text/"))) ||
+          (typeof ctEntry?.[1] === "string" &&
+            ((ctEntry[1] as string).includes("event-stream") || (ctEntry[1] as string).startsWith("text/"))) ||
           framesSeen > 0 ||
           badFrames > 0;
         if (!hasTerminal && !text && !cleanThinkingEarly && toolCalls.length === 0 && isSSEPayload) {
@@ -1433,14 +1525,10 @@ export class GoogleInteractionsProvider implements Provider {
       } catch (err: unknown) {
         const raw = err instanceof Error ? err : new Error(String(err));
         const isAbort =
-          linked.signal.aborted ||
-          eventStream.isCancelled() ||
-          (raw as { name?: string }).name === "AbortError";
+          linked.signal.aborted || eventStream.isCancelled() || (raw as { name?: string }).name === "AbortError";
         if (isAbort) {
           cancelBackground();
-          eventStream.fail(
-            Object.assign(new Error("Stream aborted"), { name: "AbortError" })
-          );
+          eventStream.fail(Object.assign(new Error("Stream aborted"), { name: "AbortError" }));
         } else if (evictSessionId && usedChain && isNotFoundChainError(raw)) {
           // Reactive self-heal, fail-clean variant (Rule 2): the `start`
           // event is already delivered, so a transparent in-stream retry

package/src/providers/openai-compat.ts

@@ -13,7 +13,7 @@
  * Strictness contract (differs from the old lenient passthrough on purpose):
  * - Requests carry ONLY standard Chat Completions fields (`model`, `messages`,
  *   `tools`, `tool_choice`, `stream`, plus `max_tokens`/
- *   `stop`/`seed` when explicitly set). No `reasoning`, `service_tier`,
+ *   when explicitly set). No `reasoning`, `service_tier`,
  *   `session_id`, `prompt_cache_key`, or other extras: strict endpoints
  *   (groq, ollama, …) fail unknown body properties, so anything unsupported
  *   is warn+drop, never sent.
@@ -66,7 +66,6 @@ import {
   newToolCallId,
   redactedHeaders,
   readErrorPayload,
-  incompleteStreamError,
   hasUnfinishedToolCall,
   linkStreamAbort,
   withAbortTimer,
@@ -130,7 +129,10 @@ interface ChatRequestBody {
   messages: ChatMessage[];
   tools?: Array<Record<string, unknown>>;
   tool_choice?: string | { type: "function"; function: { name: string } };
-  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;
 }
@@ -231,18 +233,20 @@ function resolveApiKey(
 ): string | undefined {
   const clean = (v: unknown): string | undefined => {
     if (typeof v !== "string") return undefined;
-    const t = v.trim().replace(/^["']|["']$/g, "").trim();
+    const t = v
+      .trim()
+      .replace(/^["']|["']$/g, "")
+      .trim();
     return t || undefined;
   };
   const envPrefix = envPrefixOf(prefix);
-  const key = (
+  const key =
     clean(options?.apiKey) ||
     clean(configuredApiKey) ||
     clean(options?.env?.[`${envPrefix}_API_KEY`]) ||
     clean(options?.env?.[`${envPrefix}_BASE_API_KEY`]) ||
     getApiKey(prefix, undefined, options?.env) ||
-    undefined
-  );
+    undefined;
   if (key) return key;
   if (hasAuthHeader(options?.headers)) return "unused";
   return undefined;
@@ -308,7 +312,8 @@ function warnThinkingDropped(prefix: string, thinking: ThinkingConfig | undefine
     provider: prefix,
     capability: "thinking level",
     requested: `${level} (${modelRef})`,
-    reason: "custom OpenAI-compatible endpoints define no portable reasoning control; levels vary by vendor and strict endpoints reject unknown fields.",
+    reason:
+      "custom OpenAI-compatible endpoints define no portable reasoning control; levels vary by vendor and strict endpoints reject unknown fields.",
     fallback: "the server default (no reasoning payload is sent)",
   });
 }
@@ -325,11 +330,7 @@ function audioFormatFor(mimeType?: string): string {
  * Completions subset has no shape for them, and a provider 400 would only say
  * so confusingly. Images and audio keep flowing natively.
  */
-function assertNoVideoOrFileParts(
-  context: ProviderContext,
-  prefix: string,
-  modelId: string
-): void {
+function assertNoVideoOrFileParts(context: ProviderContext, prefix: string, modelId: string): void {
   let kind: "video" | "file" | undefined;
   for (const msg of context.messages) {
     if (!Array.isArray((msg as { content?: unknown }).content)) continue;
@@ -374,10 +375,7 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<ChatContentPa
       const raw = (part as { audio?: unknown }).audio;
       const mimeType = (part as { mimeType?: string }).mimeType;
       // The OpenAI chat audio shape carries data only — always inline.
-      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) },
@@ -428,10 +426,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") {
@@ -527,25 +531,22 @@ function mapUsage(raw?: ChatResponse["usage"]): TokenUsage {
 }
 
 // The Gemini thought signature a proxy put on a tool call, if any; in: parseResponse, out: a string or undefined.
-function extractSignature(rawTc: {
-  extra_content?: { google?: { thought_signature?: string } };
-}): string | undefined {
+function extractSignature(rawTc: { extra_content?: { google?: { thought_signature?: string } } }): string | undefined {
   const sig = rawTc?.extra_content?.google?.thought_signature;
   return typeof sig === "string" && sig ? sig : undefined;
 }
 
 /** Tags a captured compat signature with its issuing provider (`google`). */
-function withCompatSignature(sig: string | undefined): { thoughtSignature?: string; thoughtSignatureProvider?: string } {
+function withCompatSignature(sig: string | undefined): {
+  thoughtSignature?: string;
+  thoughtSignatureProvider?: string;
+} {
   if (!sig) return {};
   return { thoughtSignature: sig, thoughtSignatureProvider: "google" };
 }
 
 // Throws a concise error for an HTTP 200 reply that carries only `error`; in: parseResponse, out: a thrown error.
-function throwResponseError(
-  response: ChatResponse,
-  prefix: string,
-  modelId: string
-): void {
+function throwResponseError(response: ChatResponse, prefix: string, modelId: string): void {
   const message =
     response.error && typeof response.error.message === "string" && response.error.message
       ? response.error.message
@@ -716,7 +717,8 @@ export class OpenAICompatibleChatProvider implements Provider {
         provider: this.prefix,
         capability: "service tier",
         requested: `${options.serviceTier} (${this.prefix}/${modelId})`,
-        reason: "custom OpenAI-compatible endpoints define no service-tier primitive, and strict endpoints reject unknown body properties.",
+        reason:
+          "custom OpenAI-compatible endpoints define no service-tier primitive, and strict endpoints reject unknown body properties.",
         fallback: "standard routing (no service_tier payload is sent)",
       });
     }
@@ -745,7 +747,8 @@ export class OpenAICompatibleChatProvider implements Provider {
         provider: this.prefix,
         capability: "structured output",
         requested: `${outputSpec.name} (${this.prefix}/${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)",
       });
     }
@@ -758,7 +761,7 @@ export class OpenAICompatibleChatProvider implements Provider {
     const compatTools = toCompatTools(tools);
     if (compatTools) body.tools = compatTools;
     // Standard Chat Completions generation fields, only when the caller set them.
-    Object.assign(body, mapGenerationParamsToChat(options, this.prefix, `${this.prefix}/${modelId}`));
+    Object.assign(body, mapGenerationParamsToChat(options));
     const toolChoice = mapToolChoiceToOpenAI(
       options?.toolChoice as "auto" | "none" | "required" | { type: "function"; function: { name: string } } | undefined
     );
@@ -791,7 +794,7 @@ export class OpenAICompatibleChatProvider implements Provider {
       const noStreamOptions =
         (options as { streamOptions?: unknown } | undefined)?.streamOptions === false ||
         getEnv("COMPAT_NO_STREAM_OPTIONS") === "1" ||
-        (options?.env?.["COMPAT_NO_STREAM_OPTIONS"] === "1");
+        options?.env?.["COMPAT_NO_STREAM_OPTIONS"] === "1";
       if (!noStreamOptions) {
         (body as unknown as Record<string, unknown>)["stream_options"] = { include_usage: true };
       }
@@ -807,11 +810,7 @@ export class OpenAICompatibleChatProvider implements Provider {
     sessionId: string | undefined,
     signal?: AbortSignal
   ): RequestInit {
-    const headers: Record<string, string> = buildSessionHeaders(
-      this.prefix,
-      options?.headers,
-      sessionId
-    );
+    const headers: Record<string, string> = buildSessionHeaders(this.prefix, options?.headers, sessionId);
     // Strict-endpoint opt-out (pi sendSessionAffinityHeaders pattern):
     // `COMPAT_NO_SESSION_HEADERS=1` or per-call `sendSessionHeaders:false`
     // drops affinity headers that trigger CORS preflights / strict 400s.
@@ -844,7 +843,10 @@ export class OpenAICompatibleChatProvider implements Provider {
     sessionId: string | undefined,
     signal?: AbortSignal
   ): Promise<{ status: number; statusText: string; headers: Record<string, string>; text: string }> {
-    const { signal: effective, cleanup } = combinedSignal(signal, timeoutFor(options as { timeoutMs?: number } | undefined));
+    const { signal: effective, cleanup } = combinedSignal(
+      signal,
+      timeoutFor(options as { timeoutMs?: number } | undefined)
+    );
     try {
       const res = await (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, effective));
       const text = await res.text();
@@ -939,13 +941,10 @@ export class OpenAICompatibleChatProvider implements Provider {
       // Stateless turns never establish chains, but the session store still
       // records the turn so other providers' switch detection keeps working.
       noteProviderTurn(sessionId, this.prefix);
-      return parseResponse(
-        response,
-        this.prefix,
-        clean,
-        Date.now() - startTime,
-        { request: rawRequest, response: { status: res.status, statusText: res.statusText, headers: res.headers, body: response } }
-      );
+      return parseResponse(response, this.prefix, clean, Date.now() - startTime, {
+        request: rawRequest,
+        response: { status: res.status, statusText: res.statusText, headers: res.headers, body: response },
+      });
     };
 
     try {
@@ -1000,9 +999,13 @@ export class OpenAICompatibleChatProvider 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))),
+          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)),
-          noBodyError: () => toConciseProviderError(new Error("OpenAI-compatible streaming response had no body"), prefix, clean),
+          noBodyError: () =>
+            toConciseProviderError(new Error("OpenAI-compatible streaming response had no body"), prefix, clean),
           retry: retryOptionsFrom(options),
           signal: linked.signal,
           label: { providerId: prefix, modelId: clean },
@@ -1011,7 +1014,11 @@ export class OpenAICompatibleChatProvider 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 = "";
@@ -1059,7 +1066,8 @@ export class OpenAICompatibleChatProvider 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.