agent-accelerator 0.5.9 → 0.6.5

package/src/providers/google.ts

@@ -29,7 +29,14 @@ 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,
+  VideoProcessing,
+} 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 +60,6 @@ import {
   combinedSignal,
   timeoutFor,
   hasAuthHeader,
-  clampToolCallId,
   openStreamResponse,
   retryOptionsFrom,
   headersToRecord,
@@ -85,19 +91,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>> = {
@@ -106,7 +163,8 @@ export const GOOGLE_INLINE_MIME_ALIASES: Readonly<Record<string, string>> = {
   "audio/wave": "audio/wav",
   "image/jpg": "image/jpeg",
 };
-// Documented size limits. Not enforced yet: oversized inputs get Google's own error.
+// Documented size limits (file-input-methods.md). `assertGoogleInlineSizes` below checks them, but it is NOT called yet:
+// the owner is not sure how Files API uploads should be handled, so oversized inputs still get Google's own error for now.
 /** Max inline payload per request (bytes). */
 export const GOOGLE_MAX_INLINE_REQUEST_BYTES = 100 * 1024 * 1024;
 /** Max inline PDF size (bytes). */
@@ -167,14 +225,22 @@ const INLINE_MIME: Record<MediaBlockType, readonly string[]> = {
   document: GOOGLE_DOCUMENT_MIME,
 };
 
-const FILES_API_PREFIX = "https://generativelanguage.googleapis.com/v1beta/files/";
+// A Google Files API link on either API version (`/v1/files/<id>` or `/v1beta/files/<id>`); the host is exact, so no other URL counts.
+const FILES_API_URL = /^https:\/\/generativelanguage\.googleapis\.com\/v1(?:beta)?\/files\/[^/\s]+/;
 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;
+  processing?: VideoProcessing;
+};
 type InteractionContentBlock = { type: "text"; text: string } | MediaBlock;
 
 type InteractionInputStep =
@@ -317,7 +383,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 +478,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>),
   }));
 }
 
@@ -442,8 +509,10 @@ function uriBlock(type: MediaBlockType, value: string, mimeType?: string): Media
   const withMime = (mime?: string): MediaBlock => ({ type, uri: value, ...(mime ? { mime_type: mime } : {}) });
   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;
