@ai-sdk/google 4.0.5 → 4.0.6

package/dist/internal/index.js

@@ -2890,7 +2890,2919 @@ var googleTools = {
    */
   vertexRagStore
 };
+
+// src/interactions/google-interactions-language-model.ts
+import {
+  combineHeaders as combineHeaders4,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  generateId as defaultGenerateId,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3
+} from "@ai-sdk/provider-utils";
+
+// src/interactions/convert-google-interactions-usage.ts
+function convertGoogleInteractionsUsage(usage) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
+    };
+  }
+  const totalInput = (_a = usage.total_input_tokens) != null ? _a : 0;
+  const totalOutput = (_b = usage.total_output_tokens) != null ? _b : 0;
+  const totalThought = (_c = usage.total_thought_tokens) != null ? _c : 0;
+  const totalCached = (_d = usage.total_cached_tokens) != null ? _d : 0;
+  return {
+    inputTokens: {
+      total: (_e = usage.total_input_tokens) != null ? _e : void 0,
+      noCache: usage.total_input_tokens == null ? void 0 : totalInput - totalCached,
+      cacheRead: (_f = usage.total_cached_tokens) != null ? _f : void 0,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: usage.total_output_tokens == null && usage.total_thought_tokens == null ? void 0 : totalOutput + totalThought,
+      text: (_g = usage.total_output_tokens) != null ? _g : void 0,
+      reasoning: (_h = usage.total_thought_tokens) != null ? _h : void 0
+    },
+    raw: usage
+  };
+}
+function getGoogleInteractionsOutputTokensByModality(usage) {
+  const byModality = usage == null ? void 0 : usage.output_tokens_by_modality;
+  if (byModality == null) {
+    return void 0;
+  }
+  const result = {};
+  for (const entry of byModality) {
+    if ((entry == null ? void 0 : entry.modality) != null && entry.tokens != null) {
+      result[entry.modality] = entry.tokens;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// src/interactions/extract-google-interactions-sources.ts
+var KNOWN_DOC_EXTENSIONS = {
+  pdf: "application/pdf",
+  txt: "text/plain",
+  md: "text/markdown",
+  markdown: "text/markdown",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+};
+function inferDocMediaType(uriOrName) {
+  const lower = uriOrName.toLowerCase();
+  for (const [ext, media] of Object.entries(KNOWN_DOC_EXTENSIONS)) {
+    if (lower.endsWith(`.${ext}`)) return media;
+  }
+  return "application/octet-stream";
+}
+function basename(uriOrName) {
+  const parts = uriOrName.split("/");
+  const last = parts[parts.length - 1];
+  return last && last.length > 0 ? last : void 0;
+}
+function annotationToSource({
+  annotation,
+  generateId: generateId2
+}) {
+  var _a, _b, _c, _d, _e;
+  switch (annotation.type) {
+    case "url_citation": {
+      const urlCitation = annotation;
+      if (urlCitation.url == null || urlCitation.url.length === 0) {
+        return void 0;
+      }
+      return {
+        type: "source",
+        sourceType: "url",
+        id: generateId2(),
+        url: urlCitation.url,
+        ...urlCitation.title != null ? { title: urlCitation.title } : {}
+      };
+    }
+    case "file_citation": {
+      const fileCitation = annotation;
+      const uri = (_b = (_a = fileCitation.url) != null ? _a : fileCitation.document_uri) != null ? _b : fileCitation.file_name;
+      if (uri == null || uri.length === 0) return void 0;
+      if (uri.startsWith("http://") || uri.startsWith("https://")) {
+        return {
+          type: "source",
+          sourceType: "url",
+          id: generateId2(),
+          url: uri,
+          ...fileCitation.file_name != null ? { title: fileCitation.file_name } : {}
+        };
+      }
+      const filename = (_c = fileCitation.file_name) != null ? _c : basename(uri);
+      const mediaType = inferDocMediaType(uri);
+      return {
+        type: "source",
+        sourceType: "document",
+        id: generateId2(),
+        mediaType,
+        title: (_e = (_d = fileCitation.file_name) != null ? _d : filename) != null ? _e : uri,
+        ...filename != null ? { filename } : {}
+      };
+    }
+    case "place_citation": {
+      const placeCitation = annotation;
+      if (placeCitation.url == null || placeCitation.url.length === 0) {
+        return void 0;
+      }
+      return {
+        type: "source",
+        sourceType: "url",
+        id: generateId2(),
+        url: placeCitation.url,
+        ...placeCitation.name != null ? { title: placeCitation.name } : {}
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function builtinToolResultToSources({
+  block,
+  generateId: generateId2
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const sources = [];
+  switch (block.type) {
+    case "url_context_result": {
+      const result = (_a = block.result) != null ? _a : [];
+      for (const entry of result) {
+        if ((entry == null ? void 0 : entry.url) == null || entry.url.length === 0) continue;
+        if (entry.status != null && entry.status !== "success") continue;
+        sources.push({
+          type: "source",
+          sourceType: "url",
+          id: generateId2(),
+          url: entry.url
+        });
+      }
+      break;
+    }
+    case "google_search_result": {
+      const result = (_b = block.result) != null ? _b : [];
+      for (const entry of result) {
+        const url = entry == null ? void 0 : entry.url;
+        if (url == null || url.length === 0) continue;
+        sources.push({
+          type: "source",
+          sourceType: "url",
+          id: generateId2(),
+          url,
+          ...entry.title != null ? { title: entry.title } : {}
+        });
+      }
+      break;
+    }
+    case "google_maps_result": {
+      const result = (_c = block.result) != null ? _c : [];
+      for (const entry of result) {
+        for (const place of (_d = entry.places) != null ? _d : []) {
+          if (place.url == null || place.url.length === 0) continue;
+          sources.push({
+            type: "source",
+            sourceType: "url",
+            id: generateId2(),
+            url: place.url,
+            ...place.name != null ? { title: place.name } : {}
+          });
+        }
+      }
+      break;
+    }
+    case "file_search_result": {
+      const result = (_e = block.result) != null ? _e : [];
+      for (const raw of result) {
+        if (raw == null || typeof raw !== "object") continue;
+        const entry = raw;
+        const uri = (_g = (_f = entry.url) != null ? _f : entry.document_uri) != null ? _g : entry.file_name;
+        if (uri == null || uri.length === 0) continue;
+        if (uri.startsWith("http://") || uri.startsWith("https://")) {
+          sources.push({
+            type: "source",
+            sourceType: "url",
+            id: generateId2(),
+            url: uri,
+            ...entry.title != null ? { title: entry.title } : {}
+          });
+          continue;
+        }
+        const filename = (_h = entry.file_name) != null ? _h : basename(uri);
+        const mediaType = inferDocMediaType(uri);
+        sources.push({
+          type: "source",
+          sourceType: "document",
+          id: generateId2(),
+          mediaType,
+          title: (_k = (_j = (_i = entry.title) != null ? _i : entry.file_name) != null ? _j : filename) != null ? _k : uri,
+          ...filename != null ? { filename } : {}
+        });
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return sources;
+}
+function annotationsToSources({
+  annotations,
+  generateId: generateId2
+}) {
+  var _a;
+  if (annotations == null) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const annotation of annotations) {
+    const source = annotationToSource({ annotation, generateId: generateId2 });
+    if (source == null) continue;
+    const key = source.sourceType === "url" ? `url:${source.url}` : `doc:${(_a = source.filename) != null ? _a : source.title}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    sources.push(source);
+  }
+  return sources;
+}
+
+// src/interactions/map-google-interactions-finish-reason.ts
+function mapGoogleInteractionsFinishReason({
+  status,
+  hasFunctionCall
+}) {
+  switch (status) {
+    case "completed":
+      return hasFunctionCall ? "tool-calls" : "stop";
+    case "requires_action":
+      return "tool-calls";
+    case "failed":
+      return "error";
+    case "incomplete":
+      return "length";
+    case "cancelled":
+      return "other";
+    case "in_progress":
+    default:
+      return "other";
+  }
+}
+
+// src/interactions/build-google-interactions-stream-transform.ts
+var BUILTIN_TOOL_CALL_TYPES = /* @__PURE__ */ new Set([
+  "google_search_call",
+  "code_execution_call",
+  "url_context_call",
+  "file_search_call",
+  "google_maps_call",
+  "mcp_server_tool_call"
+]);
+var BUILTIN_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+  "google_search_result",
+  "code_execution_result",
+  "url_context_result",
+  "file_search_result",
+  "google_maps_result",
+  "mcp_server_tool_result"
+]);
+function builtinToolNameFromCallType(type) {
+  return type.replace(/_call$/, "");
+}
+function builtinToolNameFromResultType(type) {
+  return type.replace(/_result$/, "");
+}
+function buildGoogleInteractionsStreamTransform({
+  warnings,
+  generateId: generateId2,
+  includeRawChunks,
+  serviceTier: headerServiceTier
+}) {
+  let interactionId;
+  let usage;
+  let serviceTier = headerServiceTier;
+  let finishStatus;
+  let hasFunctionCall = false;
+  const openBlocks = /* @__PURE__ */ new Map();
+  const emittedSourceKeys = /* @__PURE__ */ new Set();
+  function sourceKey(source) {
+    var _a;
+    return source.sourceType === "url" ? `url:${source.url}` : `doc:${(_a = source.filename) != null ? _a : source.title}`;
+  }
+  return new TransformStream({
+    start(controller) {
+      controller.enqueue({ type: "stream-start", warnings });
+    },
+    transform(chunk, controller) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+      if (includeRawChunks) {
+        controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+      }
+      if (!chunk.success) {
+        finishStatus = "failed";
+        controller.enqueue({ type: "error", error: chunk.error });
+        return;
+      }
+      const value = chunk.value;
+      const eventType = value.event_type;
+      switch (eventType) {
+        case "interaction.created": {
+          const event = value;
+          const interaction = event.interaction;
+          interactionId = (interaction == null ? void 0 : interaction.id) != null && interaction.id.length > 0 ? interaction.id : void 0;
+          const created = interaction == null ? void 0 : interaction.created;
+          let timestamp;
+          if (typeof created === "string") {
+            const parsed = new Date(created);
+            if (!Number.isNaN(parsed.getTime())) {
+              timestamp = parsed;
+            }
+          }
+          controller.enqueue({
+            type: "response-metadata",
+            ...interactionId != null ? { id: interactionId } : {},
+            modelId: interaction == null ? void 0 : interaction.model,
+            ...timestamp ? { timestamp } : {}
+          });
+          break;
+        }
+        case "step.start": {
+          const event = value;
+          const step = event.step;
+          const index = event.index;
+          const blockId = `${interactionId != null ? interactionId : "interaction"}:${index}`;
+          const stepType = step == null ? void 0 : step.type;
+          if (stepType === "model_output") {
+            const initial = (_a = step == null ? void 0 : step.content) == null ? void 0 : _a[0];
+            if ((initial == null ? void 0 : initial.type) === "text") {
+              openBlocks.set(index, {
+                kind: "text",
+                id: blockId,
+                emittedSourceKeys: /* @__PURE__ */ new Set()
+              });
+              controller.enqueue({ type: "text-start", id: blockId });
+              const initialSources = annotationsToSources({
+                annotations: initial.annotations,
+                generateId: generateId2
+              });
+              for (const source of initialSources) {
+                const key = sourceKey(source);
+                if (emittedSourceKeys.has(key)) continue;
+                emittedSourceKeys.add(key);
+                controller.enqueue(source);
+              }
+            } else if ((initial == null ? void 0 : initial.type) === "image") {
+              openBlocks.set(index, {
+                kind: "image",
+                id: blockId,
+                ...initial.data != null ? { data: initial.data } : {},
+                ...initial.mime_type != null ? { mimeType: initial.mime_type } : {},
+                ...initial.uri != null ? { uri: initial.uri } : {}
+              });
+            } else {
+              openBlocks.set(index, {
+                kind: "pending_model_output",
+                id: blockId
+              });
+            }
+          } else if (stepType === "thought") {
+            const signature = step == null ? void 0 : step.signature;
+            openBlocks.set(index, {
+              kind: "reasoning",
+              id: blockId,
+              ...signature != null ? { signature } : {}
+            });
+            controller.enqueue({ type: "reasoning-start", id: blockId });
+            if (Array.isArray(step == null ? void 0 : step.summary)) {
+              for (const item of step.summary) {
+                if ((item == null ? void 0 : item.type) === "text" && typeof item.text === "string") {
+                  controller.enqueue({
+                    type: "reasoning-delta",
+                    id: blockId,
+                    delta: item.text
+                  });
+                }
+              }
+            }
+          } else if (stepType === "function_call") {
+            const toolCallId = (_b = step == null ? void 0 : step.id) != null ? _b : blockId;
+            const toolName = (_c = step == null ? void 0 : step.name) != null ? _c : "unknown";
+            hasFunctionCall = true;
+            const state = {
+              kind: "function_call",
+              id: blockId,
+              toolCallId,
+              toolName,
+              argumentsAccum: "",
+              ...(step == null ? void 0 : step.signature) != null ? { signature: step.signature } : {}
+            };
+            openBlocks.set(index, state);
+            controller.enqueue({
+              type: "tool-input-start",
+              id: toolCallId,
+              toolName
+            });
+          } else if (stepType != null && BUILTIN_TOOL_CALL_TYPES.has(stepType)) {
+            const toolName = stepType === "mcp_server_tool_call" ? (_d = step == null ? void 0 : step.name) != null ? _d : "mcp_server_tool" : builtinToolNameFromCallType(stepType);
+            const toolCallId = (_e = step == null ? void 0 : step.id) != null ? _e : blockId;
+            const state = {
+              kind: "builtin_tool_call",
+              id: blockId,
+              blockType: stepType,
+              toolCallId,
+              toolName,
+              arguments: (_f = step == null ? void 0 : step.arguments) != null ? _f : {},
+              callEmitted: false
+            };
+            openBlocks.set(index, state);
+          } else if (stepType != null && BUILTIN_TOOL_RESULT_TYPES.has(stepType)) {
+            const toolName = stepType === "mcp_server_tool_result" ? (_g = step == null ? void 0 : step.name) != null ? _g : "mcp_server_tool" : builtinToolNameFromResultType(stepType);
+            const callId = (_h = step == null ? void 0 : step.call_id) != null ? _h : blockId;
+            const state = {
+              kind: "builtin_tool_result",
+              id: blockId,
+              blockType: stepType,
+              callId,
+              toolName,
+              result: (_i = step == null ? void 0 : step.result) != null ? _i : null,
+              ...(step == null ? void 0 : step.is_error) != null ? { isError: step.is_error } : {},
+              resultEmitted: false
+            };
+            openBlocks.set(index, state);
+          } else {
+            openBlocks.set(index, { kind: "unknown", id: blockId });
+          }
+          break;
+        }
+        case "step.delta": {
+          const event = value;
+          let open = openBlocks.get(event.index);
+          if (open == null) break;
+          const dtype = (_j = event.delta) == null ? void 0 : _j.type;
+          if (open.kind === "pending_model_output") {
+            if (dtype === "text" || dtype === "text_annotation" || dtype === "text_annotation_delta") {
+              const promoted = {
+                kind: "text",
+                id: open.id,
+                emittedSourceKeys: /* @__PURE__ */ new Set()
+              };
+              openBlocks.set(event.index, promoted);
+              open = promoted;
+              controller.enqueue({ type: "text-start", id: promoted.id });
+            }
+          }
+          if (dtype === "image" && (open.kind === "pending_model_output" || open.kind === "text" || open.kind === "image")) {
+            const imageDelta = event.delta;
+            const google = {};
+            if (interactionId != null) google.interactionId = interactionId;
+            const providerMetadata = Object.keys(google).length > 0 ? { google } : void 0;
+            if ((imageDelta == null ? void 0 : imageDelta.data) != null && imageDelta.data.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_k = imageDelta.mime_type) != null ? _k : "image/png",
+                data: { type: "data", data: imageDelta.data },
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            } else if ((imageDelta == null ? void 0 : imageDelta.uri) != null && imageDelta.uri.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_l = imageDelta.mime_type) != null ? _l : "image/png",
+                data: { type: "url", url: new URL(imageDelta.uri) },
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            }
+            if (open.kind === "image") {
+              open.data = void 0;
+              open.uri = void 0;
+            }
+            break;
+          }
+          if (dtype === "video" && (open.kind === "pending_model_output" || open.kind === "text")) {
+            const videoDelta = event.delta;
+            const google = {};
+            if (interactionId != null) google.interactionId = interactionId;
+            const providerMetadata = Object.keys(google).length > 0 ? { google } : void 0;
+            if ((videoDelta == null ? void 0 : videoDelta.data) != null && videoDelta.data.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_m = videoDelta.mime_type) != null ? _m : "video/mp4",
+                data: { type: "data", data: videoDelta.data },
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            } else if ((videoDelta == null ? void 0 : videoDelta.uri) != null && videoDelta.uri.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_n = videoDelta.mime_type) != null ? _n : "video/mp4",
+                data: { type: "url", url: new URL(videoDelta.uri) },
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            }
+            break;
+          }
+          const delta = event.delta;
+          if (open.kind === "text" && (delta == null ? void 0 : delta.type) === "text") {
+            const text = (_o = delta.text) != null ? _o : "";
+            if (text.length > 0) {
+              controller.enqueue({
+                type: "text-delta",
+                id: open.id,
+                delta: text
+              });
+            }
+          } else if (open.kind === "text" && ((delta == null ? void 0 : delta.type) === "text_annotation" || (delta == null ? void 0 : delta.type) === "text_annotation_delta")) {
+            const sources = annotationsToSources({
+              annotations: delta.annotations,
+              generateId: generateId2
+            });
+            for (const source of sources) {
+              const key = sourceKey(source);
+              if (emittedSourceKeys.has(key)) continue;
+              emittedSourceKeys.add(key);
+              open.emittedSourceKeys.add(key);
+              controller.enqueue(source);
+            }
+          } else if (open.kind === "image" && (delta == null ? void 0 : delta.type) === "image") {
+            if (delta.data != null) open.data = delta.data;
+            if (delta.mime_type != null) open.mimeType = delta.mime_type;
+            if (delta.uri != null) open.uri = delta.uri;
+          } else if (open.kind === "reasoning") {
+            if ((delta == null ? void 0 : delta.type) === "thought_summary") {
+              const item = delta.content;
+              if ((item == null ? void 0 : item.type) === "text" && typeof item.text === "string") {
+                controller.enqueue({
+                  type: "reasoning-delta",
+                  id: open.id,
+                  delta: item.text
+                });
+              }
+            } else if ((delta == null ? void 0 : delta.type) === "thought_signature") {
+              const signature = delta.signature;
+              if (signature != null) {
+                open.signature = signature;
+              }
+            }
+          } else if (open.kind === "function_call" && (delta == null ? void 0 : delta.type) === "arguments_delta") {
+            const slice = typeof delta.arguments === "string" ? delta.arguments : "";
+            if (slice.length > 0) {
+              open.argumentsAccum += slice;
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: open.toolCallId,
+                delta: slice
+              });
+            }
+            if (delta.id != null) {
+              open.toolCallId = delta.id;
+            }
+            if (delta.signature != null) {
+              open.signature = delta.signature;
+            }
+            hasFunctionCall = true;
+          } else if (open.kind === "builtin_tool_call" && (delta == null ? void 0 : delta.type) === open.blockType) {
+            if (delta.id != null) open.toolCallId = delta.id;
+            if (delta.arguments != null && typeof delta.arguments === "object") {
+              open.arguments = delta.arguments;
+            }
+            if (delta.name != null && open.blockType === "mcp_server_tool_call") {
+              open.toolName = delta.name;
+            }
+          } else if (open.kind === "builtin_tool_result" && (delta == null ? void 0 : delta.type) === open.blockType) {
+            if (delta.call_id != null) open.callId = delta.call_id;
+            if (delta.result !== void 0) open.result = delta.result;
+            if (delta.is_error != null) open.isError = delta.is_error;
+            if (delta.name != null && open.blockType === "mcp_server_tool_result") {
+              open.toolName = delta.name;
+            }
+          }
+          break;
+        }
+        case "step.stop": {
+          const event = value;
+          const open = openBlocks.get(event.index);
+          if (open == null) break;
+          if (open.kind === "text") {
+            const textProviderMetadata = interactionId != null ? { google: { interactionId } } : void 0;
+            controller.enqueue({
+              type: "text-end",
+              id: open.id,
+              ...textProviderMetadata ? { providerMetadata: textProviderMetadata } : {}
+            });
+          } else if (open.kind === "reasoning") {
+            const google = {};
+            if (open.signature != null) google.signature = open.signature;
+            if (interactionId != null) google.interactionId = interactionId;
+            const providerMetadata = Object.keys(google).length > 0 ? { google } : void 0;
+            controller.enqueue({
+              type: "reasoning-end",
+              id: open.id,
+              ...providerMetadata ? { providerMetadata } : {}
+            });
+          } else if (open.kind === "image") {
+            const google = {};
+            if (interactionId != null) google.interactionId = interactionId;
+            const providerMetadata = Object.keys(google).length > 0 ? { google } : void 0;
+            if (open.data != null && open.data.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_p = open.mimeType) != null ? _p : "image/png",
+                data: { type: "data", data: open.data },
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            } else if (open.uri != null && open.uri.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_q = open.mimeType) != null ? _q : "image/png",
+                data: { type: "url", url: new URL(open.uri) },
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            }
+          } else if (open.kind === "function_call") {
+            const accumulated = open.argumentsAccum.length > 0 ? open.argumentsAccum : "{}";
+            controller.enqueue({
+              type: "tool-input-end",
+              id: open.toolCallId
+            });
+            const google = {};
+            if (open.signature != null) google.signature = open.signature;
+            if (interactionId != null) google.interactionId = interactionId;
+            const providerMetadata = Object.keys(google).length > 0 ? { google } : void 0;
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: open.toolCallId,
+              toolName: open.toolName,
+              input: accumulated,
+              ...providerMetadata ? { providerMetadata } : {}
+            });
+          } else if (open.kind === "builtin_tool_call" && !open.callEmitted) {
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: open.toolCallId,
+              toolName: open.toolName,
+              input: JSON.stringify((_r = open.arguments) != null ? _r : {}),
+              providerExecuted: true
+            });
+            open.callEmitted = true;
+          } else if (open.kind === "builtin_tool_result" && !open.resultEmitted) {
+            controller.enqueue({
+              type: "tool-result",
+              toolCallId: open.callId,
+              toolName: open.toolName,
+              result: (_s = open.result) != null ? _s : null
+            });
+            open.resultEmitted = true;
+            const sources = builtinToolResultToSources({
+              block: {
+                type: open.blockType,
+                call_id: open.callId,
+                result: open.result
+              },
+              generateId: generateId2
+            });
+            for (const source of sources) {
+              const key = sourceKey(source);
+              if (emittedSourceKeys.has(key)) continue;
+              emittedSourceKeys.add(key);
+              controller.enqueue(source);
+            }
+          }
+          openBlocks.delete(event.index);
+          break;
+        }
+        case "interaction.status_update":
+        case "interaction.in_progress":
+        case "interaction.requires_action": {
+          const event = value;
+          if (event.status != null) {
+            finishStatus = event.status;
+          } else if (eventType === "interaction.requires_action") {
+            finishStatus = "requires_action";
+          } else {
+            finishStatus = "in_progress";
+          }
+          break;
+        }
+        case "interaction.completed": {
+          const event = value;
+          const interaction = event.interaction;
+          if ((interaction == null ? void 0 : interaction.id) != null && interaction.id.length > 0) {
+            interactionId = interaction.id;
+          }
+          if ((interaction == null ? void 0 : interaction.status) != null) {
+            finishStatus = interaction.status;
+          }
+          if ((interaction == null ? void 0 : interaction.usage) != null) {
+            usage = interaction.usage;
+          }
+          if ((interaction == null ? void 0 : interaction.service_tier) != null) {
+            serviceTier = interaction.service_tier;
+          }
+          break;
+        }
+        case "error": {
+          const event = value;
+          finishStatus = "failed";
+          const errorPayload = (_t = event.error) != null ? _t : {
+            message: "Unknown interaction error"
+          };
+          controller.enqueue({ type: "error", error: errorPayload });
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    flush(controller) {
+      const finishReason = {
+        unified: mapGoogleInteractionsFinishReason({
+          status: finishStatus,
+          hasFunctionCall
+        }),
+        raw: finishStatus
+      };
+      const outputTokensByModality = getGoogleInteractionsOutputTokensByModality(usage);
+      const providerMetadata = {
+        google: {
+          ...interactionId != null ? { interactionId } : {},
+          ...serviceTier != null ? { serviceTier } : {},
+          ...outputTokensByModality != null ? { outputTokensByModality } : {}
+        }
+      };
+      controller.enqueue({
+        type: "finish",
+        finishReason,
+        usage: convertGoogleInteractionsUsage(usage),
+        providerMetadata
+      });
+    }
+  });
+}
+
+// src/interactions/convert-to-google-interactions-input.ts
+import {
+  convertToBase64 as convertToBase642,
+  getTopLevelMediaType as getTopLevelMediaType2,
+  isFullMediaType as isFullMediaType2,
+  resolveFullMediaType as resolveFullMediaType2,
+  resolveProviderReference as resolveProviderReference2
+} from "@ai-sdk/provider-utils";
+function convertToGoogleInteractionsInput({
+  prompt,
+  previousInteractionId,
+  store,
+  mediaResolution
+}) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const warnings = [];
+  const incoherentCombo = previousInteractionId != null && store === false;
+  const shouldCompact = previousInteractionId != null && store !== false;
+  if (incoherentCombo) {
+    warnings.push({
+      type: "other",
+      message: "google.interactions: providerOptions.google.previousInteractionId was set together with store: false. These are incoherent (the prior interaction cannot be referenced when nothing was stored on the server); the full history will be sent and previous_interaction_id will still be emitted."
+    });
+  }
+  const compactedPrompt = shouldCompact ? compactPromptForPreviousInteraction({
+    prompt,
+    previousInteractionId
+  }) : prompt;
+  const systemTexts = [];
+  const steps = [];
+  for (const message of compactedPrompt) {
+    switch (message.role) {
+      case "system": {
+        systemTexts.push(message.content);
+        break;
+      }
+      case "user": {
+        const content = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "file") {
+            const fileBlock = convertFilePartToContent({
+              part,
+              warnings,
+              mediaResolution
+            });
+            if (fileBlock != null) {
+              content.push(fileBlock);
+            }
+          }
+        }
+        const merged = mergeAdjacentTextContent(content);
+        if (merged.length > 0) {
+          steps.push({ type: "user_input", content: merged });
+        }
+        break;
+      }
+      case "assistant": {
+        let pendingModelOutput = [];
+        const flushModelOutput = () => {
+          if (pendingModelOutput.length > 0) {
+            steps.push({ type: "model_output", content: pendingModelOutput });
+            pendingModelOutput = [];
+          }
+        };
+        for (const part of message.content) {
+          if (part.type === "text") {
+            pendingModelOutput.push({ type: "text", text: part.text });
+          } else if (part.type === "reasoning") {
+            flushModelOutput();
+            const signature = (_b = (_a = part.providerOptions) == null ? void 0 : _a.google) == null ? void 0 : _b.signature;
+            steps.push({
+              type: "thought",
+              ...signature != null ? { signature } : {},
+              summary: part.text.length > 0 ? [{ type: "text", text: part.text }] : void 0
+            });
+          } else if (part.type === "file") {
+            const fileBlock = convertFilePartToContent({
+              part,
+              warnings,
+              mediaResolution
+            });
+            if (fileBlock != null) {
+              pendingModelOutput.push(fileBlock);
+            }
+          } else if (part.type === "tool-call") {
+            flushModelOutput();
+            const signature = (_d = (_c = part.providerOptions) == null ? void 0 : _c.google) == null ? void 0 : _d.signature;
+            const args = typeof part.input === "string" ? safeParseToolArgs(part.input) : (_e = part.input) != null ? _e : {};
+            steps.push({
+              type: "function_call",
+              id: part.toolCallId,
+              name: part.toolName,
+              arguments: args,
+              ...signature != null ? { signature } : {}
+            });
+          } else {
+            warnings.push({
+              type: "other",
+              message: `google.interactions: unsupported assistant content part type "${part.type}"; part dropped.`
+            });
+          }
+        }
+        flushModelOutput();
+        break;
+      }
+      case "tool": {
+        const content = [];
+        for (const part of message.content) {
+          if (part.type !== "tool-result") {
+            warnings.push({
+              type: "other",
+              message: `google.interactions: unsupported tool message part type "${part.type}"; part dropped.`
+            });
+            continue;
+          }
+          const block = convertToolResultPart({
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            output: part.output,
+            signature: (_g = (_f = part.providerOptions) == null ? void 0 : _f.google) == null ? void 0 : _g.signature,
+            warnings
+          });
+          content.push(block);
+        }
+        if (content.length > 0) {
+          steps.push({ type: "user_input", content });
+        }
+        break;
+      }
+    }
+  }
+  const systemInstruction = systemTexts.length > 0 ? systemTexts.join("\n\n") : void 0;
+  return { input: steps, systemInstruction, warnings };
+}
+function convertFilePartToContent({
+  part,
+  warnings,
+  mediaResolution
+}) {
+  if (part.data.type === "text") {
+    return {
+      type: "text",
+      text: part.data.text
+    };
+  }
+  const topLevel = getTopLevelMediaType2(part.mediaType);
+  let kind;
+  switch (topLevel) {
+    case "image":
+      kind = "image";
+      break;
+    case "audio":
+      kind = "audio";
+      break;
+    case "video":
+      kind = "video";
+      break;
+    case "application":
+      kind = "document";
+      break;
+    default:
+      kind = void 0;
+  }
+  if (kind == null) {
+    warnings.push({
+      type: "other",
+      message: `google.interactions: unsupported file media type "${part.mediaType}"; part dropped.`
+    });
+    return void 0;
+  }
+  const resolutionField = mediaResolution != null && (kind === "image" || kind === "video") ? { resolution: mediaResolution } : {};
+  switch (part.data.type) {
+    case "data": {
+      const mimeType = resolveFullMediaType2({ part });
+      return {
+        type: kind,
+        data: convertToBase642(part.data.data),
+        mime_type: mimeType,
+        ...resolutionField
+      };
+    }
+    case "url": {
+      return {
+        type: kind,
+        uri: part.data.url.toString(),
+        ...isFullMediaType2(part.mediaType) ? { mime_type: part.mediaType } : {},
+        ...resolutionField
+      };
+    }
+    case "reference": {
+      const uri = resolveProviderReference2({
+        reference: part.data.reference,
+        provider: "google"
+      });
+      return {
+        type: kind,
+        uri,
+        ...isFullMediaType2(part.mediaType) ? { mime_type: part.mediaType } : {},
+        ...resolutionField
+      };
+    }
+  }
+}
+function compactPromptForPreviousInteraction({
+  prompt,
+  previousInteractionId
+}) {
+  const out = [];
+  const droppedToolCallIds = /* @__PURE__ */ new Set();
+  for (const message of prompt) {
+    if (message.role === "assistant") {
+      const matchesLinkedInteraction = message.content.some((part) => {
+        var _a, _b;
+        const partInteractionId = (_b = (_a = part.providerOptions) == null ? void 0 : _a.google) == null ? void 0 : _b.interactionId;
+        return partInteractionId === previousInteractionId;
+      });
+      if (matchesLinkedInteraction) {
+        for (const part of message.content) {
+          if (part.type === "tool-call") {
+            droppedToolCallIds.add(part.toolCallId);
+          }
+        }
+        continue;
+      }
+      out.push(message);
+      continue;
+    }
+    if (message.role === "tool") {
+      const remaining = message.content.filter((part) => {
+        if (part.type !== "tool-result") {
+          return true;
+        }
+        return !droppedToolCallIds.has(part.toolCallId);
+      });
+      if (remaining.length === 0) {
+        continue;
+      }
+      out.push({
+        ...message,
+        content: remaining
+      });
+      continue;
+    }
+    out.push(message);
+  }
+  return out;
+}
+function safeParseToolArgs(input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return { value: parsed };
+  } catch (e) {
+    return { value: input };
+  }
+}
+function convertToolResultPart({
+  toolCallId,
+  toolName,
+  output,
+  signature,
+  warnings
+}) {
+  var _a;
+  const base = {
+    type: "function_result",
+    call_id: toolCallId,
+    name: toolName,
+    ...signature != null ? { signature } : {}
+  };
+  switch (output.type) {
+    case "text":
+      return { ...base, result: output.value };
+    case "json":
+      return { ...base, result: JSON.stringify(output.value) };
+    case "error-text":
+      return { ...base, is_error: true, result: output.value };
+    case "error-json":
+      return { ...base, is_error: true, result: JSON.stringify(output.value) };
+    case "execution-denied":
+      return {
+        ...base,
+        is_error: true,
+        result: (_a = output.reason) != null ? _a : "Tool execution denied by user."
+      };
+    case "content": {
+      const blocks = [];
+      for (const item of output.value) {
+        if (item.type === "text") {
+          blocks.push({ type: "text", text: item.text });
+        } else if (item.type === "file") {
+          const topLevel = getTopLevelMediaType2(item.mediaType);
+          if (topLevel !== "image") {
+            warnings.push({
+              type: "other",
+              message: `google.interactions: tool-result file with mediaType "${item.mediaType}" is not supported (Interactions \`function_result.result\` accepts only text and image content); part dropped.`
+            });
+            continue;
+          }
+          const imageBlock = filePartToImageBlock({ part: item, warnings });
+          if (imageBlock != null) {
+            blocks.push(imageBlock);
+          }
+        } else {
+          warnings.push({
+            type: "other",
+            message: `google.interactions: tool-result content part type "${item.type}" is not supported; part dropped.`
+          });
+        }
+      }
+      return { ...base, result: blocks };
+    }
+  }
+}
+function filePartToImageBlock({
+  part,
+  warnings
+}) {
+  switch (part.data.type) {
+    case "data": {
+      const mimeType = isFullMediaType2(part.mediaType) ? part.mediaType : resolveFullMediaType2({
+        part: {
+          type: "file",
+          mediaType: part.mediaType,
+          data: part.data
+        }
+      });
+      return {
+        type: "image",
+        data: convertToBase642(part.data.data),
+        mime_type: mimeType
+      };
+    }
+    case "url":
+      return {
+        type: "image",
+        uri: part.data.url.toString(),
+        ...isFullMediaType2(part.mediaType) ? { mime_type: part.mediaType } : {}
+      };
+    case "reference": {
+      const uri = resolveProviderReference2({
+        reference: part.data.reference,
+        provider: "google"
+      });
+      return {
+        type: "image",
+        uri,
+        ...isFullMediaType2(part.mediaType) ? { mime_type: part.mediaType } : {}
+      };
+    }
+    case "text": {
+      warnings.push({
+        type: "other",
+        message: 'google.interactions: tool-result image part with `data.type === "text"` is not representable as an image; part dropped.'
+      });
+      return void 0;
+    }
+  }
+}
+function mergeAdjacentTextContent(content) {
+  if (content.length < 2) {
+    return content;
+  }
+  const result = [];
+  for (const block of content) {
+    const last = result[result.length - 1];
+    if (block.type === "text" && last != null && last.type === "text" && last.annotations == null && block.annotations == null) {
+      const merged = {
+        type: "text",
+        text: `${last.text}
+
+${block.text}`
+      };
+      result[result.length - 1] = merged;
+      continue;
+    }
+    result.push(block);
+  }
+  return result;
+}
+
+// src/interactions/google-interactions-api.ts
+import {
+  lazySchema as lazySchema12,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var tokenByModalitySchema = () => z13.object({
+  modality: z13.string().nullish(),
+  tokens: z13.number().nullish()
+}).loose();
+var usageSchema2 = () => z13.object({
+  total_input_tokens: z13.number().nullish(),
+  total_output_tokens: z13.number().nullish(),
+  total_thought_tokens: z13.number().nullish(),
+  total_cached_tokens: z13.number().nullish(),
+  total_tool_use_tokens: z13.number().nullish(),
+  total_tokens: z13.number().nullish(),
+  input_tokens_by_modality: z13.array(tokenByModalitySchema()).nullish(),
+  output_tokens_by_modality: z13.array(tokenByModalitySchema()).nullish(),
+  cached_tokens_by_modality: z13.array(tokenByModalitySchema()).nullish(),
+  tool_use_tokens_by_modality: z13.array(tokenByModalitySchema()).nullish(),
+  grounding_tool_count: z13.array(
+    z13.object({
+      type: z13.string().nullish(),
+      count: z13.number().nullish()
+    }).loose()
+  ).nullish()
+}).loose();
+var interactionStatusSchema = () => z13.enum([
+  "in_progress",
+  "requires_action",
+  "completed",
+  "failed",
+  "cancelled",
+  "incomplete"
+]);
+var annotationSchema = () => {
+  const urlCitation = z13.object({
+    type: z13.literal("url_citation"),
+    url: z13.string().nullish(),
+    title: z13.string().nullish(),
+    start_index: z13.number().nullish(),
+    end_index: z13.number().nullish()
+  }).loose();
+  const fileCitation = z13.object({
+    type: z13.literal("file_citation"),
+    file_name: z13.string().nullish(),
+    document_uri: z13.string().nullish(),
+    url: z13.string().nullish(),
+    page_number: z13.number().nullish(),
+    media_id: z13.string().nullish(),
+    start_index: z13.number().nullish(),
+    end_index: z13.number().nullish(),
+    custom_metadata: z13.record(z13.string(), z13.unknown()).nullish()
+  }).loose();
+  const placeCitation = z13.object({
+    type: z13.literal("place_citation"),
+    name: z13.string().nullish(),
+    url: z13.string().nullish(),
+    place_id: z13.string().nullish(),
+    start_index: z13.number().nullish(),
+    end_index: z13.number().nullish()
+  }).loose();
+  return z13.union([
+    urlCitation,
+    fileCitation,
+    placeCitation,
+    z13.object({ type: z13.string() }).loose()
+  ]);
+};
+var thoughtSummaryItemSchema = () => z13.object({
+  type: z13.string(),
+  text: z13.string().nullish(),
+  data: z13.string().nullish(),
+  mime_type: z13.string().nullish()
+}).loose();
+var contentBlockSchema = () => {
+  const textContent = z13.object({
+    type: z13.literal("text"),
+    text: z13.string(),
+    annotations: z13.array(annotationSchema()).nullish()
+  }).loose();
+  const imageContent = z13.object({
+    type: z13.literal("image"),
+    data: z13.string().nullish(),
+    mime_type: z13.string().nullish(),
+    resolution: z13.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+    uri: z13.string().nullish()
+  }).loose();
+  const videoContent = z13.object({
+    type: z13.literal("video"),
+    data: z13.string().nullish(),
+    mime_type: z13.string().nullish(),
+    uri: z13.string().nullish()
+  }).loose();
+  return z13.union([
+    textContent,
+    imageContent,
+    videoContent,
+    z13.object({ type: z13.string() }).loose()
+  ]);
+};
+var BUILTIN_TOOL_CALL_STEP_TYPES = [
+  "google_search_call",
+  "code_execution_call",
+  "url_context_call",
+  "file_search_call",
+  "google_maps_call",
+  "mcp_server_tool_call"
+];
+var BUILTIN_TOOL_RESULT_STEP_TYPES = [
+  "google_search_result",
+  "code_execution_result",
+  "url_context_result",
+  "file_search_result",
+  "google_maps_result",
+  "mcp_server_tool_result"
+];
+var stepSchema = () => {
+  const userInputStep = z13.object({
+    type: z13.literal("user_input"),
+    content: z13.array(contentBlockSchema()).nullish()
+  }).loose();
+  const modelOutputStep = z13.object({
+    type: z13.literal("model_output"),
+    content: z13.array(contentBlockSchema()).nullish()
+  }).loose();
+  const functionCallStep = z13.object({
+    type: z13.literal("function_call"),
+    id: z13.string(),
+    name: z13.string(),
+    arguments: z13.record(z13.string(), z13.unknown()).nullish(),
+    signature: z13.string().nullish()
+  }).loose();
+  const thoughtStep = z13.object({
+    type: z13.literal("thought"),
+    signature: z13.string().nullish(),
+    summary: z13.array(thoughtSummaryItemSchema()).nullish()
+  }).loose();
+  const builtinToolCallStep = z13.object({
+    type: z13.enum(BUILTIN_TOOL_CALL_STEP_TYPES),
+    id: z13.string(),
+    arguments: z13.record(z13.string(), z13.unknown()).nullish(),
+    name: z13.string().nullish(),
+    server_name: z13.string().nullish(),
+    search_type: z13.string().nullish(),
+    signature: z13.string().nullish()
+  }).loose();
+  const builtinToolResultStep = z13.object({
+    type: z13.enum(BUILTIN_TOOL_RESULT_STEP_TYPES),
+    call_id: z13.string(),
+    result: z13.unknown().nullish(),
+    is_error: z13.boolean().nullish(),
+    name: z13.string().nullish(),
+    server_name: z13.string().nullish(),
+    signature: z13.string().nullish()
+  }).loose();
+  return z13.union([
+    userInputStep,
+    modelOutputStep,
+    functionCallStep,
+    thoughtStep,
+    builtinToolCallStep,
+    builtinToolResultStep,
+    z13.object({ type: z13.string() }).loose()
+  ]);
+};
+var googleInteractionsResponseSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      /*
+       * `id` is omitted from the response body when `store: false` (fully
+       * stateless mode) — there is no server-side interaction record for the
+       * client to reference. `nullish` lets the schema accept that shape.
+       */
+      id: z13.string().nullish(),
+      created: z13.string().nullish(),
+      updated: z13.string().nullish(),
+      status: interactionStatusSchema(),
+      model: z13.string().nullish(),
+      agent: z13.string().nullish(),
+      steps: z13.array(stepSchema()).nullish(),
+      usage: usageSchema2().nullish(),
+      service_tier: z13.string().nullish(),
+      previous_interaction_id: z13.string().nullish(),
+      response_modalities: z13.array(z13.string()).nullish()
+    }).loose()
+  )
+);
+var googleInteractionsEventSchema = lazySchema12(
+  () => zodSchema12(
+    (() => {
+      const status = interactionStatusSchema();
+      const annotation = annotationSchema();
+      const thoughtSummaryItem = thoughtSummaryItemSchema();
+      const interactionCreatedEvent = z13.object({
+        event_type: z13.literal("interaction.created"),
+        event_id: z13.string().nullish(),
+        interaction: z13.object({
+          /*
+           * `id` is omitted when `store: false` (fully stateless mode);
+           * see the matching note on `googleInteractionsResponseSchema.id`.
+           */
+          id: z13.string().nullish(),
+          created: z13.string().nullish(),
+          model: z13.string().nullish(),
+          agent: z13.string().nullish(),
+          status: status.nullish()
+        }).loose()
+      }).loose();
+      const stepStartEvent = z13.object({
+        event_type: z13.literal("step.start"),
+        event_id: z13.string().nullish(),
+        index: z13.number(),
+        step: stepSchema()
+      }).loose();
+      const stepDeltaText = z13.object({
+        type: z13.literal("text"),
+        text: z13.string()
+      }).loose();
+      const stepDeltaThoughtSummary = z13.object({
+        type: z13.literal("thought_summary"),
+        content: thoughtSummaryItem.nullish()
+      }).loose();
+      const stepDeltaThoughtSignature = z13.object({
+        type: z13.literal("thought_signature"),
+        signature: z13.string().nullish()
+      }).loose();
+      const stepDeltaArgumentsDelta = z13.object({
+        type: z13.literal("arguments_delta"),
+        arguments: z13.string().nullish(),
+        id: z13.string().nullish(),
+        signature: z13.string().nullish()
+      }).loose();
+      const stepDeltaTextAnnotation = z13.object({
+        type: z13.enum(["text_annotation_delta", "text_annotation"]),
+        annotations: z13.array(annotation).nullish()
+      }).loose();
+      const stepDeltaImage = z13.object({
+        type: z13.literal("image"),
+        data: z13.string().nullish(),
+        mime_type: z13.string().nullish(),
+        resolution: z13.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+        uri: z13.string().nullish()
+      }).loose();
+      const stepDeltaVideo = z13.object({
+        type: z13.literal("video"),
+        data: z13.string().nullish(),
+        mime_type: z13.string().nullish(),
+        uri: z13.string().nullish()
+      }).loose();
+      const stepDeltaBuiltinToolCall = z13.object({
+        type: z13.enum(BUILTIN_TOOL_CALL_STEP_TYPES),
+        id: z13.string().nullish(),
+        arguments: z13.record(z13.string(), z13.unknown()).nullish(),
+        name: z13.string().nullish(),
+        server_name: z13.string().nullish(),
+        search_type: z13.string().nullish(),
+        signature: z13.string().nullish()
+      }).loose();
+      const stepDeltaBuiltinToolResult = z13.object({
+        type: z13.enum(BUILTIN_TOOL_RESULT_STEP_TYPES),
+        call_id: z13.string().nullish(),
+        result: z13.unknown().nullish(),
+        is_error: z13.boolean().nullish(),
+        name: z13.string().nullish(),
+        server_name: z13.string().nullish(),
+        signature: z13.string().nullish()
+      }).loose();
+      const stepDeltaUnknown = z13.object({ type: z13.string() }).loose();
+      const stepDeltaUnion = z13.union([
+        stepDeltaText,
+        stepDeltaImage,
+        stepDeltaVideo,
+        stepDeltaThoughtSummary,
+        stepDeltaThoughtSignature,
+        stepDeltaArgumentsDelta,
+        stepDeltaTextAnnotation,
+        stepDeltaBuiltinToolCall,
+        stepDeltaBuiltinToolResult,
+        stepDeltaUnknown
+      ]);
+      const stepDeltaEvent = z13.object({
+        event_type: z13.literal("step.delta"),
+        event_id: z13.string().nullish(),
+        index: z13.number(),
+        delta: stepDeltaUnion
+      }).loose();
+      const stepStopEvent = z13.object({
+        event_type: z13.literal("step.stop"),
+        event_id: z13.string().nullish(),
+        index: z13.number()
+      }).loose();
+      const interactionStatusUpdateEvent = z13.object({
+        event_type: z13.literal("interaction.status_update"),
+        event_id: z13.string().nullish(),
+        interaction_id: z13.string().nullish(),
+        status: status.nullish()
+      }).loose();
+      const interactionInProgressEvent = z13.object({
+        event_type: z13.literal("interaction.in_progress"),
+        event_id: z13.string().nullish(),
+        interaction_id: z13.string().nullish(),
+        status: status.nullish()
+      }).loose();
+      const interactionRequiresActionEvent = z13.object({
+        event_type: z13.literal("interaction.requires_action"),
+        event_id: z13.string().nullish(),
+        interaction_id: z13.string().nullish(),
+        status: status.nullish()
+      }).loose();
+      const interactionCompletedEvent = z13.object({
+        event_type: z13.literal("interaction.completed"),
+        event_id: z13.string().nullish(),
+        interaction: z13.object({
+          id: z13.string().nullish(),
+          status: status.nullish(),
+          usage: usageSchema2().nullish(),
+          service_tier: z13.string().nullish()
+        }).loose()
+      }).loose();
+      const errorEvent = z13.object({
+        event_type: z13.literal("error"),
+        event_id: z13.string().nullish(),
+        error: z13.object({
+          code: z13.string().nullish(),
+          message: z13.string().nullish()
+        }).loose().nullish()
+      }).loose();
+      const unknownEvent = z13.object({ event_type: z13.string() }).loose();
+      return z13.union([
+        interactionCreatedEvent,
+        stepStartEvent,
+        stepDeltaEvent,
+        stepStopEvent,
+        interactionStatusUpdateEvent,
+        interactionInProgressEvent,
+        interactionRequiresActionEvent,
+        interactionCompletedEvent,
+        errorEvent,
+        unknownEvent
+      ]);
+    })()
+  )
+);
+
+// src/interactions/google-interactions-language-model-options.ts
+import {
+  lazySchema as lazySchema13,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
+var googleInteractionsLanguageModelOptions = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      previousInteractionId: z14.string().nullish(),
+      store: z14.boolean().nullish(),
+      agent: z14.string().nullish(),
+      agentConfig: z14.union([
+        z14.object({
+          type: z14.literal("dynamic")
+        }).loose(),
+        z14.object({
+          type: z14.literal("deep-research"),
+          thinkingSummaries: z14.enum(["auto", "none"]).nullish(),
+          visualization: z14.enum(["off", "auto"]).nullish(),
+          collaborativePlanning: z14.boolean().nullish()
+        })
+      ]).nullish(),
+      thinkingLevel: z14.enum(["minimal", "low", "medium", "high"]).nullish(),
+      thinkingSummaries: z14.enum(["auto", "none"]).nullish(),
+      /**
+       * Output-format entries that map directly to the API's `response_format`
+       * array. Use this to request image, audio, or non-JSON text outputs
+       * with full control over `mime_type`, `aspect_ratio`, and `image_size`.
+       *
+       * Entries are sent in order. The AI SDK call-level `responseFormat: {
+       * type: 'json', schema }` still drives JSON-mode and adds a matching
+       * text entry automatically; entries listed here are appended.
+       */
+      responseFormat: z14.array(
+        z14.union([
+          z14.object({
+            type: z14.literal("text"),
+            mimeType: z14.string().nullish(),
+            schema: z14.unknown().nullish()
+          }).loose(),
+          z14.object({
+            type: z14.literal("image"),
+            mimeType: z14.string().nullish(),
+            aspectRatio: z14.enum([
+              "1:1",
+              "2:3",
+              "3:2",
+              "3:4",
+              "4:3",
+              "4:5",
+              "5:4",
+              "9:16",
+              "16:9",
+              "21:9",
+              "1:8",
+              "8:1",
+              "1:4",
+              "4:1"
+            ]).nullish(),
+            imageSize: z14.enum(["1K", "2K", "4K", "512"]).nullish()
+          }).loose(),
+          z14.object({
+            type: z14.literal("audio"),
+            mimeType: z14.string().nullish()
+          }).loose()
+        ])
+      ).nullish(),
+      /**
+       * @deprecated Use `responseFormat` with a `{ type: 'image', ... }`
+       * entry instead. Retained for backwards compatibility; the SDK
+       * translates it into a matching `response_format` image entry and
+       * emits a warning when set.
+       */
+      imageConfig: z14.object({
+        aspectRatio: z14.enum([
+          "1:1",
+          "2:3",
+          "3:2",
+          "3:4",
+          "4:3",
+          "4:5",
+          "5:4",
+          "9:16",
+          "16:9",
+          "21:9",
+          "1:8",
+          "8:1",
+          "1:4",
+          "4:1"
+        ]).nullish(),
+        imageSize: z14.enum(["1K", "2K", "4K", "512"]).nullish()
+      }).nullish(),
+      mediaResolution: z14.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+      responseModalities: z14.array(z14.enum(["text", "image", "audio", "video", "document"])).nullish(),
+      serviceTier: z14.enum(["flex", "standard", "priority"]).nullish(),
+      /**
+       * Alternative to AI SDK `system` message. If both are set, the AI SDK
+       * `system` message wins and a warning is emitted.
+       */
+      systemInstruction: z14.string().nullish(),
+      /**
+       * Per-block signature for round-tripping `thought.signature` and
+       * `function_call.signature` blocks. Set by the SDK on output reasoning /
+       * tool-call parts; passed back unchanged on input parts so the API
+       * accepts the prior turn.
+       */
+      signature: z14.string().nullish(),
+      /**
+       * Set by the SDK on output assistant messages. The converter uses it to
+       * decide which messages to drop when compacting under
+       * `previousInteractionId`.
+       */
+      interactionId: z14.string().nullish(),
+      /**
+       * Maximum time, in milliseconds, to poll a background interaction (agent
+       * call) before giving up. Defaults to 30 minutes. Long-running agents
+       * such as deep research can take tens of minutes — increase if needed.
+       */
+      pollingTimeoutMs: z14.number().int().positive().nullish(),
+      /**
+       * Run the interaction in the background. Required for agents whose
+       * server-side workflow cannot complete within a single request/response.
+       * When `true`, the POST returns with a non-terminal status and the SDK
+       * polls `GET /interactions/{id}` until the work completes. Some agents
+       * reject `true`; see the agent's documentation for which mode it
+       * requires.
+       */
+      background: z14.boolean().nullish(),
+      /**
+       * Environment configuration for the agent sandbox. Only applies to agent
+       * calls (`google.interactions({ agent })`); ignored on model-id calls.
+       *
+       *   - `"remote"`: provision a fresh sandbox for this call.
+       *   - any other string: an existing `environment_id` to reuse.
+       *   - object: provision a fresh sandbox and optionally preload `sources`
+       *     and/or constrain outbound traffic via `network`.
+       */
+      environment: z14.union([
+        z14.string(),
+        z14.object({
+          type: z14.literal("remote"),
+          sources: z14.array(
+            z14.union([
+              z14.object({
+                type: z14.literal("gcs"),
+                source: z14.string(),
+                target: z14.string().nullish()
+              }),
+              z14.object({
+                type: z14.literal("repository"),
+                source: z14.string(),
+                target: z14.string().nullish()
+              }),
+              z14.object({
+                type: z14.literal("inline"),
+                content: z14.string(),
+                target: z14.string()
+              })
+            ])
+          ).nullish(),
+          network: z14.union([
+            z14.literal("disabled"),
+            z14.object({
+              allowlist: z14.array(
+                z14.object({
+                  domain: z14.string(),
+                  transform: z14.array(z14.record(z14.string(), z14.string())).nullish()
+                })
+              )
+            })
+          ]).nullish()
+        })
+      ]).nullish()
+    })
+  )
+);
+
+// src/interactions/parse-google-interactions-outputs.ts
+function googleProviderMetadata({
+  signature,
+  interactionId
+}) {
+  const google = {};
+  if (signature != null) {
+    google.signature = signature;
+  }
+  if (interactionId != null) {
+    google.interactionId = interactionId;
+  }
+  return Object.keys(google).length > 0 ? { providerMetadata: { google } } : {};
+}
+var BUILTIN_TOOL_CALL_TYPES2 = /* @__PURE__ */ new Set([
+  "google_search_call",
+  "code_execution_call",
+  "url_context_call",
+  "file_search_call",
+  "google_maps_call",
+  "mcp_server_tool_call"
+]);
+var BUILTIN_TOOL_RESULT_TYPES2 = /* @__PURE__ */ new Set([
+  "google_search_result",
+  "code_execution_result",
+  "url_context_result",
+  "file_search_result",
+  "google_maps_result",
+  "mcp_server_tool_result"
+]);
+function builtinToolNameFromCallType2(type) {
+  return type.replace(/_call$/, "");
+}
+function builtinToolNameFromResultType2(type) {
+  return type.replace(/_result$/, "");
+}
+function parseGoogleInteractionsOutputs({
+  steps,
+  generateId: generateId2,
+  interactionId
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const content = [];
+  let hasFunctionCall = false;
+  if (steps == null) {
+    return { content, hasFunctionCall };
+  }
+  for (const step of steps) {
+    if (step == null || typeof step !== "object") continue;
+    const type = step.type;
+    if (typeof type !== "string") continue;
+    switch (type) {
+      case "user_input": {
+        break;
+      }
+      case "model_output": {
+        const blocks = (_a = step.content) != null ? _a : [];
+        for (const block of blocks) {
+          if (block == null || typeof block !== "object") continue;
+          const blockType = block.type;
+          if (blockType === "text") {
+            const text = (_b = block.text) != null ? _b : "";
+            const annotations = block.annotations;
+            content.push({
+              type: "text",
+              text,
+              ...googleProviderMetadata({ interactionId })
+            });
+            const sources = annotationsToSources({ annotations, generateId: generateId2 });
+            for (const source of sources) {
+              content.push(source);
+            }
+          } else if (blockType === "image") {
+            const image = block;
+            if (image.data != null && image.data.length > 0) {
+              content.push({
+                type: "file",
+                mediaType: (_c = image.mime_type) != null ? _c : "image/png",
+                data: { type: "data", data: image.data },
+                ...googleProviderMetadata({ interactionId })
+              });
+            } else if (image.uri != null && image.uri.length > 0) {
+              content.push({
+                type: "file",
+                mediaType: (_d = image.mime_type) != null ? _d : "image/png",
+                data: { type: "url", url: new URL(image.uri) },
+                ...googleProviderMetadata({ interactionId })
+              });
+            }
+          } else if (blockType === "video") {
+            const video = block;
+            if (video.data != null && video.data.length > 0) {
+              content.push({
+                type: "file",
+                mediaType: (_e = video.mime_type) != null ? _e : "video/mp4",
+                data: { type: "data", data: video.data },
+                ...googleProviderMetadata({ interactionId })
+              });
+            } else if (video.uri != null && video.uri.length > 0) {
+              content.push({
+                type: "file",
+                mediaType: (_f = video.mime_type) != null ? _f : "video/mp4",
+                data: { type: "url", url: new URL(video.uri) },
+                ...googleProviderMetadata({ interactionId })
+              });
+            }
+          }
+        }
+        break;
+      }
+      case "thought": {
+        const thought = step;
+        const summary = Array.isArray(thought.summary) ? thought.summary : [];
+        const text = summary.filter(
+          (item) => (item == null ? void 0 : item.type) === "text" && typeof item.text === "string"
+        ).map((item) => item.text).join("\n");
+        content.push({
+          type: "reasoning",
+          text,
+          ...googleProviderMetadata({
+            signature: thought.signature,
+            interactionId
+          })
+        });
+        break;
+      }
+      case "function_call": {
+        hasFunctionCall = true;
+        const call = step;
+        content.push({
+          type: "tool-call",
+          toolCallId: call.id,
+          toolName: call.name,
+          input: JSON.stringify((_g = call.arguments) != null ? _g : {}),
+          ...googleProviderMetadata({
+            signature: call.signature,
+            interactionId
+          })
+        });
+        break;
+      }
+      default: {
+        if (BUILTIN_TOOL_CALL_TYPES2.has(type)) {
+          const call = step;
+          const toolName = type === "mcp_server_tool_call" ? (_h = call.name) != null ? _h : "mcp_server_tool" : builtinToolNameFromCallType2(type);
+          const input = JSON.stringify((_i = call.arguments) != null ? _i : {});
+          content.push({
+            type: "tool-call",
+            toolCallId: (_j = call.id) != null ? _j : generateId2(),
+            toolName,
+            input,
+            providerExecuted: true
+          });
+        } else if (BUILTIN_TOOL_RESULT_TYPES2.has(type)) {
+          const result = step;
+          const toolName = type === "mcp_server_tool_result" ? (_k = result.name) != null ? _k : "mcp_server_tool" : builtinToolNameFromResultType2(type);
+          content.push({
+            type: "tool-result",
+            toolCallId: (_l = result.call_id) != null ? _l : generateId2(),
+            toolName,
+            result: (_m = result.result) != null ? _m : null
+          });
+          const sources = builtinToolResultToSources({
+            block: step,
+            generateId: generateId2
+          });
+          for (const source of sources) {
+            content.push(source);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return { content, hasFunctionCall };
+}
+
+// src/interactions/poll-google-interactions.ts
+import {
+  createJsonResponseHandler as createJsonResponseHandler3,
+  delay,
+  getFromApi,
+  isAbortError
+} from "@ai-sdk/provider-utils";
+
+// src/interactions/cancel-google-interaction.ts
+import {
+  combineHeaders as combineHeaders3,
+  getRuntimeEnvironmentUserAgent,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
+var getOriginalFetch = () => globalThis.fetch;
+async function cancelGoogleInteraction({
+  baseURL,
+  interactionId,
+  headers,
+  fetch = getOriginalFetch()
+}) {
+  if (interactionId == null || interactionId.length === 0) {
+    return;
+  }
+  const url = `${baseURL}/interactions/${encodeURIComponent(interactionId)}/cancel`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: withUserAgentSuffix(
+        combineHeaders3({ "Content-Type": "application/json" }, headers),
+        getRuntimeEnvironmentUserAgent()
+      ),
+      body: "{}"
+    });
+    try {
+      await response.text();
+    } catch (e) {
+    }
+  } catch (e) {
+  }
+}
+
+// src/interactions/poll-google-interactions.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "incomplete"]);
+function isTerminalStatus(status) {
+  return status != null && TERMINAL_STATUSES.has(status);
+}
+var DEFAULT_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 1e4;
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
+async function pollGoogleInteractionUntilTerminal({
+  baseURL,
+  interactionId,
+  headers,
+  fetch,
+  abortSignal,
+  initialDelayMs = DEFAULT_INITIAL_DELAY_MS,
+  maxDelayMs = DEFAULT_MAX_DELAY_MS,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+}) {
+  if (interactionId == null || interactionId.length === 0) {
+    throw new Error(
+      "google.interactions: cannot poll a background interaction without an id. The POST response did not include an interaction id."
+    );
+  }
+  const startedAt = Date.now();
+  let nextDelayMs = initialDelayMs;
+  const url = `${baseURL}/interactions/${encodeURIComponent(interactionId)}`;
+  const cancelOnServer = () => cancelGoogleInteraction({ baseURL, interactionId, headers, fetch });
+  try {
+    while (true) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        await cancelOnServer();
+        throw new DOMException("Polling was aborted", "AbortError");
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(
+          `google.interactions: timed out polling interaction ${interactionId} after ${timeoutMs}ms.`
+        );
+      }
+      await delay(nextDelayMs, { abortSignal });
+      const {
+        value: response,
+        rawValue: rawResponse,
+        responseHeaders
+      } = await getFromApi({
+        url,
+        headers,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler3(
+          googleInteractionsResponseSchema
+        ),
+        abortSignal,
+        fetch
+      });
+      if (isTerminalStatus(response.status)) {
+        return { response, rawResponse, responseHeaders };
+      }
+      nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+    }
+  } catch (error) {
+    if (isAbortError(error)) {
+      await cancelOnServer();
+    }
+    throw error;
+  }
+}
+
+// src/interactions/prepare-google-interactions-tools.ts
+function prepareGoogleInteractionsTools({
+  tools,
+  toolChoice
+}) {
+  var _a, _b, _c, _d;
+  const toolWarnings = [];
+  const normalized = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  if (normalized == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const interactionsTools = [];
+  for (const tool of normalized) {
+    if (tool.type === "function") {
+      interactionsTools.push({
+        type: "function",
+        name: tool.name,
+        description: (_a = tool.description) != null ? _a : "",
+        parameters: tool.inputSchema
+      });
+      continue;
+    }
+    if (tool.type === "provider") {
+      const args = (_b = tool.args) != null ? _b : {};
+      switch (tool.id) {
+        case "google.google_search": {
+          const searchTypesArg = args.searchTypes;
+          let search_types;
+          if (searchTypesArg != null && typeof searchTypesArg === "object") {
+            const list = [];
+            if (searchTypesArg.webSearch != null) list.push("web_search");
+            if (searchTypesArg.imageSearch != null) list.push("image_search");
+            if (list.length > 0) {
+              search_types = list;
+            }
+          }
+          interactionsTools.push({
+            type: "google_search",
+            ...search_types != null ? { search_types } : {}
+          });
+          break;
+        }
+        case "google.code_execution": {
+          interactionsTools.push({ type: "code_execution" });
+          break;
+        }
+        case "google.url_context": {
+          interactionsTools.push({ type: "url_context" });
+          break;
+        }
+        case "google.file_search": {
+          interactionsTools.push({
+            type: "file_search",
+            ...args.fileSearchStoreNames != null ? {
+              file_search_store_names: args.fileSearchStoreNames
+            } : {},
+            ...args.topK != null ? { top_k: args.topK } : {},
+            ...args.metadataFilter != null ? { metadata_filter: args.metadataFilter } : {}
+          });
+          break;
+        }
+        case "google.google_maps": {
+          interactionsTools.push({
+            type: "google_maps",
+            ...args.latitude != null ? { latitude: args.latitude } : {},
+            ...args.longitude != null ? { longitude: args.longitude } : {},
+            ...args.enableWidget != null ? { enable_widget: args.enableWidget } : {}
+          });
+          break;
+        }
+        case "google.computer_use": {
+          interactionsTools.push({
+            type: "computer_use",
+            environment: (_c = args.environment) != null ? _c : "browser",
+            ...args.excludedPredefinedFunctions != null ? {
+              excludedPredefinedFunctions: args.excludedPredefinedFunctions
+            } : {}
+          });
+          break;
+        }
+        case "google.mcp_server": {
+          interactionsTools.push({
+            type: "mcp_server",
+            ...args.name != null ? { name: args.name } : {},
+            ...args.url != null ? { url: args.url } : {},
+            ...args.headers != null ? { headers: args.headers } : {},
+            ...args.allowedTools != null ? { allowed_tools: args.allowedTools } : {}
+          });
+          break;
+        }
+        case "google.retrieval": {
+          const vertexAiSearchConfig = (_d = args.vertexAiSearchConfig) != null ? _d : void 0;
+          interactionsTools.push({
+            type: "retrieval",
+            ...args.retrievalTypes != null ? {
+              retrieval_types: args.retrievalTypes
+            } : { retrieval_types: ["vertex_ai_search"] },
+            ...vertexAiSearchConfig != null ? { vertex_ai_search_config: vertexAiSearchConfig } : {}
+          });
+          break;
+        }
+        default: {
+          toolWarnings.push({
+            type: "unsupported",
+            feature: `provider-defined tool ${tool.id}`,
+            details: `provider-defined tool ${tool.id} is not supported by google.interactions; tool dropped.`
+          });
+          break;
+        }
+      }
+      continue;
+    }
+    toolWarnings.push({
+      type: "unsupported",
+      feature: `tool of type ${tool.type}`,
+      details: "Only function tools and google.* provider-defined tools are supported by google.interactions; tool dropped."
+    });
+  }
+  const hasFunctionTool = interactionsTools.some((t) => t.type === "function");
+  let mappedToolChoice;
+  if (toolChoice != null && hasFunctionTool) {
+    switch (toolChoice.type) {
+      case "auto":
+        mappedToolChoice = "auto";
+        break;
+      case "required":
+        mappedToolChoice = "any";
+        break;
+      case "none":
+        mappedToolChoice = "none";
+        break;
+      case "tool":
+        mappedToolChoice = {
+          allowed_tools: {
+            mode: "validated",
+            tools: [toolChoice.toolName]
+          }
+        };
+        break;
+    }
+  }
+  return {
+    tools: interactionsTools.length > 0 ? interactionsTools : void 0,
+    toolChoice: mappedToolChoice,
+    toolWarnings
+  };
+}
+
+// src/interactions/stream-google-interactions.ts
+import {
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  delay as delay2,
+  getFromApi as getFromApi2,
+  isAbortError as isAbortError2
+} from "@ai-sdk/provider-utils";
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 500;
+function streamGoogleInteractionEvents({
+  baseURL,
+  interactionId,
+  headers,
+  fetch,
+  abortSignal,
+  maxRetries = DEFAULT_MAX_RETRIES,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS
+}) {
+  if (interactionId.length === 0) {
+    throw new Error(
+      "google.interactions: cannot stream a background interaction without an id."
+    );
+  }
+  const eventSourceHeaders = {
+    ...headers,
+    accept: "text/event-stream"
+  };
+  let lastEventId;
+  let complete = false;
+  let attempt = 0;
+  let receivedAnyEventThisAttempt = false;
+  let currentReader;
+  const internalAbort = new AbortController();
+  const upstreamAbortHandler = () => internalAbort.abort();
+  if (abortSignal != null) {
+    if (abortSignal.aborted) {
+      internalAbort.abort();
+    } else {
+      abortSignal.addEventListener("abort", upstreamAbortHandler, {
+        once: true
+      });
+    }
+  }
+  const effectiveSignal = internalAbort.signal;
+  function buildUrl() {
+    const base = `${baseURL}/interactions/${encodeURIComponent(interactionId)}`;
+    const params = new URLSearchParams({ stream: "true" });
+    if (lastEventId != null) {
+      params.set("last_event_id", lastEventId);
+    }
+    return `${base}?${params.toString()}`;
+  }
+  async function openReader() {
+    const { value: stream } = await getFromApi2({
+      url: buildUrl(),
+      headers: eventSourceHeaders,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler2(
+        googleInteractionsEventSchema
+      ),
+      abortSignal: effectiveSignal,
+      fetch
+    });
+    return stream.getReader();
+  }
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        while (!complete && !effectiveSignal.aborted) {
+          if (currentReader == null) {
+            try {
+              currentReader = await openReader();
+              receivedAnyEventThisAttempt = false;
+            } catch (error) {
+              if (isAbortError2(error) || effectiveSignal.aborted) {
+                controller.error(error);
+                return;
+              }
+              attempt++;
+              if (attempt >= maxRetries) {
+                controller.error(error);
+                return;
+              }
+              await delay2(retryDelayMs * attempt, {
+                abortSignal: effectiveSignal
+              });
+              continue;
+            }
+          }
+          try {
+            const { done, value } = await currentReader.read();
+            if (done) {
+              currentReader = void 0;
+              if (complete) break;
+              if (!receivedAnyEventThisAttempt) {
+                attempt++;
+                if (attempt >= maxRetries) {
+                  controller.error(
+                    new Error(
+                      "google.interactions: SSE stream closed without producing any events."
+                    )
+                  );
+                  return;
+                }
+                await delay2(retryDelayMs * attempt, {
+                  abortSignal: effectiveSignal
+                });
+              } else {
+                attempt = 0;
+              }
+              continue;
+            }
+            receivedAnyEventThisAttempt = true;
+            if (value.success) {
+              const streamEvent = value.value;
+              if (typeof streamEvent.event_id === "string" && streamEvent.event_id.length > 0) {
+                lastEventId = streamEvent.event_id;
+              }
+              if (streamEvent.event_type === "interaction.completed" || streamEvent.event_type === "error") {
+                complete = true;
+              }
+            }
+            controller.enqueue(value);
+          } catch (error) {
+            if (isAbortError2(error) || effectiveSignal.aborted) {
+              controller.error(error);
+              return;
+            }
+            currentReader = void 0;
+            attempt++;
+            if (attempt >= maxRetries) {
+              controller.error(error);
+              return;
+            }
+            await delay2(retryDelayMs * attempt, {
+              abortSignal: effectiveSignal
+            });
+          }
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        if (abortSignal != null) {
+          abortSignal.removeEventListener("abort", upstreamAbortHandler);
+        }
+        currentReader == null ? void 0 : currentReader.cancel().catch(() => {
+        });
+        currentReader = void 0;
+        if (effectiveSignal.aborted && !complete) {
+          await cancelGoogleInteraction({
+            baseURL,
+            interactionId,
+            headers,
+            fetch
+          });
+        }
+      }
+    },
+    cancel() {
+      internalAbort.abort();
+      currentReader == null ? void 0 : currentReader.cancel().catch(() => {
+      });
+      currentReader = void 0;
+    }
+  });
+}
+
+// src/interactions/synthesize-google-interactions-agent-stream.ts
+function synthesizeGoogleInteractionsAgentStream({
+  response,
+  warnings,
+  generateId: generateId2,
+  includeRawChunks,
+  headerServiceTier
+}) {
+  return new ReadableStream({
+    start(controller) {
+      var _a, _b, _c;
+      controller.enqueue({ type: "stream-start", warnings });
+      const interactionId = typeof response.id === "string" && response.id.length > 0 ? response.id : void 0;
+      let timestamp;
+      const created = response.created;
+      if (typeof created === "string") {
+        const parsed = new Date(created);
+        if (!Number.isNaN(parsed.getTime())) {
+          timestamp = parsed;
+        }
+      }
+      controller.enqueue({
+        type: "response-metadata",
+        ...interactionId != null ? { id: interactionId } : {},
+        modelId: (_a = response.model) != null ? _a : void 0,
+        ...timestamp ? { timestamp } : {}
+      });
+      if (includeRawChunks) {
+        controller.enqueue({ type: "raw", rawValue: response });
+      }
+      const { content, hasFunctionCall } = parseGoogleInteractionsOutputs({
+        steps: (_b = response.steps) != null ? _b : null,
+        generateId: generateId2,
+        interactionId
+      });
+      let blockCounter = 0;
+      const nextBlockId = () => `${interactionId != null ? interactionId : "agent"}:${blockCounter++}`;
+      for (const part of content) {
+        switch (part.type) {
+          case "text": {
+            const id = nextBlockId();
+            const providerMetadata2 = part.providerMetadata;
+            controller.enqueue({ type: "text-start", id });
+            if (part.text.length > 0) {
+              controller.enqueue({ type: "text-delta", id, delta: part.text });
+            }
+            controller.enqueue({
+              type: "text-end",
+              id,
+              ...providerMetadata2 ? { providerMetadata: providerMetadata2 } : {}
+            });
+            break;
+          }
+          case "reasoning": {
+            const id = nextBlockId();
+            const providerMetadata2 = part.providerMetadata;
+            controller.enqueue({ type: "reasoning-start", id });
+            if (part.text.length > 0) {
+              controller.enqueue({
+                type: "reasoning-delta",
+                id,
+                delta: part.text
+              });
+            }
+            controller.enqueue({
+              type: "reasoning-end",
+              id,
+              ...providerMetadata2 ? { providerMetadata: providerMetadata2 } : {}
+            });
+            break;
+          }
+          case "tool-call": {
+            const providerMetadata2 = part.providerMetadata;
+            controller.enqueue({
+              type: "tool-input-start",
+              id: part.toolCallId,
+              toolName: part.toolName,
+              ...part.providerExecuted ? { providerExecuted: part.providerExecuted } : {}
+            });
+            controller.enqueue({
+              type: "tool-input-delta",
+              id: part.toolCallId,
+              delta: part.input
+            });
+            controller.enqueue({
+              type: "tool-input-end",
+              id: part.toolCallId
+            });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input,
+              ...part.providerExecuted ? { providerExecuted: part.providerExecuted } : {},
+              ...providerMetadata2 ? { providerMetadata: providerMetadata2 } : {}
+            });
+            break;
+          }
+          case "tool-result": {
+            controller.enqueue({
+              type: "tool-result",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              result: part.result
+            });
+            break;
+          }
+          case "source":
+          case "file": {
+            controller.enqueue(part);
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      const serviceTier = (_c = response.service_tier) != null ? _c : headerServiceTier;
+      const finishReason = {
+        unified: mapGoogleInteractionsFinishReason({
+          status: response.status,
+          hasFunctionCall
+        }),
+        raw: response.status
+      };
+      const providerMetadata = {
+        google: {
+          ...interactionId != null ? { interactionId } : {},
+          ...serviceTier != null ? { serviceTier } : {}
+        }
+      };
+      controller.enqueue({
+        type: "finish",
+        finishReason,
+        usage: convertGoogleInteractionsUsage(response.usage),
+        providerMetadata
+      });
+      controller.close();
+    }
+  });
+}
+
+// src/interactions/google-interactions-language-model.ts
+var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
+  constructor(modelOrAgent, config) {
+    this.specificationVersion = "v4";
+    if (typeof modelOrAgent === "string") {
+      this.modelId = modelOrAgent;
+      this.agent = void 0;
+    } else if ("managedAgent" in modelOrAgent) {
+      this.modelId = modelOrAgent.managedAgent;
+      this.agent = modelOrAgent.managedAgent;
+    } else {
+      this.modelId = modelOrAgent.agent;
+      this.agent = modelOrAgent.agent;
+    }
+    this.config = config;
+  }
+  static [WORKFLOW_SERIALIZE3](model) {
+    return {
+      ...serializeModelOptions3({
+        modelId: model.modelId,
+        config: model.config
+      }),
+      agent: model.agent
+    };
+  }
+  static [WORKFLOW_DESERIALIZE3](options) {
+    return new _GoogleInteractionsLanguageModel(
+      options.agent != null ? { agent: options.agent } : options.modelId,
+      options.config
+    );
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get supportedUrls() {
+    if (this.config.supportedUrls) {
+      return this.config.supportedUrls();
+    }
+    return {
+      "image/*": [/^https?:\/\/.+/],
+      "application/pdf": [/^https?:\/\/.+/],
+      "audio/*": [/^https?:\/\/.+/],
+      "video/*": [
+        /^https?:\/\/(www\.)?youtube\.com\/watch\?v=.+/,
+        /^https?:\/\/youtu\.be\/.+/,
+        /^gs:\/\/.+/
+      ]
+    };
+  }
+  async getArgs(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+    const warnings = [];
+    const googleOptions = await parseProviderOptions3({
+      provider: "google",
+      providerOptions: options.providerOptions,
+      schema: googleInteractionsLanguageModelOptions
+    });
+    const isAgent = this.agent != null;
+    const hasTools = options.tools != null && options.tools.length > 0;
+    let toolsForBody;
+    let toolChoiceForBody;
+    if (hasTools && isAgent) {
+      warnings.push({
+        type: "other",
+        message: "google.interactions: tools are not supported when an agent is set; tools will be omitted from the request body."
+      });
+    } else if (hasTools) {
+      const prepared = prepareGoogleInteractionsTools({
+        tools: options.tools,
+        toolChoice: options.toolChoice
+      });
+      toolsForBody = prepared.tools;
+      toolChoiceForBody = prepared.toolChoice;
+      warnings.push(...prepared.toolWarnings);
+    }
+    const responseFormatEntries = [];
+    if (((_a = options.responseFormat) == null ? void 0 : _a.type) === "json") {
+      if (isAgent) {
+        warnings.push({
+          type: "other",
+          message: "google.interactions: structured output (responseFormat) is not supported when an agent is set; responseFormat will be ignored."
+        });
+      } else {
+        const entry = {
+          type: "text",
+          mime_type: "application/json",
+          ...options.responseFormat.schema != null ? { schema: options.responseFormat.schema } : {}
+        };
+        responseFormatEntries.push(entry);
+      }
+    }
+    if ((googleOptions == null ? void 0 : googleOptions.responseFormat) != null) {
+      for (const entry of googleOptions.responseFormat) {
+        if (entry.type === "text") {
+          responseFormatEntries.push(
+            pruneUndefined({
+              type: "text",
+              mime_type: (_b = entry.mimeType) != null ? _b : void 0,
+              schema: (_c = entry.schema) != null ? _c : void 0
+            })
+          );
+        } else if (entry.type === "image") {
+          responseFormatEntries.push(
+            pruneUndefined({
+              type: "image",
+              mime_type: (_d = entry.mimeType) != null ? _d : void 0,
+              aspect_ratio: (_e = entry.aspectRatio) != null ? _e : void 0,
+              image_size: (_f = entry.imageSize) != null ? _f : void 0
+            })
+          );
+        } else if (entry.type === "audio") {
+          responseFormatEntries.push(
+            pruneUndefined({
+              type: "audio",
+              mime_type: (_g = entry.mimeType) != null ? _g : void 0
+            })
+          );
+        }
+      }
+    }
+    const {
+      input,
+      systemInstruction: convertedSystemInstruction,
+      warnings: convWarnings
+    } = convertToGoogleInteractionsInput({
+      prompt: options.prompt,
+      previousInteractionId: (_h = googleOptions == null ? void 0 : googleOptions.previousInteractionId) != null ? _h : void 0,
+      store: (_i = googleOptions == null ? void 0 : googleOptions.store) != null ? _i : void 0,
+      mediaResolution: (_j = googleOptions == null ? void 0 : googleOptions.mediaResolution) != null ? _j : void 0
+    });
+    warnings.push(...convWarnings);
+    let systemInstruction = convertedSystemInstruction;
+    const optionSystemInstruction = (_k = googleOptions == null ? void 0 : googleOptions.systemInstruction) != null ? _k : void 0;
+    if (systemInstruction != null && optionSystemInstruction != null) {
+      warnings.push({
+        type: "other",
+        message: "google.interactions: both AI SDK system message and providerOptions.google.systemInstruction were set; using the AI SDK system message."
+      });
+    } else if (systemInstruction == null && optionSystemInstruction != null) {
+      systemInstruction = optionSystemInstruction;
+    }
+    let generationConfig;
+    if (isAgent) {
+      const droppedFields = [];
+      if (options.temperature != null) droppedFields.push("temperature");
+      if (options.topP != null) droppedFields.push("topP");
+      if (options.seed != null) droppedFields.push("seed");
+      if (options.stopSequences != null && options.stopSequences.length > 0) {
+        droppedFields.push("stopSequences");
+      }
+      if (options.maxOutputTokens != null)
+        droppedFields.push("maxOutputTokens");
+      if ((googleOptions == null ? void 0 : googleOptions.thinkingLevel) != null)
+        droppedFields.push("thinkingLevel");
+      if ((googleOptions == null ? void 0 : googleOptions.thinkingSummaries) != null) {
+        droppedFields.push("thinkingSummaries");
+      }
+      if ((googleOptions == null ? void 0 : googleOptions.imageConfig) != null) droppedFields.push("imageConfig");
+      if (droppedFields.length > 0) {
+        warnings.push({
+          type: "other",
+          message: `google.interactions: ${droppedFields.join(", ")} ${droppedFields.length === 1 ? "is" : "are"} not supported when an agent is set; use providerOptions.google.agentConfig instead. Dropped from the request body.`
+        });
+      }
+      generationConfig = void 0;
+    } else {
+      generationConfig = pruneUndefined({
+        temperature: (_l = options.temperature) != null ? _l : void 0,
+        top_p: (_m = options.topP) != null ? _m : void 0,
+        seed: (_n = options.seed) != null ? _n : void 0,
+        stop_sequences: options.stopSequences != null && options.stopSequences.length > 0 ? options.stopSequences : void 0,
+        max_output_tokens: (_o = options.maxOutputTokens) != null ? _o : void 0,
+        thinking_level: (_p = googleOptions == null ? void 0 : googleOptions.thinkingLevel) != null ? _p : void 0,
+        thinking_summaries: (_q = googleOptions == null ? void 0 : googleOptions.thinkingSummaries) != null ? _q : void 0,
+        tool_choice: toolChoiceForBody
+      });
+      if ((googleOptions == null ? void 0 : googleOptions.imageConfig) != null) {
+        const alreadyHasImageEntry = responseFormatEntries.some(
+          (entry) => entry.type === "image"
+        );
+        warnings.push({
+          type: "other",
+          message: alreadyHasImageEntry ? "google.interactions: providerOptions.google.imageConfig is deprecated and was ignored because providerOptions.google.responseFormat already supplies an image entry. Use responseFormat exclusively." : 'google.interactions: providerOptions.google.imageConfig is deprecated. Use providerOptions.google.responseFormat with a { type: "image", ... } entry instead.'
+        });
+        if (!alreadyHasImageEntry) {
+          responseFormatEntries.push({
+            type: "image",
+            mime_type: "image/png",
+            ...googleOptions.imageConfig.aspectRatio != null ? { aspect_ratio: googleOptions.imageConfig.aspectRatio } : {},
+            ...googleOptions.imageConfig.imageSize != null ? { image_size: googleOptions.imageConfig.imageSize } : {}
+          });
+        }
+      }
+    }
+    let agentConfig;
+    if (isAgent && (googleOptions == null ? void 0 : googleOptions.agentConfig) != null) {
+      const agentConfigOptions = googleOptions.agentConfig;
+      if (agentConfigOptions.type === "deep-research") {
+        agentConfig = pruneUndefined({
+          type: "deep-research",
+          thinking_summaries: (_r = agentConfigOptions.thinkingSummaries) != null ? _r : void 0,
+          visualization: (_s = agentConfigOptions.visualization) != null ? _s : void 0,
+          collaborative_planning: (_t = agentConfigOptions.collaborativePlanning) != null ? _t : void 0
+        });
+      } else if (agentConfigOptions.type === "dynamic") {
+        agentConfig = { type: "dynamic" };
+      }
+    }
+    let environment;
+    if ((googleOptions == null ? void 0 : googleOptions.environment) != null) {
+      if (!isAgent) {
+        warnings.push({
+          type: "other",
+          message: "google.interactions: environment is only supported when an agent is set; environment will be omitted from the request body."
+        });
+      } else if (typeof googleOptions.environment === "string") {
+        environment = googleOptions.environment;
+      } else {
+        const environmentOptions = googleOptions.environment;
+        const sources = (_u = environmentOptions.sources) == null ? void 0 : _u.map((source) => {
+          var _a2;
+          if (source.type === "inline") {
+            return {
+              type: "inline",
+              content: source.content,
+              target: source.target
+            };
+          }
+          return pruneUndefined({
+            type: source.type,
+            source: source.source,
+            target: (_a2 = source.target) != null ? _a2 : void 0
+          });
+        });
+        let network;
+        if (environmentOptions.network === "disabled") {
+          network = "disabled";
+        } else if (environmentOptions.network != null) {
+          network = {
+            allowlist: environmentOptions.network.allowlist.map(
+              (entry) => {
+                var _a2;
+                return pruneUndefined({
+                  domain: entry.domain,
+                  transform: (_a2 = entry.transform) != null ? _a2 : void 0
+                });
+              }
+            )
+          };
+        }
+        environment = pruneUndefined({
+          type: "remote",
+          sources: sources != null && sources.length > 0 ? sources : void 0,
+          network
+        });
+      }
+    }
+    const args = pruneUndefined({
+      ...isAgent ? { agent: this.agent } : { model: this.modelId },
+      input,
+      system_instruction: systemInstruction,
+      tools: toolsForBody,
+      response_format: responseFormatEntries.length > 0 ? responseFormatEntries : void 0,
+      response_modalities: (googleOptions == null ? void 0 : googleOptions.responseModalities) != null ? googleOptions.responseModalities : void 0,
+      previous_interaction_id: (_v = googleOptions == null ? void 0 : googleOptions.previousInteractionId) != null ? _v : void 0,
+      service_tier: (_w = googleOptions == null ? void 0 : googleOptions.serviceTier) != null ? _w : void 0,
+      store: (_x = googleOptions == null ? void 0 : googleOptions.store) != null ? _x : void 0,
+      generation_config: generationConfig != null && Object.keys(generationConfig).length > 0 ? generationConfig : void 0,
+      agent_config: agentConfig,
+      environment,
+      background: (_y = googleOptions == null ? void 0 : googleOptions.background) != null ? _y : void 0
+    });
+    return {
+      args,
+      warnings,
+      isAgent,
+      isBackground: (googleOptions == null ? void 0 : googleOptions.background) === true,
+      pollingTimeoutMs: (_z = googleOptions == null ? void 0 : googleOptions.pollingTimeoutMs) != null ? _z : void 0
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
+    const url = `${this.config.baseURL}/interactions`;
+    const mergedHeaders = combineHeaders4(
+      this.config.headers ? await resolve3(this.config.headers) : void 0,
+      options.headers
+    );
+    const postResult = await postJsonToApi3({
+      url,
+      headers: mergedHeaders,
+      body: args,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler4(
+        googleInteractionsResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = postResult;
+    if (isAgent && !isTerminalStatus(response.status)) {
+      const polled = await pollGoogleInteractionUntilTerminal({
+        baseURL: this.config.baseURL,
+        interactionId: response.id,
+        headers: mergedHeaders,
+        fetch: this.config.fetch,
+        abortSignal: options.abortSignal,
+        timeoutMs: pollingTimeoutMs
+      });
+      response = polled.response;
+      rawResponse = polled.rawResponse;
+      responseHeaders = (_a = polled.responseHeaders) != null ? _a : responseHeaders;
+    }
+    const interactionId = typeof response.id === "string" && response.id.length > 0 ? response.id : void 0;
+    const { content, hasFunctionCall } = parseGoogleInteractionsOutputs({
+      steps: (_b = response.steps) != null ? _b : null,
+      generateId: (_c = this.config.generateId) != null ? _c : defaultGenerateId,
+      interactionId
+    });
+    const finishReason = {
+      unified: mapGoogleInteractionsFinishReason({
+        status: response.status,
+        hasFunctionCall
+      }),
+      raw: response.status
+    };
+    const serviceTier = (_e = (_d = response.service_tier) != null ? _d : responseHeaders == null ? void 0 : responseHeaders["x-gemini-service-tier"]) != null ? _e : void 0;
+    const outputTokensByModality = getGoogleInteractionsOutputTokensByModality(
+      response.usage
+    );
+    const providerMetadata = {
+      google: {
+        ...interactionId != null ? { interactionId } : {},
+        ...serviceTier != null ? { serviceTier } : {},
+        ...outputTokensByModality != null ? { outputTokensByModality } : {}
+      }
+    };
+    let timestamp;
+    if (typeof response.created === "string") {
+      const parsed = new Date(response.created);
+      if (!Number.isNaN(parsed.getTime())) {
+        timestamp = parsed;
+      }
+    }
+    return {
+      content,
+      finishReason,
+      usage: convertGoogleInteractionsUsage(response.usage),
+      warnings,
+      providerMetadata,
+      request: { body: args },
+      response: {
+        headers: responseHeaders,
+        body: rawResponse,
+        ...interactionId != null ? { id: interactionId } : {},
+        ...timestamp ? { timestamp } : {},
+        modelId: (_f = response.model) != null ? _f : void 0
+      }
+    };
+  }
+  async doStream(options) {
+    var _a;
+    const { args, warnings, isBackground, pollingTimeoutMs } = await this.getArgs(options);
+    const url = `${this.config.baseURL}/interactions`;
+    const mergedHeaders = combineHeaders4(
+      this.config.headers ? await resolve3(this.config.headers) : void 0,
+      options.headers
+    );
+    if (isBackground) {
+      return this.doStreamBackground({
+        args,
+        warnings,
+        url,
+        mergedHeaders,
+        options,
+        pollingTimeoutMs
+      });
+    }
+    const body = { ...args, stream: true };
+    const { responseHeaders, value: response } = await postJsonToApi3({
+      url,
+      headers: mergedHeaders,
+      body,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler3(
+        googleInteractionsEventSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const headerServiceTier = responseHeaders == null ? void 0 : responseHeaders["x-gemini-service-tier"];
+    const transform = buildGoogleInteractionsStreamTransform({
+      warnings,
+      generateId: (_a = this.config.generateId) != null ? _a : defaultGenerateId,
+      includeRawChunks: options.includeRawChunks,
+      serviceTier: headerServiceTier
+    });
+    return {
+      stream: response.pipeThrough(transform),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+  /*
+   * Drive the streaming surface for agent calls. Agents require
+   * `background: true`, which is incompatible with `stream: true` on POST.
+   *
+   * Approach:
+   *   1. POST `/interactions` with `background: true`. The response includes
+   *      the interaction id and an initial (usually non-terminal) status.
+   *   2. If the POST status is already terminal (rare), synthesize a stream
+   *      from the polled outputs and we're done.
+   *   3. Otherwise open `GET /interactions/{id}?stream=true` and pipe the
+   *      SSE events through `buildGoogleInteractionsStreamTransform` so the
+   *      consumer receives text deltas / thinking summaries / tool events as
+   *      they happen instead of all at once at the end.
+   *
+   * The SSE connection can drop while the agent idles between events
+   * (`UND_ERR_BODY_TIMEOUT`); `streamGoogleInteractionEvents` handles the
+   * reconnect-with-`last_event_id` loop transparently.
+   */
+  async doStreamBackground({
+    args,
+    warnings,
+    url,
+    mergedHeaders,
+    options,
+    pollingTimeoutMs
+  }) {
+    var _a, _b;
+    const postResult = await postJsonToApi3({
+      url,
+      headers: mergedHeaders,
+      body: args,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler4(
+        googleInteractionsResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { responseHeaders: postHeaders, value: postResponse } = postResult;
+    const interactionId = postResponse.id;
+    if (interactionId == null || interactionId.length === 0) {
+      throw new Error(
+        "google.interactions: background POST response did not include an interaction id; cannot stream the result."
+      );
+    }
+    const headerServiceTier = postHeaders == null ? void 0 : postHeaders["x-gemini-service-tier"];
+    if (isTerminalStatus(postResponse.status)) {
+      const synthesized = synthesizeGoogleInteractionsAgentStream({
+        response: postResponse,
+        warnings,
+        generateId: (_a = this.config.generateId) != null ? _a : defaultGenerateId,
+        includeRawChunks: options.includeRawChunks,
+        headerServiceTier
+      });
+      return {
+        stream: synthesized,
+        request: { body: args },
+        response: { headers: postHeaders }
+      };
+    }
+    void pollingTimeoutMs;
+    const events = streamGoogleInteractionEvents({
+      baseURL: this.config.baseURL,
+      interactionId,
+      headers: mergedHeaders,
+      fetch: this.config.fetch,
+      abortSignal: options.abortSignal
+    });
+    const transform = buildGoogleInteractionsStreamTransform({
+      warnings,
+      generateId: (_b = this.config.generateId) != null ? _b : defaultGenerateId,
+      includeRawChunks: options.includeRawChunks,
+      serviceTier: headerServiceTier
+    });
+    return {
+      stream: events.pipeThrough(transform),
+      request: { body: args },
+      response: { headers: postHeaders }
+    };
+  }
+};
+function pruneUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    result[key] = value;
+  }
+  return result;
+}
 export {
+  GoogleInteractionsLanguageModel,
   GoogleLanguageModel,
   GoogleSpeechModel,
   getGroundingMetadataSchema,