@ai-sdk/google 3.0.67 → 3.0.68

package/dist/index.js

@@ -27,10 +27,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/google-provider.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "3.0.67" : "0.0.0-test";
+var VERSION = true ? "3.0.68" : "0.0.0-test";
 
 // src/google-generative-ai-embedding-model.ts
 var import_provider = require("@ai-sdk/provider");
@@ -2995,55 +2995,2375 @@ var googleVideoModelOptionsSchema = (0, import_provider_utils15.lazySchema)(
   )
 );
 
-// src/google-provider.ts
-function createGoogleGenerativeAI(options = {}) {
-  var _a, _b;
-  const baseURL = (_a = (0, import_provider_utils16.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
-  const providerName = (_b = options.name) != null ? _b : "google.generative-ai";
-  const getHeaders = () => (0, import_provider_utils16.withUserAgentSuffix)(
-    {
-      "x-goog-api-key": (0, import_provider_utils16.loadApiKey)({
-        apiKey: options.apiKey,
-        environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
-        description: "Google Generative AI"
-      }),
-      ...options.headers
+// src/interactions/google-interactions-language-model.ts
+var import_provider_utils20 = require("@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
     },
-    `ai-sdk/google/${VERSION}`
-  );
-  const createChatModel = (modelId) => {
-    var _a2;
-    return new GoogleGenerativeAILanguageModel(modelId, {
-      provider: providerName,
-      baseURL,
-      headers: getHeaders,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils16.generateId,
-      supportedUrls: () => ({
-        "*": [
-          // Google Generative Language "files" endpoint
-          // e.g. https://generativelanguage.googleapis.com/v1beta/files/...
-          new RegExp(`^${baseURL}/files/.*$`),
-          // YouTube URLs (public or unlisted videos)
-          new RegExp(
-            `^https://(?:www\\.)?youtube\\.com/watch\\?v=[\\w-]+(?:&[\\w=&.-]*)?$`
-          ),
-          new RegExp(`^https://youtu\\.be/[\\w-]+(?:\\?[\\w=&.-]*)?$`)
-        ]
-      }),
-      fetch: options.fetch
-    });
+    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
   };
-  const createEmbeddingModel = (modelId) => new GoogleGenerativeAIEmbeddingModel(modelId, {
-    provider: providerName,
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
+}
+
+// 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: generateId3
+}) {
+  var _a, _b, _c, _d, _e;
+  switch (annotation.type) {
+    case "url_citation": {
+      const a = annotation;
+      if (a.url == null || a.url.length === 0) return void 0;
+      return {
+        type: "source",
+        sourceType: "url",
+        id: generateId3(),
+        url: a.url,
+        ...a.title != null ? { title: a.title } : {}
+      };
+    }
+    case "file_citation": {
+      const a = annotation;
+      const uri = (_b = (_a = a.document_uri) != null ? _a : a.source) != null ? _b : a.file_name;
+      if (uri == null || uri.length === 0) return void 0;
+      if (uri.startsWith("http://") || uri.startsWith("https://")) {
+        return {
+          type: "source",
+          sourceType: "url",
+          id: generateId3(),
+          url: uri,
+          ...a.file_name != null ? { title: a.file_name } : {}
+        };
+      }
+      const filename = (_c = a.file_name) != null ? _c : basename(uri);
+      const mediaType = inferDocMediaType(uri);
+      return {
+        type: "source",
+        sourceType: "document",
+        id: generateId3(),
+        mediaType,
+        title: (_e = (_d = a.file_name) != null ? _d : filename) != null ? _e : uri,
+        ...filename != null ? { filename } : {}
+      };
+    }
+    case "place_citation": {
+      const a = annotation;
+      if (a.url == null || a.url.length === 0) return void 0;
+      return {
+        type: "source",
+        sourceType: "url",
+        id: generateId3(),
+        url: a.url,
+        ...a.name != null ? { title: a.name } : {}
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function builtinToolResultToSources({
+  block,
+  generateId: generateId3
+}) {
+  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: generateId3(),
+          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: generateId3(),
+          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: generateId3(),
+            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.document_uri) != null ? _f : entry.source) != 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: generateId3(),
+            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: generateId3(),
+          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: generateId3
+}) {
+  var _a;
+  if (annotations == null) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const annotation of annotations) {
+    const source = annotationToSource({ annotation, generateId: generateId3 });
+    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: generateId3,
+  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;
+      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.start": {
+          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 "content.start": {
+          const event = value;
+          const block = event.content;
+          const index = event.index;
+          const blockId = `${interactionId != null ? interactionId : "interaction"}:${index}`;
+          if ((block == null ? void 0 : block.type) === "text") {
+            openBlocks.set(index, {
+              kind: "text",
+              id: blockId,
+              emittedSourceKeys: /* @__PURE__ */ new Set()
+            });
+            controller.enqueue({ type: "text-start", id: blockId });
+            const initialSources = annotationsToSources({
+              annotations: block.annotations,
+              generateId: generateId3
+            });
+            for (const source of initialSources) {
+              const key = sourceKey(source);
+              if (emittedSourceKeys.has(key)) continue;
+              emittedSourceKeys.add(key);
+              controller.enqueue(source);
+            }
+          } else if ((block == null ? void 0 : block.type) === "image") {
+            const img = block;
+            openBlocks.set(index, {
+              kind: "image",
+              id: blockId,
+              ...img.data != null ? { data: img.data } : {},
+              ...img.mime_type != null ? { mimeType: img.mime_type } : {},
+              ...img.uri != null ? { uri: img.uri } : {}
+            });
+          } else if ((block == null ? void 0 : block.type) === "thought") {
+            const signature = block.signature;
+            openBlocks.set(index, {
+              kind: "reasoning",
+              id: blockId,
+              ...signature != null ? { signature } : {}
+            });
+            controller.enqueue({ type: "reasoning-start", id: blockId });
+          } else if ((block == null ? void 0 : block.type) === "function_call") {
+            const fc = block;
+            const toolCallId = (_a = fc.id) != null ? _a : blockId;
+            hasFunctionCall = true;
+            const state = {
+              kind: "function_call",
+              id: blockId,
+              toolCallId,
+              toolName: fc.name,
+              arguments: (_b = fc.arguments) != null ? _b : {},
+              ...fc.signature != null ? { signature: fc.signature } : {},
+              startEmitted: false
+            };
+            openBlocks.set(index, state);
+            if (state.toolName != null) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: toolCallId,
+                toolName: state.toolName
+              });
+              state.startEmitted = true;
+            }
+          } else if ((block == null ? void 0 : block.type) != null && BUILTIN_TOOL_CALL_TYPES.has(block.type)) {
+            const toolName = block.type === "mcp_server_tool_call" ? (_c = block.name) != null ? _c : "mcp_server_tool" : builtinToolNameFromCallType(block.type);
+            const toolCallId = (_d = block.id) != null ? _d : blockId;
+            const state = {
+              kind: "builtin_tool_call",
+              id: blockId,
+              blockType: block.type,
+              toolCallId,
+              toolName,
+              arguments: (_e = block.arguments) != null ? _e : {},
+              callEmitted: false
+            };
+            openBlocks.set(index, state);
+          } else if ((block == null ? void 0 : block.type) != null && BUILTIN_TOOL_RESULT_TYPES.has(block.type)) {
+            const toolName = block.type === "mcp_server_tool_result" ? (_f = block.name) != null ? _f : "mcp_server_tool" : builtinToolNameFromResultType(block.type);
+            const callId = (_g = block.call_id) != null ? _g : blockId;
+            const state = {
+              kind: "builtin_tool_result",
+              id: blockId,
+              blockType: block.type,
+              callId,
+              toolName,
+              result: (_h = block.result) != null ? _h : null,
+              ...block.is_error != null ? { isError: block.is_error } : {},
+              resultEmitted: false
+            };
+            openBlocks.set(index, state);
+          } else {
+            openBlocks.set(index, { kind: "unknown", id: blockId });
+          }
+          break;
+        }
+        case "content.delta": {
+          const event = value;
+          const open = openBlocks.get(event.index);
+          if (open == null) break;
+          const delta = event.delta;
+          if (open.kind === "text" && (delta == null ? void 0 : delta.type) === "text") {
+            const text = (_i = delta.text) != null ? _i : "";
+            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") {
+            const sources = annotationsToSources({
+              annotations: delta.annotations,
+              generateId: generateId3
+            });
+            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) === "function_call") {
+            if (delta.id != null) {
+              open.toolCallId = delta.id;
+            }
+            if (delta.name != null) {
+              open.toolName = delta.name;
+            }
+            if (delta.arguments != null) {
+              open.arguments = delta.arguments;
+            }
+            if (delta.signature != null) {
+              open.signature = delta.signature;
+            }
+            if (!open.startEmitted && open.toolName != null) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: open.toolCallId,
+                toolName: open.toolName
+              });
+              open.startEmitted = true;
+            }
+            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) 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 "content.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 google2 = {};
+            if (open.signature != null) google2.signature = open.signature;
+            if (interactionId != null) google2.interactionId = interactionId;
+            const providerMetadata = Object.keys(google2).length > 0 ? { google: google2 } : void 0;
+            controller.enqueue({
+              type: "reasoning-end",
+              id: open.id,
+              ...providerMetadata ? { providerMetadata } : {}
+            });
+          } else if (open.kind === "image") {
+            const google2 = {};
+            if (interactionId != null) google2.interactionId = interactionId;
+            const providerMetadata = Object.keys(google2).length > 0 ? { google: google2 } : void 0;
+            if (open.data != null && open.data.length > 0) {
+              controller.enqueue({
+                type: "file",
+                mediaType: (_j = open.mimeType) != null ? _j : "image/png",
+                data: open.data,
+                ...providerMetadata ? { providerMetadata } : {}
+              });
+            } else if (open.uri != null && open.uri.length > 0) {
+              const uriProviderMetadata = {
+                google: {
+                  ...interactionId != null ? { interactionId } : {},
+                  imageUri: open.uri
+                }
+              };
+              controller.enqueue({
+                type: "file",
+                mediaType: (_k = open.mimeType) != null ? _k : "image/png",
+                data: "",
+                providerMetadata: uriProviderMetadata
+              });
+            }
+          } else if (open.kind === "function_call") {
+            const toolName = (_l = open.toolName) != null ? _l : "unknown";
+            const argsJson = JSON.stringify((_m = open.arguments) != null ? _m : {});
+            if (!open.startEmitted) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: open.toolCallId,
+                toolName
+              });
+            }
+            controller.enqueue({
+              type: "tool-input-delta",
+              id: open.toolCallId,
+              delta: argsJson
+            });
+            controller.enqueue({
+              type: "tool-input-end",
+              id: open.toolCallId
+            });
+            const google2 = {};
+            if (open.signature != null) google2.signature = open.signature;
+            if (interactionId != null) google2.interactionId = interactionId;
+            const providerMetadata = Object.keys(google2).length > 0 ? { google: google2 } : void 0;
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: open.toolCallId,
+              toolName,
+              input: argsJson,
+              ...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((_n = open.arguments) != null ? _n : {}),
+              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: (_o = open.result) != null ? _o : null
+            });
+            open.resultEmitted = true;
+            const sources = builtinToolResultToSources({
+              block: {
+                type: open.blockType,
+                call_id: open.callId,
+                result: open.result
+              },
+              generateId: generateId3
+            });
+            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": {
+          const event = value;
+          finishStatus = event.status;
+          break;
+        }
+        case "interaction.complete": {
+          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 = (_p = event.error) != null ? _p : {
+            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 providerMetadata = {
+        google: {
+          ...interactionId != null ? { interactionId } : {},
+          ...serviceTier != null ? { serviceTier } : {}
+        }
+      };
+      controller.enqueue({
+        type: "finish",
+        finishReason,
+        usage: convertGoogleInteractionsUsage(usage),
+        providerMetadata
+      });
+    }
   });