+  if (FILES_API_URL.test(value) || value.startsWith("gs://")) return withMime(mime);
+  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 +521,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.`
     );
@@ -475,11 +545,63 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<InteractionCo
     const block = uri ?? (await inlineBlock(type, value, part.mimeType));
     // Per-item detail level (image and video blocks only, api-ref `MediaResolution`).
     const resolution = part.type === "image" || part.type === "video" ? part.resolution : undefined;
-    blocks.push(resolution ? { ...block, resolution } : block);
+    // Per-video processing mode (`static` | `agentic`, api-ref `MediaProcessing`): the model may then add `processing_call` / `processing_result` steps, which the raw-steps replay keeps like any other step.
+    const processing = part.type === "video" ? part.processing : undefined;
+    if (processing !== undefined && processing !== "static" && processing !== "agentic")
+      throw new ValidationError(
+        `[Agent Accelerator] Invalid video processing ${JSON.stringify(processing)}: expected "static" or "agentic".`
+      );
+    blocks.push({ ...block, ...(resolution ? { resolution } : {}), ...(processing ? { processing } : {}) });
   }
   return blocks;
 }
 
+// Decoded size in bytes of a base64 string, without decoding it; in: assertGoogleInlineSizes, out: a byte count.
+function base64Bytes(b64: string): number {
+  const clean = b64.replace(/\s/g, "");
+  const padding = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor((clean.length * 3) / 4) - padding);
+}
+
+// Every inline media block (`data` + `mime_type`) found anywhere in a request `input`, including blocks inside steps and function results; in: assertGoogleInlineSizes, out: the blocks.
+function inlineBlocks(
+  value: unknown,
+  out: Array<{ mime?: string; bytes: number }> = []
+): Array<{ mime?: string; bytes: number }> {
+  if (Array.isArray(value)) {
+    for (const v of value) inlineBlocks(v, out);
+  } else if (value && typeof value === "object") {
+    const o = value as Record<string, unknown>;
+    if (typeof o["data"] === "string" && typeof o["mime_type"] === "string")
+      out.push({ mime: bareMime(o["mime_type"]), bytes: base64Bytes(o["data"]) });
+    else for (const v of Object.values(o)) inlineBlocks(v, out);
+  }
+  return out;
+}
+
+/**
+ * Fails before the network when the inline media of one request is over Google's documented limits: 100 MB in total and
+ * 50 MB for each PDF (larger files go through the Files API). Counts decoded bytes, over the whole `input` (the full
+ * history on a reseed). NOT called by the adapter yet (see the call sites in `generate` and `stream`).
+ */
+export function assertGoogleInlineSizes(input: unknown, modelId: string): void {
+  const blocks = inlineBlocks(input);
+  const mb = (n: number): string => `${(n / (1024 * 1024)).toFixed(1)} MB`;
+  for (const b of blocks) {
+    if (b.mime === "application/pdf" && b.bytes > GOOGLE_MAX_INLINE_PDF_BYTES) {
+      throw new ValidationError(
+        `[Agent Accelerator] [google/${modelId}] A PDF of ${mb(b.bytes)} is over Google's ${mb(GOOGLE_MAX_INLINE_PDF_BYTES)} limit for inline PDFs. Upload it with the Files API and pass its link instead.`
+      );
+    }
+  }
+  const total = blocks.reduce((n, b) => n + b.bytes, 0);
+  if (total > GOOGLE_MAX_INLINE_REQUEST_BYTES) {
+    throw new ValidationError(
+      `[Agent Accelerator] [google/${modelId}] The inline media of this request is ${mb(total)}, over Google's ${mb(GOOGLE_MAX_INLINE_REQUEST_BYTES)} limit per request. Upload the large files with the Files API and pass their links instead.`
+    );
+  }
+}
+
 // Keeps a turn's model-generated steps exactly as received (input echoes and empty signatures dropped); in: REST `steps` or assembled stream steps, out: ProviderGenerateResult.providerSteps.
 function replaySteps(steps: unknown[] | undefined): ProviderSteps | undefined {
   const kept = (steps ?? [])
@@ -515,13 +637,14 @@ function resultToText(result: unknown): string {
   return safeStringify(result);
 }
 
-// Builds the documented `function_result` step (`is_error` only when the tool failed); in: a canonical tool_result part, out: chained or full-history `input`.
-function functionResultStep(part: ToolResultPart): InteractionInputStep {
+// Builds the documented `function_result` step (`is_error` only when the tool failed); text first, then the media the tool returned with `toolContent` (Gemini 3 accepts image and document blocks in `result`); in: a canonical tool_result part, out: chained or full-history `input`.
+async function functionResultStep(part: ToolResultPart): Promise<InteractionInputStep> {
+  const media = part.parts && part.parts.length > 0 ? await contentPartsToBlocks(part.parts) : [];
   return {
     type: "function_result",
     name: part.name,
     call_id: part.id,
-    result: [{ type: "text", text: resultToText(part.result) }],
+    result: [{ type: "text", text: resultToText(part.result) }, ...media],
     ...(part.isError ? { is_error: true } : {}),
   };
 }
@@ -534,7 +657,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--) {
@@ -563,7 +688,7 @@ async function latestTurnInput(context: ProviderContext): Promise<string | Inter
       if (!Array.isArray(m.content)) continue;
       for (const part of m.content) {
         if (part.type === "tool_result") {
-          steps.push(functionResultStep(part));
+          steps.push(await functionResultStep(part));
         }
       }
     } else if (m.role === "user") {
@@ -617,10 +742,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") {
@@ -652,7 +778,7 @@ async function fullHistorySteps(context: ProviderContext): Promise<InteractionIn
       if (!Array.isArray(m.content)) continue;
       for (const part of m.content) {
         if (part.type === "tool_result") {
-          steps.push(functionResultStep(part));
+          steps.push(await functionResultStep(part));
         }
       }
     }
@@ -733,11 +859,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 +937,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,19 +955,26 @@ 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;
       }
       let effectiveSystemPrompt = context.systemPrompt;
       if (outputSpec && !modelSupportsStructuredOutput("google", modelId)) {
         outputEmulated = true;
-        effectiveSystemPrompt = augmentSystemPromptWithStructuredOutput(context.systemPrompt, outputSpec);
+        effectiveSystemPrompt = augmentSystemPromptWithStructuredOutput(
+          context.systemPrompt,
+          outputSpec,
+          options?.prompts?.structuredOutput
+        );
         emitProviderWarning({
           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 +1055,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 +1075,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 +1119,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 +1141,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(() => {});
   }
 
@@ -1035,6 +1175,8 @@ export class GoogleInteractionsProvider implements Provider {
     const sessionId = options?.sessionId;
     const tools = options?.tools as StandardToolDeclaration[] | undefined;
     let body = await this.buildBody(clean, context, options, sessionId, tools, false);
+    // Size limits are implemented but switched off for now (the owner is unsure about Files API handling yet):
+    // assertGoogleInlineSizes(body.input, clean);
 
     const makeRawRequest = (b: InteractionRequestBody): ProviderRawData["request"] => ({
       url,
@@ -1060,7 +1202,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 +1216,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 +1229,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;
     };
@@ -1143,6 +1289,8 @@ export class GoogleInteractionsProvider implements Provider {
         const sessionId = options?.sessionId;
         const tools = options?.tools as StandardToolDeclaration[] | undefined;
         const body = await this.buildBody(clean, context, options, sessionId, tools, true);
+        // Size limits are implemented but switched off for now (the owner is unsure about Files API handling yet):
+        // assertGoogleInlineSizes(body.input, clean);
         evictSessionId = sessionId;
         usedChain = body.previous_interaction_id !== undefined;
 
@@ -1165,9 +1313,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 +1332,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 +1445,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 +1503,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 +1544,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 +1564,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 +1596,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