-  const createImageModel = (modelId, settings = {}) => new GoogleGenerativeAIImageModel(modelId, settings, {
-    provider: providerName,
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
+}
+
+// src/interactions/convert-to-google-interactions-input.ts
+var import_provider_utils16 = require("@ai-sdk/provider-utils");
+function getTopLevelMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
+}
+function isFullMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  if (slashIndex === -1) {
+    return false;
+  }
+  const subtype = mediaType.substring(slashIndex + 1);
+  return subtype.length > 0 && subtype !== "*";
+}
+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 turns = [];
+  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") {
+            const block = {
+              type: "text",
+              text: part.text
+            };
+            content.push(block);
+          } 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) {
+          turns.push({ role: "user", content: merged });
+        }
+        break;
+      }
+      case "assistant": {
+        const content = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "reasoning") {
+            const signature = (_b = (_a = part.providerOptions) == null ? void 0 : _a.google) == null ? void 0 : _b.signature;
+            content.push({
+              type: "thought",
+              ...signature != null ? { signature } : {},
+              summary: part.text.length > 0 ? [{ type: "text", text: part.text }] : void 0
+            });
+          } else if (part.type === "tool-call") {
+            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 : {};
+            content.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.`
+            });
+          }
+        }
+        if (content.length > 0) {
+          turns.push({ role: "model", content });
+        }
+        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) {
+          turns.push({ role: "user", content });
+        }
+        break;
+      }
+    }
+  }
+  const systemInstruction = systemTexts.length > 0 ? systemTexts.join("\n\n") : void 0;
+  let input;
+  if (turns.length === 0) {
+    input = "";
+  } else if (turns.length === 1 && turns[0].role === "user" && Array.isArray(turns[0].content)) {
+    input = turns[0].content;
+  } else {
+    input = turns;
+  }
+  return { input, systemInstruction, warnings };
+}
+function convertFilePartToContent({
+  part,
+  warnings,
+  mediaResolution
+}) {
+  const topLevel = getTopLevelMediaType(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 } : {};
+  if (part.data instanceof URL) {
+    return {
+      type: kind,
+      uri: part.data.toString(),
+      ...isFullMediaType(part.mediaType) ? { mime_type: part.mediaType } : {},
+      ...resolutionField
+    };
+  }
+  if (!isFullMediaType(part.mediaType)) {
+    warnings.push({
+      type: "other",
+      message: `google.interactions: inline file data requires a full IANA media type (e.g. "image/png"), got "${part.mediaType}"; part dropped.`
+    });
+    return void 0;
+  }
+  return {
+    type: kind,
+    data: (0, import_provider_utils16.convertToBase64)(part.data),
+    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 === "image-data") {
+          const imageBlock = filePartToImageBlock({
+            part: {
+              type: "file",
+              mediaType: item.mediaType,
+              data: item.data
+            },
+            warnings
+          });
+          if (imageBlock != null) {
+            blocks.push(imageBlock);
+          }
+        } else if (item.type === "image-url") {
+          const imageBlock = filePartToImageBlock({
+            part: {
+              type: "file",
+              mediaType: "image/*",
+              data: new URL(item.url)
+            },
+            warnings
+          });
+          if (imageBlock != null) {
+            blocks.push(imageBlock);
+          }
+        } else if (item.type === "file-data" || item.type === "file-url") {
+          const mediaType = item.type === "file-data" ? item.mediaType : "application/*";
+          const topLevel = getTopLevelMediaType(mediaType);
+          if (topLevel !== "image") {
+            warnings.push({
+              type: "other",
+              message: `google.interactions: tool-result file with mediaType "${mediaType}" is not supported (Interactions \`function_result.result\` accepts only text and image content); part dropped.`
+            });
+            continue;
+          }
+          const imageBlock = filePartToImageBlock({
+            part: item.type === "file-data" ? {
+              type: "file",
+              mediaType: item.mediaType,
+              data: item.data
+            } : {
+              type: "file",
+              mediaType,
+              data: new URL(item.url)
+            },
+            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
+}) {
+  if (part.data instanceof URL) {
+    return {
+      type: "image",
+      uri: part.data.toString(),
+      ...isFullMediaType(part.mediaType) ? { mime_type: part.mediaType } : {}
+    };
+  }
+  if (!isFullMediaType(part.mediaType)) {
+    warnings.push({
+      type: "other",
+      message: `google.interactions: tool-result image part requires a full IANA media type (e.g. "image/png"), got "${part.mediaType}"; part dropped.`
+    });
+    return void 0;
+  }
+  return {
+    type: "image",
+    data: (0, import_provider_utils16.convertToBase64)(part.data),
+    mime_type: part.mediaType
+  };
+}
+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
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
+var import_v415 = require("zod/v4");
+var tokenByModalitySchema = () => import_v415.z.object({
+  modality: import_v415.z.string().nullish(),
+  tokens: import_v415.z.number().nullish()
+}).loose();
+var usageSchema2 = () => import_v415.z.object({
+  total_input_tokens: import_v415.z.number().nullish(),
+  total_output_tokens: import_v415.z.number().nullish(),
+  total_thought_tokens: import_v415.z.number().nullish(),
+  total_cached_tokens: import_v415.z.number().nullish(),
+  total_tool_use_tokens: import_v415.z.number().nullish(),
+  total_tokens: import_v415.z.number().nullish(),
+  input_tokens_by_modality: import_v415.z.array(tokenByModalitySchema()).nullish(),
+  output_tokens_by_modality: import_v415.z.array(tokenByModalitySchema()).nullish(),
+  cached_tokens_by_modality: import_v415.z.array(tokenByModalitySchema()).nullish(),
+  tool_use_tokens_by_modality: import_v415.z.array(tokenByModalitySchema()).nullish(),
+  grounding_tool_count: import_v415.z.array(
+    import_v415.z.object({
+      type: import_v415.z.string().nullish(),
+      count: import_v415.z.number().nullish()
+    }).loose()
+  ).nullish()
+}).loose();
+var interactionStatusSchema = () => import_v415.z.enum([
+  "in_progress",
+  "requires_action",
+  "completed",
+  "failed",
+  "cancelled",
+  "incomplete"
+]);
+var annotationSchema = () => {
+  const urlCitation = import_v415.z.object({
+    type: import_v415.z.literal("url_citation"),
+    url: import_v415.z.string().nullish(),
+    title: import_v415.z.string().nullish(),
+    start_index: import_v415.z.number().nullish(),
+    end_index: import_v415.z.number().nullish()
+  }).loose();
+  const fileCitation = import_v415.z.object({
+    type: import_v415.z.literal("file_citation"),
+    file_name: import_v415.z.string().nullish(),
+    document_uri: import_v415.z.string().nullish(),
+    source: import_v415.z.string().nullish(),
+    page_number: import_v415.z.number().nullish(),
+    media_id: import_v415.z.string().nullish(),
+    start_index: import_v415.z.number().nullish(),
+    end_index: import_v415.z.number().nullish(),
+    custom_metadata: import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()).nullish()
+  }).loose();
+  const placeCitation = import_v415.z.object({
+    type: import_v415.z.literal("place_citation"),
+    name: import_v415.z.string().nullish(),
+    url: import_v415.z.string().nullish(),
+    place_id: import_v415.z.string().nullish(),
+    start_index: import_v415.z.number().nullish(),
+    end_index: import_v415.z.number().nullish()
+  }).loose();
+  return import_v415.z.union([
+    urlCitation,
+    fileCitation,
+    placeCitation,
+    import_v415.z.object({ type: import_v415.z.string() }).loose()
+  ]);
+};
+var thoughtSummaryItemSchema = () => import_v415.z.object({
+  type: import_v415.z.string(),
+  text: import_v415.z.string().nullish(),
+  data: import_v415.z.string().nullish(),
+  mime_type: import_v415.z.string().nullish()
+}).loose();
+var contentBlockSchema = () => {
+  const textContent = import_v415.z.object({
+    type: import_v415.z.literal("text"),
+    text: import_v415.z.string(),
+    annotations: import_v415.z.array(annotationSchema()).nullish()
+  }).loose();
+  const thoughtContent = import_v415.z.object({
+    type: import_v415.z.literal("thought"),
+    signature: import_v415.z.string().nullish(),
+    summary: import_v415.z.array(thoughtSummaryItemSchema()).nullish()
+  }).loose();
+  const functionCallContent = import_v415.z.object({
+    type: import_v415.z.literal("function_call"),
+    id: import_v415.z.string(),
+    name: import_v415.z.string(),
+    arguments: import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()).nullish(),
+    signature: import_v415.z.string().nullish()
+  }).loose();
+  const imageContent = import_v415.z.object({
+    type: import_v415.z.literal("image"),
+    data: import_v415.z.string().nullish(),
+    mime_type: import_v415.z.string().nullish(),
+    resolution: import_v415.z.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+    uri: import_v415.z.string().nullish()
+  }).loose();
+  const builtinToolCall = import_v415.z.object({
+    type: import_v415.z.enum([
+      "google_search_call",
+      "code_execution_call",
+      "url_context_call",
+      "file_search_call",
+      "google_maps_call",
+      "mcp_server_tool_call"
+    ]),
+    id: import_v415.z.string(),
+    arguments: import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()).nullish(),
+    name: import_v415.z.string().nullish(),
+    server_name: import_v415.z.string().nullish(),
+    search_type: import_v415.z.string().nullish(),
+    signature: import_v415.z.string().nullish()
+  }).loose();
+  const builtinToolResult = import_v415.z.object({
+    type: import_v415.z.enum([
+      "google_search_result",
+      "code_execution_result",
+      "url_context_result",
+      "file_search_result",
+      "google_maps_result",
+      "mcp_server_tool_result"
+    ]),
+    call_id: import_v415.z.string(),
+    result: import_v415.z.unknown().nullish(),
+    is_error: import_v415.z.boolean().nullish(),
+    name: import_v415.z.string().nullish(),
+    server_name: import_v415.z.string().nullish(),
+    signature: import_v415.z.string().nullish()
+  }).loose();
+  return import_v415.z.union([
+    textContent,
+    imageContent,
+    thoughtContent,
+    functionCallContent,
+    builtinToolCall,
+    builtinToolResult,
+    import_v415.z.object({ type: import_v415.z.string() }).loose()
+  ]);
+};
+var googleInteractionsResponseSchema = (0, import_provider_utils17.lazySchema)(
+  () => (0, import_provider_utils17.zodSchema)(
+    import_v415.z.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: import_v415.z.string().nullish(),
+      created: import_v415.z.string().nullish(),
+      updated: import_v415.z.string().nullish(),
+      status: interactionStatusSchema(),
+      model: import_v415.z.string().nullish(),
+      agent: import_v415.z.string().nullish(),
+      outputs: import_v415.z.array(contentBlockSchema()).nullish(),
+      usage: usageSchema2().nullish(),
+      service_tier: import_v415.z.string().nullish(),
+      previous_interaction_id: import_v415.z.string().nullish(),
+      response_modalities: import_v415.z.array(import_v415.z.string()).nullish()
+    }).loose()
+  )
+);
+var googleInteractionsEventSchema = (0, import_provider_utils17.lazySchema)(
+  () => (0, import_provider_utils17.zodSchema)(
+    (() => {
+      const status = interactionStatusSchema();
+      const annotation = annotationSchema();
+      const thoughtSummaryItem = thoughtSummaryItemSchema();
+      const interactionStartEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("interaction.start"),
+        event_id: import_v415.z.string().nullish(),
+        interaction: import_v415.z.object({
+          /*
+           * `id` is omitted when `store: false` (fully stateless mode);
+           * see the matching note on `googleInteractionsResponseSchema.id`.
+           */
+          id: import_v415.z.string().nullish(),
+          created: import_v415.z.string().nullish(),
+          model: import_v415.z.string().nullish(),
+          agent: import_v415.z.string().nullish(),
+          status: status.nullish()
+        }).loose()
+      }).loose();
+      const contentStartEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("content.start"),
+        event_id: import_v415.z.string().nullish(),
+        index: import_v415.z.number(),
+        content: contentBlockSchema()
+      }).loose();
+      const contentDeltaText = import_v415.z.object({
+        type: import_v415.z.literal("text"),
+        text: import_v415.z.string()
+      }).loose();
+      const contentDeltaThoughtSummary = import_v415.z.object({
+        type: import_v415.z.literal("thought_summary"),
+        content: thoughtSummaryItem.nullish()
+      }).loose();
+      const contentDeltaThoughtSignature = import_v415.z.object({
+        type: import_v415.z.literal("thought_signature"),
+        signature: import_v415.z.string().nullish()
+      }).loose();
+      const contentDeltaFunctionCall = import_v415.z.object({
+        type: import_v415.z.literal("function_call"),
+        id: import_v415.z.string(),
+        name: import_v415.z.string(),
+        arguments: import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()).nullish(),
+        signature: import_v415.z.string().nullish()
+      }).loose();
+      const contentDeltaTextAnnotation = import_v415.z.object({
+        type: import_v415.z.literal("text_annotation"),
+        annotations: import_v415.z.array(annotation).nullish()
+      }).loose();
+      const contentDeltaImage = import_v415.z.object({
+        type: import_v415.z.literal("image"),
+        data: import_v415.z.string().nullish(),
+        mime_type: import_v415.z.string().nullish(),
+        resolution: import_v415.z.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+        uri: import_v415.z.string().nullish()
+      }).loose();
+      const contentDeltaBuiltinToolCall = import_v415.z.object({
+        type: import_v415.z.enum([
+          "google_search_call",
+          "code_execution_call",
+          "url_context_call",
+          "file_search_call",
+          "google_maps_call",
+          "mcp_server_tool_call"
+        ]),
+        id: import_v415.z.string(),
+        arguments: import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()).nullish(),
+        name: import_v415.z.string().nullish(),
+        server_name: import_v415.z.string().nullish(),
+        search_type: import_v415.z.string().nullish(),
+        signature: import_v415.z.string().nullish()
+      }).loose();
+      const contentDeltaBuiltinToolResult = import_v415.z.object({
+        type: import_v415.z.enum([
+          "google_search_result",
+          "code_execution_result",
+          "url_context_result",
+          "file_search_result",
+          "google_maps_result",
+          "mcp_server_tool_result"
+        ]),
+        call_id: import_v415.z.string(),
+        result: import_v415.z.unknown().nullish(),
+        is_error: import_v415.z.boolean().nullish(),
+        name: import_v415.z.string().nullish(),
+        server_name: import_v415.z.string().nullish(),
+        signature: import_v415.z.string().nullish()
+      }).loose();
+      const contentDeltaUnknown = import_v415.z.object({ type: import_v415.z.string() }).loose();
+      const contentDeltaUnion = import_v415.z.union([
+        contentDeltaText,
+        contentDeltaImage,
+        contentDeltaThoughtSummary,
+        contentDeltaThoughtSignature,
+        contentDeltaFunctionCall,
+        contentDeltaTextAnnotation,
+        contentDeltaBuiltinToolCall,
+        contentDeltaBuiltinToolResult,
+        contentDeltaUnknown
+      ]);
+      const contentDeltaEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("content.delta"),
+        event_id: import_v415.z.string().nullish(),
+        index: import_v415.z.number(),
+        delta: contentDeltaUnion
+      }).loose();
+      const contentStopEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("content.stop"),
+        event_id: import_v415.z.string().nullish(),
+        index: import_v415.z.number()
+      }).loose();
+      const interactionStatusUpdateEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("interaction.status_update"),
+        event_id: import_v415.z.string().nullish(),
+        interaction_id: import_v415.z.string().nullish(),
+        status
+      }).loose();
+      const interactionCompleteEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("interaction.complete"),
+        event_id: import_v415.z.string().nullish(),
+        interaction: import_v415.z.object({
+          id: import_v415.z.string().nullish(),
+          status: status.nullish(),
+          usage: usageSchema2().nullish(),
+          service_tier: import_v415.z.string().nullish()
+        }).loose()
+      }).loose();
+      const errorEvent = import_v415.z.object({
+        event_type: import_v415.z.literal("error"),
+        event_id: import_v415.z.string().nullish(),
+        error: import_v415.z.object({
+          code: import_v415.z.string().nullish(),
+          message: import_v415.z.string().nullish()
+        }).loose().nullish()
+      }).loose();
+      const unknownEvent = import_v415.z.object({ event_type: import_v415.z.string() }).loose();
+      return import_v415.z.union([
+        interactionStartEvent,
+        contentStartEvent,
+        contentDeltaEvent,
+        contentStopEvent,
+        interactionStatusUpdateEvent,
+        interactionCompleteEvent,
+        errorEvent,
+        unknownEvent
+      ]);
+    })()
+  )
+);
+
+// src/interactions/google-interactions-language-model-options.ts
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var import_v416 = require("zod/v4");
+var googleInteractionsLanguageModelOptions = (0, import_provider_utils18.lazySchema)(
+  () => (0, import_provider_utils18.zodSchema)(
+    import_v416.z.object({
+      previousInteractionId: import_v416.z.string().nullish(),
+      store: import_v416.z.boolean().nullish(),
+      agent: import_v416.z.string().nullish(),
+      agentConfig: import_v416.z.union([
+        import_v416.z.object({
+          type: import_v416.z.literal("dynamic")
+        }).loose(),
+        import_v416.z.object({
+          type: import_v416.z.literal("deep-research"),
+          thinkingSummaries: import_v416.z.enum(["auto", "none"]).nullish(),
+          visualization: import_v416.z.enum(["off", "auto"]).nullish(),
+          collaborativePlanning: import_v416.z.boolean().nullish()
+        })
+      ]).nullish(),
+      thinkingLevel: import_v416.z.enum(["minimal", "low", "medium", "high"]).nullish(),
+      thinkingSummaries: import_v416.z.enum(["auto", "none"]).nullish(),
+      imageConfig: import_v416.z.object({
+        aspectRatio: import_v416.z.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: import_v416.z.enum(["1K", "2K", "4K", "512"]).nullish()
+      }).nullish(),
+      mediaResolution: import_v416.z.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+      responseModalities: import_v416.z.array(import_v416.z.enum(["text", "image", "audio", "video", "document"])).nullish(),
+      serviceTier: import_v416.z.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: import_v416.z.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: import_v416.z.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: import_v416.z.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: import_v416.z.number().int().positive().nullish()
+    })
+  )
+);
+
+// src/interactions/parse-google-interactions-outputs.ts
+function googleProviderMetadata({
+  signature,
+  interactionId
+}) {
+  const google2 = {};
+  if (signature != null) {
+    google2.signature = signature;
+  }
+  if (interactionId != null) {
+    google2.interactionId = interactionId;
+  }
+  return Object.keys(google2).length > 0 ? { providerMetadata: { google: google2 } } : {};
+}
+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({
+  outputs,
+  generateId: generateId3,
+  interactionId
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const content = [];
+  let hasFunctionCall = false;
+  if (outputs == null) {
+    return { content, hasFunctionCall };
+  }
+  for (const block of outputs) {
+    if (block == null || typeof block !== "object") continue;
+    const type = block.type;
+    if (typeof type !== "string") continue;
+    switch (type) {
+      case "text": {
+        const text = (_a = block.text) != null ? _a : "";
+        const annotations = block.annotations;
+        content.push({
+          type: "text",
+          text,
+          ...googleProviderMetadata({ interactionId })
+        });
+        const sources = annotationsToSources({ annotations, generateId: generateId3 });
+        for (const source of sources) {
+          content.push(source);
+        }
+        break;
+      }
+      case "thought": {
+        const thought = block;
+        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 "image": {
+        const image = block;
+        if (image.data != null && image.data.length > 0) {
+          content.push({
+            type: "file",
+            mediaType: (_b = image.mime_type) != null ? _b : "image/png",
+            data: image.data,
+            ...googleProviderMetadata({ interactionId })
+          });
+        } else if (image.uri != null && image.uri.length > 0) {
+          content.push({
+            type: "file",
+            mediaType: (_c = image.mime_type) != null ? _c : "image/png",
+            data: "",
+            providerMetadata: {
+              google: {
+                ...interactionId != null ? { interactionId } : {},
+                imageUri: image.uri
+              }
+            }
+          });
+        }
+        break;
+      }
+      case "function_call": {
+        hasFunctionCall = true;
+        const call = block;
+        content.push({
+          type: "tool-call",
+          toolCallId: call.id,
+          toolName: call.name,
+          input: JSON.stringify((_d = call.arguments) != null ? _d : {}),
+          ...googleProviderMetadata({
+            signature: call.signature,
+            interactionId
+          })
+        });
+        break;
+      }
+      default: {
+        if (BUILTIN_TOOL_CALL_TYPES2.has(type)) {
+          const call = block;
+          const toolName = type === "mcp_server_tool_call" ? (_e = call.name) != null ? _e : "mcp_server_tool" : builtinToolNameFromCallType2(type);
+          const input = JSON.stringify((_f = call.arguments) != null ? _f : {});
+          content.push({
+            type: "tool-call",
+            toolCallId: (_g = call.id) != null ? _g : generateId3(),
+            toolName,
+            input,
+            providerExecuted: true
+          });
+        } else if (BUILTIN_TOOL_RESULT_TYPES2.has(type)) {
+          const result = block;
+          const toolName = type === "mcp_server_tool_result" ? (_h = result.name) != null ? _h : "mcp_server_tool" : builtinToolNameFromResultType2(type);
+          content.push({
+            type: "tool-result",
+            toolCallId: (_i = result.call_id) != null ? _i : generateId3(),
+            toolName,
+            result: (_j = result.result) != null ? _j : null
+          });
+          const sources = builtinToolResultToSources({
+            block,
+            generateId: generateId3
+          });
+          for (const source of sources) {
+            content.push(source);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return { content, hasFunctionCall };
+}
+
+// src/interactions/poll-google-interactions.ts
+var import_provider_utils19 = require("@ai-sdk/provider-utils");
+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)}`;
+  while (true) {
+    if (abortSignal == null ? void 0 : abortSignal.aborted) {
+      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 (0, import_provider_utils19.delay)(nextDelayMs, { abortSignal });
+    const {
+      value: response,
+      rawValue: rawResponse,
+      responseHeaders
+    } = await (0, import_provider_utils19.getFromApi)({
+      url,
+      headers,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils19.createJsonResponseHandler)(
+        googleInteractionsResponseSchema
+      ),
+      abortSignal,
+      fetch
+    });
+    if (isTerminalStatus(response.status)) {
+      return { response, rawResponse, responseHeaders };
+    }
+    nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+  }
+}
+
+// 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/synthesize-google-interactions-agent-stream.ts
+function synthesizeGoogleInteractionsAgentStream({
+  response,
+  warnings,
+  generateId: generateId3,
+  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({
+        outputs: (_b = response.outputs) != null ? _b : null,
+        generateId: generateId3,
+        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 {
+  constructor(modelOrAgent, config) {
+    this.specificationVersion = "v3";
+    if (typeof modelOrAgent === "string") {
+      this.modelId = modelOrAgent;
+      this.agent = void 0;
+    } else {
+      this.modelId = modelOrAgent.agent;
+      this.agent = modelOrAgent.agent;
+    }
+    this.config = 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;
+    const warnings = [];
+    const opts = await (0, import_provider_utils20.parseProviderOptions)({
+      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);
+    }
+    let responseMimeType;
+    let responseFormat;
+    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 {
+        responseMimeType = "application/json";
+        if (options.responseFormat.schema != null) {
+          responseFormat = options.responseFormat.schema;
+        }
+      }
+    }
+    const {
+      input,
+      systemInstruction: convertedSystemInstruction,
+      warnings: convWarnings
+    } = convertToGoogleInteractionsInput({
+      prompt: options.prompt,
+      previousInteractionId: (_b = opts == null ? void 0 : opts.previousInteractionId) != null ? _b : void 0,
+      store: (_c = opts == null ? void 0 : opts.store) != null ? _c : void 0,
+      mediaResolution: (_d = opts == null ? void 0 : opts.mediaResolution) != null ? _d : void 0
+    });
+    warnings.push(...convWarnings);
+    let systemInstruction = convertedSystemInstruction;
+    const optionSystemInstruction = (_e = opts == null ? void 0 : opts.systemInstruction) != null ? _e : 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 ((opts == null ? void 0 : opts.thinkingLevel) != null) droppedFields.push("thinkingLevel");
+      if ((opts == null ? void 0 : opts.thinkingSummaries) != null) {
+        droppedFields.push("thinkingSummaries");
+      }
+      if ((opts == null ? void 0 : opts.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: (_f = options.temperature) != null ? _f : void 0,
+        top_p: (_g = options.topP) != null ? _g : void 0,
+        seed: (_h = options.seed) != null ? _h : void 0,
+        stop_sequences: options.stopSequences != null && options.stopSequences.length > 0 ? options.stopSequences : void 0,
+        max_output_tokens: (_i = options.maxOutputTokens) != null ? _i : void 0,
+        thinking_level: (_j = opts == null ? void 0 : opts.thinkingLevel) != null ? _j : void 0,
+        thinking_summaries: (_k = opts == null ? void 0 : opts.thinkingSummaries) != null ? _k : void 0,
+        image_config: (opts == null ? void 0 : opts.imageConfig) != null ? pruneUndefined({
+          aspect_ratio: (_l = opts.imageConfig.aspectRatio) != null ? _l : void 0,
+          image_size: (_m = opts.imageConfig.imageSize) != null ? _m : void 0
+        }) : void 0,
+        tool_choice: toolChoiceForBody
+      });
+    }
+    let agentConfig;
+    if (isAgent && (opts == null ? void 0 : opts.agentConfig) != null) {
+      const ac = opts.agentConfig;
+      if (ac.type === "deep-research") {
+        agentConfig = pruneUndefined({
+          type: "deep-research",
+          thinking_summaries: (_n = ac.thinkingSummaries) != null ? _n : void 0,
+          visualization: (_o = ac.visualization) != null ? _o : void 0,
+          collaborative_planning: (_p = ac.collaborativePlanning) != null ? _p : void 0
+        });
+      } else if (ac.type === "dynamic") {
+        agentConfig = { type: "dynamic" };
+      }
+    }
+    const args = pruneUndefined({
+      ...isAgent ? { agent: this.agent } : { model: this.modelId },
+      input,
+      system_instruction: systemInstruction,
+      tools: toolsForBody,
+      response_format: responseFormat,
+      response_mime_type: responseMimeType,
+      response_modalities: (opts == null ? void 0 : opts.responseModalities) != null ? opts.responseModalities : void 0,
+      previous_interaction_id: (_q = opts == null ? void 0 : opts.previousInteractionId) != null ? _q : void 0,
+      service_tier: (_r = opts == null ? void 0 : opts.serviceTier) != null ? _r : void 0,
+      store: (_s = opts == null ? void 0 : opts.store) != null ? _s : void 0,
+      generation_config: generationConfig != null && Object.keys(generationConfig).length > 0 ? generationConfig : void 0,
+      agent_config: agentConfig,
+      ...isAgent ? { background: true } : {}
+    });
+    return {
+      args,
+      warnings,
+      isAgent,
+      pollingTimeoutMs: (_t = opts == null ? void 0 : opts.pollingTimeoutMs) != null ? _t : 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 = (0, import_provider_utils20.combineHeaders)(
+      this.config.headers ? await (0, import_provider_utils20.resolve)(this.config.headers) : void 0,
+      options.headers
+    );
+    const postResult = await (0, import_provider_utils20.postJsonToApi)({
+      url,
+      headers: mergedHeaders,
+      body: args,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils20.createJsonResponseHandler)(
+        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({
+      outputs: (_b = response.outputs) != null ? _b : null,
+      generateId: (_c = this.config.generateId) != null ? _c : import_provider_utils20.generateId,
+      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 providerMetadata = {
+      google: {
+        ...interactionId != null ? { interactionId } : {},
+        ...serviceTier != null ? { serviceTier } : {}
+      }
+    };
+    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, isAgent, pollingTimeoutMs } = await this.getArgs(options);
+    const url = `${this.config.baseURL}/interactions`;
+    const mergedHeaders = (0, import_provider_utils20.combineHeaders)(
+      this.config.headers ? await (0, import_provider_utils20.resolve)(this.config.headers) : void 0,
+      options.headers
+    );
+    if (isAgent) {
+      return this.doStreamAgent({
+        args,
+        warnings,
+        url,
+        mergedHeaders,
+        options,
+        pollingTimeoutMs
+      });
+    }
+    const body = { ...args, stream: true };
+    const { responseHeaders, value: response } = await (0, import_provider_utils20.postJsonToApi)({
+      url,
+      headers: mergedHeaders,
+      body,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils20.createEventSourceResponseHandler)(
+        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 : import_provider_utils20.generateId,
+      includeRawChunks: options.includeRawChunks,
+      serviceTier: headerServiceTier
+    });
+    return {
+      stream: response.pipeThrough(transform),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+  /*
+   * Drive the streaming surface for agent calls. Agent calls require
+   * `background: true`, which is incompatible with `stream: true` on POST.
+   *
+   * In principle the API also exposes `GET /interactions/{id}?stream=true`
+   * to replay events as the agent runs. In practice the connection is
+   * idle for long stretches while the agent thinks (deep-research can run
+   * for a minute or more between SSE events), and undici's default body
+   * timeout terminates the request mid-flight with `UND_ERR_BODY_TIMEOUT`.
+   * Tuning the timeout per-call would require the caller to thread an
+   * `undici.Agent` through `fetch`, which contradicts the AI SDK's
+   * pluggable-fetch contract.
+   *
+   * We therefore drive `doStream` exactly like `doGenerate` for agents:
+   * POST with `background: true`, poll `GET /interactions/{id}` until
+   * terminal, then synthesize the stream from the final outputs. The
+   * user-facing surface stays identical -- text-start / text-delta /
+   * text-end / finish parts arrive in the same order as a true SSE
+   * response, just buffered until the agent completes.
+   */
+  async doStreamAgent({
+    args,
+    warnings,
+    url,
+    mergedHeaders,
+    options,
+    pollingTimeoutMs
+  }) {
+    var _a, _b;
+    const postResult = await (0, import_provider_utils20.postJsonToApi)({
+      url,
+      headers: mergedHeaders,
+      body: args,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils20.createJsonResponseHandler)(
+        googleInteractionsResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let { responseHeaders: postHeaders, value: postResponse } = postResult;
+    const interactionId = postResponse.id;
+    if (interactionId == null || interactionId.length === 0) {
+      throw new Error(
+        "google.interactions: agent POST response did not include an interaction id; cannot poll for the agent result."
+      );
+    }
+    if (!isTerminalStatus(postResponse.status)) {
+      const polled = await pollGoogleInteractionUntilTerminal({
+        baseURL: this.config.baseURL,
+        interactionId,
+        headers: mergedHeaders,
+        fetch: this.config.fetch,
+        abortSignal: options.abortSignal,
+        timeoutMs: pollingTimeoutMs
+      });
+      postResponse = polled.response;
+      postHeaders = (_a = polled.responseHeaders) != null ? _a : postHeaders;
+    }
+    const stream = synthesizeGoogleInteractionsAgentStream({
+      response: postResponse,
+      warnings,
+      generateId: (_b = this.config.generateId) != null ? _b : import_provider_utils20.generateId,
+      includeRawChunks: options.includeRawChunks,
+      headerServiceTier: postHeaders == null ? void 0 : postHeaders["x-gemini-service-tier"]
+    });
+    return {
+      stream,
+      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;
+}
+
+// src/google-provider.ts
+function createGoogleGenerativeAI(options = {}) {
+  var _a, _b;
+  const baseURL = (_a = (0, import_provider_utils21.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
+  const providerName = (_b = options.name) != null ? _b : "google.generative-ai";
+  const getHeaders = () => (0, import_provider_utils21.withUserAgentSuffix)(
+    {
+      "x-goog-api-key": (0, import_provider_utils21.loadApiKey)({
+        apiKey: options.apiKey,
+        environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
+        description: "Google Generative AI"
+      }),
+      ...options.headers
+    },
+    `ai-sdk/google/${VERSION}`
+  );
+  const createChatModel = (modelId) => {
+    var _a2;
+    return new GoogleGenerativeAILanguageModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils21.generateId,
+      supportedUrls: () => ({
+        "*": [
+          // Google Generative Language "files" endpoint
+          // e.g. https://generativelanguage.googleapis.com/v1beta/files/...
+          new RegExp(`^${baseURL}/files/.*$`),
+          // YouTube URLs (public or unlisted videos)
+          new RegExp(
+            `^https://(?:www\\.)?youtube\\.com/watch\\?v=[\\w-]+(?:&[\\w=&.-]*)?$`
+          ),
+          new RegExp(`^https://youtu\\.be/[\\w-]+(?:\\?[\\w=&.-]*)?$`)
+        ]
+      }),
+      fetch: options.fetch
+    });
+  };
+  const createEmbeddingModel = (modelId) => new GoogleGenerativeAIEmbeddingModel(modelId, {
+    provider: providerName,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createImageModel = (modelId, settings = {}) => new GoogleGenerativeAIImageModel(modelId, settings, {
+    provider: providerName,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
   });
   const createVideoModel = (modelId) => {
     var _a2;
@@ -3052,9 +5372,22 @@ function createGoogleGenerativeAI(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils16.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils21.generateId
     });
   };
+  const createInteractionsModel = (modelIdOrAgent) => {
+    var _a2;
+    return new GoogleInteractionsLanguageModel(
+      modelIdOrAgent,
+      {
+        provider: `${providerName}.interactions`,
+        baseURL,
+        headers: getHeaders,
+        generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils21.generateId,
+        fetch: options.fetch
+      }
+    );
+  };
   const provider = function(modelId) {
     if (new.target) {
       throw new Error(
@@ -3075,6 +5408,7 @@ function createGoogleGenerativeAI(options = {}) {
   provider.imageModel = createImageModel;
   provider.video = createVideoModel;
   provider.videoModel = createVideoModel;
+  provider.interactions = createInteractionsModel;
   provider.tools = googleTools;
   return provider;
 }