cloudassist-ai-provider 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,2 +1,2187 @@
-export { createGoogleGenerativeAI, google } from './google-provider';
-export { VERSION } from './version';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  VERSION: () => VERSION,
+  createGoogleGenerativeAI: () => createGoogleGenerativeAI,
+  google: () => google
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/google-provider.ts
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
+
+// src/version.ts
+var VERSION = true ? "0.0.1" : "0.0.0-test";
+
+// src/google-generative-ai-embedding-model.ts
+var import_provider = require("@ai-sdk/provider");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_v43 = require("zod/v4");
+
+// src/google-error.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_v4 = require("zod/v4");
+var googleErrorDataSchema = (0, import_provider_utils.lazySchema)(
+  () => (0, import_provider_utils.zodSchema)(
+    import_v4.z.object({
+      error: import_v4.z.object({
+        code: import_v4.z.number().nullable(),
+        message: import_v4.z.string(),
+        status: import_v4.z.string()
+      })
+    })
+  )
+);
+var googleFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+  errorSchema: googleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/google-generative-ai-embedding-options.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_v42 = require("zod/v4");
+var googleGenerativeAIEmbeddingProviderOptions = (0, import_provider_utils2.lazySchema)(
+  () => (0, import_provider_utils2.zodSchema)(
+    import_v42.z.object({
+      /**
+       * Optional. Optional reduced dimension for the output embedding.
+       * If set, excessive values in the output embedding are truncated from the end.
+       */
+      outputDimensionality: import_v42.z.number().optional(),
+      /**
+       * Optional. Specifies the task type for generating embeddings.
+       * Supported task types:
+       * - SEMANTIC_SIMILARITY: Optimized for text similarity.
+       * - CLASSIFICATION: Optimized for text classification.
+       * - CLUSTERING: Optimized for clustering texts based on similarity.
+       * - RETRIEVAL_DOCUMENT: Optimized for document retrieval.
+       * - RETRIEVAL_QUERY: Optimized for query-based retrieval.
+       * - QUESTION_ANSWERING: Optimized for answering questions.
+       * - FACT_VERIFICATION: Optimized for verifying factual information.
+       * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
+       */
+      taskType: import_v42.z.enum([
+        "SEMANTIC_SIMILARITY",
+        "CLASSIFICATION",
+        "CLUSTERING",
+        "RETRIEVAL_DOCUMENT",
+        "RETRIEVAL_QUERY",
+        "QUESTION_ANSWERING",
+        "FACT_VERIFICATION",
+        "CODE_RETRIEVAL_QUERY"
+      ]).optional()
+    })
+  )
+);
+
+// src/provider-key.ts
+var ALLOWED_PROVIDER_KEYS = [
+  "antigravity",
+  "gemini-cli",
+  "cloudassist",
+  "google"
+];
+function getProviderKey(providerOptions) {
+  return ALLOWED_PROVIDER_KEYS.find(
+    (key) => (providerOptions == null ? void 0 : providerOptions[key]) !== void 0
+  );
+}
+
+// src/google-generative-ai-embedding-model.ts
+var GoogleGenerativeAIEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.maxEmbeddingsPerCall = 2048;
+    this.supportsParallelCalls = true;
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    const providerKey = getProviderKey(providerOptions);
+    const googleOptions = await (0, import_provider_utils3.parseProviderOptions)({
+      provider: providerKey != null ? providerKey : "google",
+      providerOptions,
+      schema: googleGenerativeAIEmbeddingProviderOptions
+    });
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new import_provider.TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const mergedHeaders = (0, import_provider_utils3.combineHeaders)(
+      await (0, import_provider_utils3.resolve)(this.config.headers),
+      headers
+    );
+    if (values.length === 1) {
+      const {
+        responseHeaders: responseHeaders2,
+        value: response2,
+        rawValue: rawValue2
+      } = await (0, import_provider_utils3.postJsonToApi)({
+        url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
+        headers: mergedHeaders,
+        body: {
+          model: `models/${this.modelId}`,
+          content: {
+            parts: [{ text: values[0] }]
+          },
+          outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
+          taskType: googleOptions == null ? void 0 : googleOptions.taskType
+        },
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+          googleGenerativeAISingleEmbeddingResponseSchema
+        ),
+        abortSignal,
+        fetch: this.config.fetch
+      });
+      return {
+        embeddings: [response2.embedding.values],
+        usage: void 0,
+        response: { headers: responseHeaders2, body: rawValue2 }
+      };
+    }
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await (0, import_provider_utils3.postJsonToApi)({
+      url: `${this.config.baseURL}/models/${this.modelId}:batchEmbedContents`,
+      headers: mergedHeaders,
+      body: {
+        requests: values.map((value) => ({
+          model: `models/${this.modelId}`,
+          content: { role: "user", parts: [{ text: value }] },
+          outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
+          taskType: googleOptions == null ? void 0 : googleOptions.taskType
+        }))
+      },
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        googleGenerativeAITextEmbeddingResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.embeddings.map((item) => item.values),
+      usage: void 0,
+      response: { headers: responseHeaders, body: rawValue }
+    };
+  }
+};
+var googleGenerativeAITextEmbeddingResponseSchema = (0, import_provider_utils3.lazySchema)(
+  () => (0, import_provider_utils3.zodSchema)(
+    import_v43.z.object({
+      embeddings: import_v43.z.array(import_v43.z.object({ values: import_v43.z.array(import_v43.z.number()) }))
+    })
+  )
+);
+var googleGenerativeAISingleEmbeddingResponseSchema = (0, import_provider_utils3.lazySchema)(
+  () => (0, import_provider_utils3.zodSchema)(
+    import_v43.z.object({
+      embedding: import_v43.z.object({ values: import_v43.z.array(import_v43.z.number()) })
+    })
+  )
+);
+
+// src/google-generative-ai-language-model.ts
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_v45 = require("zod/v4");
+
+// src/convert-json-schema-to-openapi-schema.ts
+function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
+  if (jsonSchema == null) {
+    return void 0;
+  }
+  if (isEmptyObjectSchema(jsonSchema)) {
+    if (isRoot) {
+      return void 0;
+    }
+    if (typeof jsonSchema === "object" && jsonSchema.description) {
+      return { type: "object", description: jsonSchema.description };
+    }
+    return { type: "object" };
+  }
+  if (typeof jsonSchema === "boolean") {
+    return { type: "boolean", properties: {} };
+  }
+  const {
+    type,
+    description,
+    required,
+    properties,
+    items,
+    allOf,
+    anyOf,
+    oneOf,
+    format,
+    const: constValue,
+    minLength,
+    enum: enumValues
+  } = jsonSchema;
+  const result = {};
+  if (description) result.description = description;
+  if (required) result.required = required;
+  if (format) result.format = format;
+  if (constValue !== void 0) {
+    result.enum = [constValue];
+  }
+  if (type) {
+    if (Array.isArray(type)) {
+      const hasNull = type.includes("null");
+      const nonNullTypes = type.filter((t) => t !== "null");
+      if (nonNullTypes.length === 0) {
+        result.type = "null";
+      } else {
+        result.anyOf = nonNullTypes.map((t) => ({ type: t }));
+        if (hasNull) {
+          result.nullable = true;
+        }
+      }
+    } else {
+      result.type = type;
+    }
+  }
+  if (enumValues !== void 0) {
+    result.enum = enumValues;
+  }
+  if (properties != null) {
+    result.properties = Object.entries(properties).reduce(
+      (acc, [key, value]) => {
+        acc[key] = convertJSONSchemaToOpenAPISchema(value, false);
+        return acc;
+      },
+      {}
+    );
+  }
+  if (items) {
+    result.items = Array.isArray(items) ? items.map((item) => convertJSONSchemaToOpenAPISchema(item, false)) : convertJSONSchemaToOpenAPISchema(items, false);
+  }
+  if (allOf) {
+    result.allOf = allOf.map(
+      (item) => convertJSONSchemaToOpenAPISchema(item, false)
+    );
+  }
+  if (anyOf) {
+    if (anyOf.some(
+      (schema) => typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null"
+    )) {
+      const nonNullSchemas = anyOf.filter(
+        (schema) => !(typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null")
+      );
+      if (nonNullSchemas.length === 1) {
+        const converted = convertJSONSchemaToOpenAPISchema(
+          nonNullSchemas[0],
+          false
+        );
+        if (typeof converted === "object") {
+          result.nullable = true;
+          Object.assign(result, converted);
+        }
+      } else {
+        result.anyOf = nonNullSchemas.map(
+          (item) => convertJSONSchemaToOpenAPISchema(item, false)
+        );
+        result.nullable = true;
+      }
+    } else {
+      result.anyOf = anyOf.map(
+        (item) => convertJSONSchemaToOpenAPISchema(item, false)
+      );
+    }
+  }
+  if (oneOf) {
+    result.oneOf = oneOf.map(
+      (item) => convertJSONSchemaToOpenAPISchema(item, false)
+    );
+  }
+  if (minLength !== void 0) {
+    result.minLength = minLength;
+  }
+  return result;
+}
+function isEmptyObjectSchema(jsonSchema) {
+  return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0) && !jsonSchema.additionalProperties;
+}
+
+// src/convert-to-google-generative-ai-messages.ts
+var import_provider3 = require("@ai-sdk/provider");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+
+// src/google-prepare-tools.ts
+var import_provider2 = require("@ai-sdk/provider");
+function isClaudeModel(modelId) {
+  return modelId.toLowerCase().startsWith("claude-");
+}
+function prepareTools({
+  tools,
+  toolChoice,
+  modelId
+}) {
+  var _a;
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  const isLatest = [
+    "gemini-flash-latest",
+    "gemini-flash-lite-latest",
+    "gemini-pro-latest"
+  ].some((id) => id === modelId);
+  const isGemini2orNewer = modelId.includes("gemini-2") || modelId.includes("gemini-3") || isLatest;
+  const supportsDynamicRetrieval = modelId.includes("gemini-1.5-flash") && !modelId.includes("-8b");
+  const supportsFileSearch = modelId.includes("gemini-2.5");
+  if (tools == null) {
+    return { tools: void 0, toolConfig: void 0, toolWarnings };
+  }
+  const hasFunctionTools = tools.some((tool) => tool.type === "function");
+  const hasProviderDefinedTools = tools.some(
+    (tool) => tool.type === "provider-defined"
+  );
+  if (hasFunctionTools && hasProviderDefinedTools) {
+    const functionTools = tools.filter((tool) => tool.type === "function");
+    toolWarnings.push({
+      type: "unsupported-tool",
+      tool: tools.find((tool) => tool.type === "function"),
+      details: `Cannot mix function tools with provider-defined tools in the same request. Falling back to provider-defined tools only. The following function tools will be ignored: ${functionTools.map((t) => t.name).join(", ")}. Please use either function tools or provider-defined tools, but not both.`
+    });
+  }
+  if (hasProviderDefinedTools) {
+    const googleTools2 = [];
+    const providerDefinedTools = tools.filter(
+      (tool) => tool.type === "provider-defined"
+    );
+    providerDefinedTools.forEach((tool) => {
+      switch (tool.id) {
+        case "google.google_search":
+          if (isGemini2orNewer) {
+            googleTools2.push({ googleSearch: {} });
+          } else if (supportsDynamicRetrieval) {
+            googleTools2.push({
+              googleSearchRetrieval: {
+                dynamicRetrievalConfig: {
+                  mode: tool.args.mode,
+                  dynamicThreshold: tool.args.dynamicThreshold
+                }
+              }
+            });
+          } else {
+            googleTools2.push({ googleSearchRetrieval: {} });
+          }
+          break;
+        case "google.enterprise_web_search":
+          if (isGemini2orNewer) {
+            googleTools2.push({ enterpriseWebSearch: {} });
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "Enterprise Web Search requires Gemini 2.0 or newer."
+            });
+          }
+          break;
+        case "google.url_context":
+          if (isGemini2orNewer) {
+            googleTools2.push({ urlContext: {} });
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The URL context tool is not supported with other Gemini models than Gemini 2."
+            });
+          }
+          break;
+        case "google.code_execution":
+          if (isGemini2orNewer) {
+            googleTools2.push({ codeExecution: {} });
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The code execution tools is not supported with other Gemini models than Gemini 2."
+            });
+          }
+          break;
+        case "google.file_search":
+          if (supportsFileSearch) {
+            googleTools2.push({ fileSearch: { ...tool.args } });
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The file search tool is only supported with Gemini 2.5 models."
+            });
+          }
+          break;
+        case "google.vertex_rag_store":
+          if (isGemini2orNewer) {
+            googleTools2.push({
+              retrieval: {
+                vertex_rag_store: {
+                  rag_resources: {
+                    rag_corpus: tool.args.ragCorpus
+                  },
+                  similarity_top_k: tool.args.topK
+                }
+              }
+            });
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The RAG store tool is not supported with other Gemini models than Gemini 2."
+            });
+          }
+          break;
+        case "google.google_maps":
+          if (isGemini2orNewer) {
+            googleTools2.push({ googleMaps: {} });
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The Google Maps grounding tool is not supported with Gemini models other than Gemini 2 or newer."
+            });
+          }
+          break;
+        default:
+          toolWarnings.push({ type: "unsupported-tool", tool });
+          break;
+      }
+    });
+    return {
+      tools: googleTools2.length > 0 ? googleTools2 : void 0,
+      toolConfig: void 0,
+      toolWarnings
+    };
+  }
+  const functionDeclarations = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function": {
+        let parameters = convertJSONSchemaToOpenAPISchema(tool.inputSchema);
+        if (isClaudeModel(modelId) && !parameters) {
+          parameters = { type: "object", properties: {} };
+        }
+        functionDeclarations.push({
+          name: tool.name,
+          description: (_a = tool.description) != null ? _a : "",
+          parameters
+        });
+        break;
+      }
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool });
+        break;
+    }
+  }
+  if (toolChoice == null) {
+    return {
+      tools: [{ functionDeclarations }],
+      toolConfig: void 0,
+      toolWarnings
+    };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: { functionCallingConfig: { mode: "AUTO" } },
+        toolWarnings
+      };
+    case "none":
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: { functionCallingConfig: { mode: "NONE" } },
+        toolWarnings
+      };
+    case "required":
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: { functionCallingConfig: { mode: "ANY" } },
+        toolWarnings
+      };
+    case "tool":
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: {
+          functionCallingConfig: {
+            mode: "ANY",
+            allowedFunctionNames: [toolChoice.toolName]
+          }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new import_provider2.UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+// src/convert-to-google-generative-ai-messages.ts
+function convertToGoogleGenerativeAIMessages(prompt, options) {
+  var _a, _b, _c;
+  const systemInstructionParts = [];
+  const contents = [];
+  let systemMessagesAllowed = true;
+  const isGemmaModel = (_a = options == null ? void 0 : options.isGemmaModel) != null ? _a : false;
+  const modelId = (_b = options == null ? void 0 : options.modelId) != null ? _b : "";
+  const includeToolCallId = isClaudeModel(modelId);
+  const providerKey = (_c = options == null ? void 0 : options.providerKey) != null ? _c : "google";
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        if (!systemMessagesAllowed) {
+          throw new import_provider3.UnsupportedFunctionalityError({
+            functionality: "system messages are only supported at the beginning of the conversation"
+          });
+        }
+        systemInstructionParts.push({ text: content });
+        break;
+      }
+      case "user": {
+        systemMessagesAllowed = false;
+        const parts = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              parts.push({ text: part.text });
+              break;
+            }
+            case "file": {
+              const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+              parts.push(
+                part.data instanceof URL ? {
+                  fileData: {
+                    mimeType: mediaType,
+                    fileUri: part.data.toString()
+                  }
+                } : {
+                  inlineData: {
+                    mimeType: mediaType,
+                    data: (0, import_provider_utils4.convertToBase64)(part.data)
+                  }
+                }
+              );
+              break;
+            }
+          }
+        }
+        contents.push({ role: "user", parts });
+        break;
+      }
+      case "assistant": {
+        systemMessagesAllowed = false;
+        contents.push({
+          role: "model",
+          parts: content.map((part) => {
+            var _a2, _b2, _c2;
+            const thoughtSignature = ((_b2 = (_a2 = part.providerOptions) == null ? void 0 : _a2[providerKey]) == null ? void 0 : _b2.thoughtSignature) != null ? String((_c2 = part.providerOptions[providerKey]) == null ? void 0 : _c2.thoughtSignature) : void 0;
+            switch (part.type) {
+              case "text": {
+                return part.text.length === 0 ? void 0 : {
+                  text: part.text,
+                  thoughtSignature
+                };
+              }
+              case "reasoning": {
+                return part.text.length === 0 ? void 0 : {
+                  text: part.text,
+                  thought: true,
+                  thoughtSignature
+                };
+              }
+              case "file": {
+                if (part.mediaType !== "image/png") {
+                  throw new import_provider3.UnsupportedFunctionalityError({
+                    functionality: "Only PNG images are supported in assistant messages"
+                  });
+                }
+                if (part.data instanceof URL) {
+                  throw new import_provider3.UnsupportedFunctionalityError({
+                    functionality: "File data URLs in assistant messages are not supported"
+                  });
+                }
+                return {
+                  inlineData: {
+                    mimeType: part.mediaType,
+                    data: (0, import_provider_utils4.convertToBase64)(part.data)
+                  }
+                };
+              }
+              case "tool-call": {
+                return {
+                  functionCall: {
+                    name: part.toolName,
+                    args: part.input,
+                    ...includeToolCallId && part.toolCallId ? { id: part.toolCallId } : {}
+                  },
+                  thoughtSignature
+                };
+              }
+            }
+          }).filter((part) => part !== void 0)
+        });
+        break;
+      }
+      case "tool": {
+        systemMessagesAllowed = false;
+        const parts = [];
+        for (const part of content) {
+          const output = part.output;
+          if (output.type === "content") {
+            for (const contentPart of output.value) {
+              switch (contentPart.type) {
+                case "text":
+                  parts.push({
+                    functionResponse: {
+                      name: part.toolName,
+                      response: {
+                        name: part.toolName,
+                        content: contentPart.text
+                      },
+                      ...includeToolCallId && part.toolCallId ? { id: part.toolCallId } : {}
+                    }
+                  });
+                  break;
+                case "media":
+                  parts.push(
+                    {
+                      inlineData: {
+                        mimeType: contentPart.mediaType,
+                        data: contentPart.data
+                      }
+                    },
+                    {
+                      text: "Tool executed successfully and returned this image as a response"
+                    }
+                  );
+                  break;
+                default:
+                  parts.push({ text: JSON.stringify(contentPart) });
+                  break;
+              }
+            }
+          } else {
+            parts.push({
+              functionResponse: {
+                name: part.toolName,
+                response: {
+                  name: part.toolName,
+                  content: output.value
+                },
+                ...includeToolCallId && part.toolCallId ? { id: part.toolCallId } : {}
+              }
+            });
+          }
+        }
+        contents.push({
+          role: "user",
+          parts
+        });
+        break;
+      }
+    }
+  }
+  if (isGemmaModel && systemInstructionParts.length > 0 && contents.length > 0 && contents[0].role === "user") {
+    const systemText = systemInstructionParts.map((part) => part.text).join("\n\n");
+    contents[0].parts.unshift({ text: systemText + "\n\n" });
+  }
+  return {
+    systemInstruction: systemInstructionParts.length > 0 && !isGemmaModel ? { parts: systemInstructionParts } : void 0,
+    contents
+  };
+}
+
+// src/google-generative-ai-options.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_v44 = require("zod/v4");
+var googleGenerativeAIProviderOptions = (0, import_provider_utils5.lazySchema)(
+  () => (0, import_provider_utils5.zodSchema)(
+    import_v44.z.object({
+      responseModalities: import_v44.z.array(import_v44.z.enum(["TEXT", "IMAGE"])).optional(),
+      thinkingConfig: import_v44.z.object({
+        thinkingBudget: import_v44.z.number().optional(),
+        includeThoughts: import_v44.z.boolean().optional(),
+        // https://ai.google.dev/gemini-api/docs/gemini-3?thinking=high#thinking_level
+        thinkingLevel: import_v44.z.enum(["minimal", "low", "medium", "high"]).optional()
+      }).optional(),
+      /**
+       * Optional.
+       * The name of the cached content used as context to serve the prediction.
+       * Format: cachedContents/{cachedContent}
+       */
+      cachedContent: import_v44.z.string().optional(),
+      /**
+       * Optional. Enable structured output. Default is true.
+       *
+       * This is useful when the JSON Schema contains elements that are
+       * not supported by the OpenAPI schema version that
+       * Google Generative AI uses. You can use this to disable
+       * structured outputs if you need to.
+       */
+      structuredOutputs: import_v44.z.boolean().optional(),
+      /**
+       * Optional. A list of unique safety settings for blocking unsafe content.
+       */
+      safetySettings: import_v44.z.array(
+        import_v44.z.object({
+          category: import_v44.z.enum([
+            "HARM_CATEGORY_UNSPECIFIED",
+            "HARM_CATEGORY_HATE_SPEECH",
+            "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "HARM_CATEGORY_HARASSMENT",
+            "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "HARM_CATEGORY_CIVIC_INTEGRITY"
+          ]),
+          threshold: import_v44.z.enum([
+            "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+            "BLOCK_LOW_AND_ABOVE",
+            "BLOCK_MEDIUM_AND_ABOVE",
+            "BLOCK_ONLY_HIGH",
+            "BLOCK_NONE",
+            "OFF"
+          ])
+        })
+      ).optional(),
+      threshold: import_v44.z.enum([
+        "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+        "BLOCK_LOW_AND_ABOVE",
+        "BLOCK_MEDIUM_AND_ABOVE",
+        "BLOCK_ONLY_HIGH",
+        "BLOCK_NONE",
+        "OFF"
+      ]).optional(),
+      /**
+       * Optional. Enables timestamp understanding for audio-only files.
+       *
+       * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
+       */
+      audioTimestamp: import_v44.z.boolean().optional(),
+      /**
+       * Optional. Defines labels used in billing reports. Available on Vertex AI only.
+       *
+       * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/add-labels-to-api-calls
+       */
+      labels: import_v44.z.record(import_v44.z.string(), import_v44.z.string()).optional(),
+      /**
+       * Optional. If specified, the media resolution specified will be used.
+       *
+       * https://ai.google.dev/api/generate-content#MediaResolution
+       */
+      mediaResolution: import_v44.z.enum([
+        "MEDIA_RESOLUTION_UNSPECIFIED",
+        "MEDIA_RESOLUTION_LOW",
+        "MEDIA_RESOLUTION_MEDIUM",
+        "MEDIA_RESOLUTION_HIGH"
+      ]).optional(),
+      /**
+       * Optional. Configures the image generation aspect ratio for Gemini models.
+       *
+       * https://ai.google.dev/gemini-api/docs/image-generation#aspect_ratios
+       */
+      imageConfig: import_v44.z.object({
+        aspectRatio: import_v44.z.enum([
+          "1:1",
+          "2:3",
+          "3:2",
+          "3:4",
+          "4:3",
+          "4:5",
+          "5:4",
+          "9:16",
+          "16:9",
+          "21:9"
+        ]).optional(),
+        imageSize: import_v44.z.enum(["1K", "2K", "4K"]).optional()
+      }).optional(),
+      /**
+       * Optional. Configuration for grounding retrieval.
+       * Used to provide location context for Google Maps and Google Search grounding.
+       *
+       * https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
+       */
+      retrievalConfig: import_v44.z.object({
+        latLng: import_v44.z.object({
+          latitude: import_v44.z.number(),
+          longitude: import_v44.z.number()
+        }).optional()
+      }).optional(),
+      // Cloud Assist specific options
+      /**
+       * Required for Cloud Assist. The Google Cloud project ID.
+       */
+      projectId: import_v44.z.string().optional(),
+      /**
+       * Optional. Session ID for conversation continuity.
+       */
+      sessionId: import_v44.z.string().optional(),
+      /**
+       * Optional. Request type (e.g., "agent").
+       */
+      requestType: import_v44.z.string().optional(),
+      /**
+       * Required for Cloud Assist. User agent identifier.
+       */
+      userAgent: import_v44.z.string().optional(),
+      /**
+       * Optional. Custom request ID. If not provided, one will be generated.
+       */
+      requestId: import_v44.z.string().optional()
+    })
+  )
+);
+
+// src/map-google-generative-ai-finish-reason.ts
+function mapGoogleGenerativeAIFinishReason({
+  finishReason,
+  hasToolCalls
+}) {
+  switch (finishReason) {
+    case "STOP":
+      return hasToolCalls ? "tool-calls" : "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "IMAGE_SAFETY":
+    case "RECITATION":
+    case "SAFETY":
+    case "BLOCKLIST":
+    case "PROHIBITED_CONTENT":
+    case "SPII":
+      return "content-filter";
+    case "FINISH_REASON_UNSPECIFIED":
+    case "OTHER":
+      return "other";
+    case "MALFORMED_FUNCTION_CALL":
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+
+// src/google-generative-ai-language-model.ts
+var GoogleGenerativeAILanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    var _a;
+    this.modelId = modelId;
+    this.config = config;
+    this.generateId = (_a = config.generateId) != null ? _a : import_provider_utils6.generateId;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get supportedUrls() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed,
+    tools,
+    toolChoice,
+    providerOptions
+  }) {
+    var _a;
+    const warnings = [];
+    const providerKey = getProviderKey(providerOptions);
+    const googleOptions = await (0, import_provider_utils6.parseProviderOptions)({
+      provider: providerKey != null ? providerKey : "google",
+      providerOptions,
+      schema: googleGenerativeAIProviderOptions
+    });
+    if ((tools == null ? void 0 : tools.some(
+      (tool) => tool.type === "provider-defined" && tool.id === "google.vertex_rag_store"
+    )) && !this.config.provider.startsWith("google.vertex.")) {
+      warnings.push({
+        type: "other",
+        message: `The 'vertex_rag_store' tool is only supported with the Google Vertex provider and might not be supported or could behave unexpectedly with the current Google provider (${this.config.provider}).`
+      });
+    }
+    const isGemmaModel = this.modelId.toLowerCase().startsWith("gemma-");
+    const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(
+      prompt,
+      { isGemmaModel, modelId: this.modelId, providerKey }
+    );
+    const {
+      tools: googleTools2,
+      toolConfig: googleToolConfig,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice,
+      modelId: this.modelId
+    });
+    return {
+      args: {
+        generationConfig: {
+          // standardized settings:
+          maxOutputTokens,
+          temperature,
+          topK,
+          topP,
+          frequencyPenalty,
+          presencePenalty,
+          stopSequences,
+          seed,
+          // response format:
+          responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
+          responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
+          // so this is needed as an escape hatch:
+          // TODO convert into provider option
+          ((_a = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _a : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
+            audioTimestamp: googleOptions.audioTimestamp
+          },
+          // provider options:
+          responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities,
+          thinkingConfig: googleOptions == null ? void 0 : googleOptions.thinkingConfig,
+          ...(googleOptions == null ? void 0 : googleOptions.imageConfig) && {
+            imageConfig: googleOptions.imageConfig
+          },
+          ...(googleOptions == null ? void 0 : googleOptions.mediaResolution) && {
+            mediaResolution: googleOptions.mediaResolution
+          }
+        },
+        contents,
+        systemInstruction: isGemmaModel ? void 0 : systemInstruction,
+        safetySettings: googleOptions == null ? void 0 : googleOptions.safetySettings,
+        tools: googleTools2,
+        toolConfig: (googleOptions == null ? void 0 : googleOptions.retrievalConfig) ? {
+          ...googleToolConfig,
+          retrievalConfig: googleOptions.retrievalConfig
+        } : googleToolConfig,
+        cachedContent: googleOptions == null ? void 0 : googleOptions.cachedContent,
+        labels: googleOptions == null ? void 0 : googleOptions.labels,
+        // Cloud Assist: sessionId goes inside the request
+        ...(googleOptions == null ? void 0 : googleOptions.sessionId) && { sessionId: googleOptions.sessionId }
+      },
+      warnings: [...warnings, ...toolWarnings],
+      // Cloud Assist specific options (used to wrap the request)
+      cloudAssistOptions: {
+        projectId: googleOptions == null ? void 0 : googleOptions.projectId,
+        requestType: googleOptions == null ? void 0 : googleOptions.requestType,
+        userAgent: googleOptions == null ? void 0 : googleOptions.userAgent,
+        requestId: googleOptions == null ? void 0 : googleOptions.requestId
+      },
+      providerKey
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    const { args, warnings, cloudAssistOptions, providerKey } = await this.getArgs(options);
+    const wrappedRequest = {
+      project: cloudAssistOptions.projectId,
+      model: this.modelId,
+      request: args,
+      ...cloudAssistOptions.requestType && {
+        requestType: cloudAssistOptions.requestType
+      },
+      userAgent: (_a = cloudAssistOptions.userAgent) != null ? _a : "ai-sdk",
+      requestId: (_b = cloudAssistOptions.requestId) != null ? _b : `ai-sdk-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
+    };
+    const body = JSON.stringify(wrappedRequest);
+    const mergedHeaders = (0, import_provider_utils6.combineHeaders)(
+      await (0, import_provider_utils6.resolve)(this.config.headers),
+      options.headers
+    );
+    const { responseHeaders, value: response } = await (0, import_provider_utils6.postJsonToApi)({
+      url: `${this.config.baseURL}/v1internal:streamGenerateContent?alt=sse`,
+      headers: mergedHeaders,
+      body: wrappedRequest,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils6.createEventSourceResponseHandler)(chunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const content = [];
+    let finishReason = "unknown";
+    let usageMetadata;
+    let promptFeedback;
+    let groundingMetadata;
+    let urlContextMetadata;
+    let safetyRatings;
+    let currentTextContent = "";
+    let currentTextThoughtSignature;
+    let currentReasoningContent = "";
+    let currentReasoningThoughtSignature;
+    let isInReasoning = false;
+    let lastCodeExecutionToolCallId;
+    const useToolCallId = isClaudeModel(this.modelId);
+    const reader = response.getReader();
+    try {
+      while (true) {
+        const { done, value: chunk } = await reader.read();
+        if (done) break;
+        if (!chunk.success) continue;
+        const value = chunk.value;
+        const responseData = (_c = value.response) != null ? _c : value;
+        if (responseData.usageMetadata) {
+          usageMetadata = responseData.usageMetadata;
+        }
+        if (responseData.promptFeedback) {
+          promptFeedback = responseData.promptFeedback;
+        }
+        const candidate = (_d = responseData.candidates) == null ? void 0 : _d[0];
+        if (!candidate) continue;
+        if (candidate.groundingMetadata) {
+          groundingMetadata = candidate.groundingMetadata;
+        }
+        if (candidate.urlContextMetadata) {
+          urlContextMetadata = candidate.urlContextMetadata;
+        }
+        if (candidate.safetyRatings) {
+          safetyRatings = candidate.safetyRatings;
+        }
+        const parts = (_f = (_e = candidate.content) == null ? void 0 : _e.parts) != null ? _f : [];
+        for (const part of parts) {
+          if ("executableCode" in part && ((_g = part.executableCode) == null ? void 0 : _g.code)) {
+            if (currentTextContent) {
+              content.push({
+                type: "text",
+                text: currentTextContent,
+                providerMetadata: currentTextThoughtSignature ? {
+                  [providerKey != null ? providerKey : "google"]: {
+                    thoughtSignature: currentTextThoughtSignature
+                  }
+                } : void 0
+              });
+              currentTextContent = "";
+              currentTextThoughtSignature = void 0;
+            }
+            if (currentReasoningContent) {
+              content.push({
+                type: "reasoning",
+                text: currentReasoningContent,
+                providerMetadata: currentReasoningThoughtSignature ? {
+                  [providerKey != null ? providerKey : "google"]: {
+                    thoughtSignature: currentReasoningThoughtSignature
+                  }
+                } : void 0
+              });
+              currentReasoningContent = "";
+              currentReasoningThoughtSignature = void 0;
+            }
+            const toolCallId = this.config.generateId();
+            lastCodeExecutionToolCallId = toolCallId;
+            content.push({
+              type: "tool-call",
+              toolCallId,
+              toolName: "code_execution",
+              input: JSON.stringify(part.executableCode),
+              providerExecuted: true
+            });
+          } else if ("codeExecutionResult" in part && part.codeExecutionResult) {
+            content.push({
+              type: "tool-result",
+              toolCallId: lastCodeExecutionToolCallId,
+              toolName: "code_execution",
+              result: {
+                outcome: part.codeExecutionResult.outcome,
+                output: part.codeExecutionResult.output
+              },
+              providerExecuted: true
+            });
+            lastCodeExecutionToolCallId = void 0;
+          } else if ("text" in part && part.text != null) {
+            const isThinking = part.thought === true;
+            if (isThinking) {
+              if (!isInReasoning && currentTextContent) {
+                content.push({
+                  type: "text",
+                  text: currentTextContent,
+                  providerMetadata: currentTextThoughtSignature ? {
+                    [providerKey != null ? providerKey : "google"]: {
+                      thoughtSignature: currentTextThoughtSignature
+                    }
+                  } : void 0
+                });
+                currentTextContent = "";
+                currentTextThoughtSignature = void 0;
+              }
+              isInReasoning = true;
+              currentReasoningContent += part.text;
+              if (part.thoughtSignature) {
+                currentReasoningThoughtSignature = part.thoughtSignature;
+              }
+            } else {
+              if (isInReasoning && currentReasoningContent) {
+                content.push({
+                  type: "reasoning",
+                  text: currentReasoningContent,
+                  providerMetadata: currentReasoningThoughtSignature ? {
+                    [providerKey != null ? providerKey : "google"]: {
+                      thoughtSignature: currentReasoningThoughtSignature
+                    }
+                  } : void 0
+                });
+                currentReasoningContent = "";
+                currentReasoningThoughtSignature = void 0;
+              }
+              isInReasoning = false;
+              currentTextContent += part.text;
+              if (part.thoughtSignature) {
+                currentTextThoughtSignature = part.thoughtSignature;
+              }
+            }
+          } else if ("functionCall" in part) {
+            if (currentTextContent) {
+              content.push({
+                type: "text",
+                text: currentTextContent,
+                providerMetadata: currentTextThoughtSignature ? {
+                  [providerKey != null ? providerKey : "google"]: {
+                    thoughtSignature: currentTextThoughtSignature
+                  }
+                } : void 0
+              });
+              currentTextContent = "";
+              currentTextThoughtSignature = void 0;
+            }
+            if (currentReasoningContent) {
+              content.push({
+                type: "reasoning",
+                text: currentReasoningContent,
+                providerMetadata: currentReasoningThoughtSignature ? {
+                  [providerKey != null ? providerKey : "google"]: {
+                    thoughtSignature: currentReasoningThoughtSignature
+                  }
+                } : void 0
+              });
+              currentReasoningContent = "";
+              currentReasoningThoughtSignature = void 0;
+            }
+            const toolCallId = useToolCallId && part.functionCall.id ? part.functionCall.id : this.config.generateId();
+            content.push({
+              type: "tool-call",
+              toolCallId,
+              toolName: part.functionCall.name,
+              input: JSON.stringify(part.functionCall.args),
+              providerMetadata: part.thoughtSignature ? {
+                [providerKey != null ? providerKey : "google"]: {
+                  thoughtSignature: part.thoughtSignature
+                }
+              } : void 0
+            });
+          } else if ("inlineData" in part) {
+            if (currentTextContent) {
+              content.push({
+                type: "text",
+                text: currentTextContent,
+                providerMetadata: currentTextThoughtSignature ? {
+                  [providerKey != null ? providerKey : "google"]: {
+                    thoughtSignature: currentTextThoughtSignature
+                  }
+                } : void 0
+              });
+              currentTextContent = "";
+              currentTextThoughtSignature = void 0;
+            }
+            if (currentReasoningContent) {
+              content.push({
+                type: "reasoning",
+                text: currentReasoningContent,
+                providerMetadata: currentReasoningThoughtSignature ? {
+                  [providerKey != null ? providerKey : "google"]: {
+                    thoughtSignature: currentReasoningThoughtSignature
+                  }
+                } : void 0
+              });
+              currentReasoningContent = "";
+              currentReasoningThoughtSignature = void 0;
+            }
+            content.push({
+              type: "file",
+              data: part.inlineData.data,
+              mediaType: part.inlineData.mimeType
+            });
+          }
+        }
+        if (candidate.finishReason) {
+          finishReason = mapGoogleGenerativeAIFinishReason({
+            finishReason: candidate.finishReason,
+            hasToolCalls: content.some((part) => part.type === "tool-call")
+          });
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (currentTextContent) {
+      content.push({
+        type: "text",
+        text: currentTextContent,
+        providerMetadata: currentTextThoughtSignature ? {
+          [providerKey != null ? providerKey : "google"]: {
+            thoughtSignature: currentTextThoughtSignature
+          }
+        } : void 0
+      });
+    }
+    if (currentReasoningContent) {
+      content.push({
+        type: "reasoning",
+        text: currentReasoningContent,
+        providerMetadata: currentReasoningThoughtSignature ? {
+          [providerKey != null ? providerKey : "google"]: {
+            thoughtSignature: currentReasoningThoughtSignature
+          }
+        } : void 0
+      });
+    }
+    const sources = (_h = extractSources({
+      groundingMetadata,
+      generateId: this.config.generateId
+    })) != null ? _h : [];
+    for (const source of sources) {
+      content.push(source);
+    }
+    return {
+      content,
+      finishReason,
+      usage: {
+        inputTokens: (_i = usageMetadata == null ? void 0 : usageMetadata.promptTokenCount) != null ? _i : void 0,
+        outputTokens: (_j = usageMetadata == null ? void 0 : usageMetadata.candidatesTokenCount) != null ? _j : void 0,
+        totalTokens: (_k = usageMetadata == null ? void 0 : usageMetadata.totalTokenCount) != null ? _k : void 0,
+        reasoningTokens: (_l = usageMetadata == null ? void 0 : usageMetadata.thoughtsTokenCount) != null ? _l : void 0,
+        cachedInputTokens: (_m = usageMetadata == null ? void 0 : usageMetadata.cachedContentTokenCount) != null ? _m : void 0
+      },
+      warnings,
+      providerMetadata: {
+        [providerKey != null ? providerKey : "google"]: {
+          promptFeedback: promptFeedback != null ? promptFeedback : null,
+          groundingMetadata: groundingMetadata != null ? groundingMetadata : null,
+          urlContextMetadata: urlContextMetadata != null ? urlContextMetadata : null,
+          safetyRatings: safetyRatings != null ? safetyRatings : null,
+          usageMetadata: usageMetadata != null ? usageMetadata : null
+        }
+      },
+      request: { body },
+      response: {
+        headers: responseHeaders
+      }
+    };
+  }
+  async doStream(options) {
+    var _a, _b;
+    const { args, warnings, cloudAssistOptions, providerKey } = await this.getArgs(options);
+    const wrappedRequest = {
+      project: cloudAssistOptions.projectId,
+      model: this.modelId,
+      request: args,
+      ...cloudAssistOptions.requestType && {
+        requestType: cloudAssistOptions.requestType
+      },
+      userAgent: (_a = cloudAssistOptions.userAgent) != null ? _a : "ai-sdk",
+      requestId: (_b = cloudAssistOptions.requestId) != null ? _b : `ai-sdk-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
+    };
+    const body = JSON.stringify(wrappedRequest);
+    const headers = (0, import_provider_utils6.combineHeaders)(
+      await (0, import_provider_utils6.resolve)(this.config.headers),
+      options.headers
+    );
+    const { responseHeaders, value: response } = await (0, import_provider_utils6.postJsonToApi)({
+      url: `${this.config.baseURL}/v1internal:streamGenerateContent?alt=sse`,
+      headers,
+      body: wrappedRequest,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils6.createEventSourceResponseHandler)(chunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let finishReason = "unknown";
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    let providerMetadata = void 0;
+    const generateId3 = this.config.generateId;
+    const useToolCallId = isClaudeModel(this.modelId);
+    let hasToolCalls = false;
+    let currentTextBlockId = null;
+    let currentReasoningBlockId = null;
+    let blockCounter = 0;
+    const emittedSourceUrls = /* @__PURE__ */ new Set();
+    let lastCodeExecutionToolCallId;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            const responseData = (_a2 = value.response) != null ? _a2 : value;
+            const usageMetadata = responseData.usageMetadata;
+            if (usageMetadata != null) {
+              usage.inputTokens = (_b2 = usageMetadata.promptTokenCount) != null ? _b2 : void 0;
+              usage.outputTokens = (_c = usageMetadata.candidatesTokenCount) != null ? _c : void 0;
+              usage.totalTokens = (_d = usageMetadata.totalTokenCount) != null ? _d : void 0;
+              usage.reasoningTokens = (_e = usageMetadata.thoughtsTokenCount) != null ? _e : void 0;
+              usage.cachedInputTokens = (_f = usageMetadata.cachedContentTokenCount) != null ? _f : void 0;
+            }
+            const candidate = (_g = responseData.candidates) == null ? void 0 : _g[0];
+            if (candidate == null) {
+              return;
+            }
+            const content = candidate.content;
+            const sources = extractSources({
+              groundingMetadata: candidate.groundingMetadata,
+              generateId: generateId3
+            });
+            if (sources != null) {
+              for (const source of sources) {
+                if (source.sourceType === "url" && !emittedSourceUrls.has(source.url)) {
+                  emittedSourceUrls.add(source.url);
+                  controller.enqueue(source);
+                }
+              }
+            }
+            if (content != null) {
+              const parts = (_h = content.parts) != null ? _h : [];
+              for (const part of parts) {
+                if ("executableCode" in part && ((_i = part.executableCode) == null ? void 0 : _i.code)) {
+                  const toolCallId = generateId3();
+                  lastCodeExecutionToolCallId = toolCallId;
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: "code_execution",
+                    input: JSON.stringify(part.executableCode),
+                    providerExecuted: true
+                  });
+                  hasToolCalls = true;
+                } else if ("codeExecutionResult" in part && part.codeExecutionResult) {
+                  const toolCallId = lastCodeExecutionToolCallId;
+                  if (toolCallId) {
+                    controller.enqueue({
+                      type: "tool-result",
+                      toolCallId,
+                      toolName: "code_execution",
+                      result: {
+                        outcome: part.codeExecutionResult.outcome,
+                        output: part.codeExecutionResult.output
+                      },
+                      providerExecuted: true
+                    });
+                    lastCodeExecutionToolCallId = void 0;
+                  }
+                } else if ("text" in part && part.text != null && part.text.length > 0) {
+                  if (part.thought === true) {
+                    if (currentTextBlockId !== null) {
+                      controller.enqueue({
+                        type: "text-end",
+                        id: currentTextBlockId
+                      });
+                      currentTextBlockId = null;
+                    }
+                    if (currentReasoningBlockId === null) {
+                      currentReasoningBlockId = String(blockCounter++);
+                      controller.enqueue({
+                        type: "reasoning-start",
+                        id: currentReasoningBlockId,
+                        providerMetadata: part.thoughtSignature ? {
+                          [providerKey != null ? providerKey : "google"]: {
+                            thoughtSignature: part.thoughtSignature
+                          }
+                        } : void 0
+                      });
+                    }
+                    controller.enqueue({
+                      type: "reasoning-delta",
+                      id: currentReasoningBlockId,
+                      delta: part.text,
+                      providerMetadata: part.thoughtSignature ? {
+                        [providerKey != null ? providerKey : "google"]: {
+                          thoughtSignature: part.thoughtSignature
+                        }
+                      } : void 0
+                    });
+                  } else {
+                    if (currentReasoningBlockId !== null) {
+                      controller.enqueue({
+                        type: "reasoning-end",
+                        id: currentReasoningBlockId
+                      });
+                      currentReasoningBlockId = null;
+                    }
+                    if (currentTextBlockId === null) {
+                      currentTextBlockId = String(blockCounter++);
+                      controller.enqueue({
+                        type: "text-start",
+                        id: currentTextBlockId,
+                        providerMetadata: part.thoughtSignature ? {
+                          [providerKey != null ? providerKey : "google"]: {
+                            thoughtSignature: part.thoughtSignature
+                          }
+                        } : void 0
+                      });
+                    }
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: currentTextBlockId,
+                      delta: part.text,
+                      providerMetadata: part.thoughtSignature ? {
+                        [providerKey != null ? providerKey : "google"]: {
+                          thoughtSignature: part.thoughtSignature
+                        }
+                      } : void 0
+                    });
+                  }
+                } else if ("inlineData" in part) {
+                  controller.enqueue({
+                    type: "file",
+                    mediaType: part.inlineData.mimeType,
+                    data: part.inlineData.data
+                  });
+                }
+              }
+              const toolCallDeltas = getToolCallsFromParts({
+                parts: content.parts,
+                generateId: generateId3,
+                useToolCallId,
+                providerKey
+              });
+              if (toolCallDeltas != null) {
+                for (const toolCall of toolCallDeltas) {
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCall.toolCallId,
+                    toolName: toolCall.toolName,
+                    providerMetadata: toolCall.providerMetadata
+                  });
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: toolCall.toolCallId,
+                    delta: toolCall.args,
+                    providerMetadata: toolCall.providerMetadata
+                  });
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.toolCallId,
+                    providerMetadata: toolCall.providerMetadata
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: toolCall.toolCallId,
+                    toolName: toolCall.toolName,
+                    input: toolCall.args,
+                    providerMetadata: toolCall.providerMetadata
+                  });
+                  hasToolCalls = true;
+                }
+              }
+            }
+            if (candidate.finishReason != null) {
+              finishReason = mapGoogleGenerativeAIFinishReason({
+                finishReason: candidate.finishReason,
+                hasToolCalls
+              });
+              providerMetadata = {
+                [providerKey != null ? providerKey : "google"]: {
+                  promptFeedback: (_j = responseData.promptFeedback) != null ? _j : null,
+                  groundingMetadata: (_k = candidate.groundingMetadata) != null ? _k : null,
+                  urlContextMetadata: (_l = candidate.urlContextMetadata) != null ? _l : null,
+                  safetyRatings: (_m = candidate.safetyRatings) != null ? _m : null
+                }
+              };
+              if (usageMetadata != null) {
+                providerMetadata[providerKey != null ? providerKey : "google"].usageMetadata = usageMetadata;
+              }
+            }
+          },
+          flush(controller) {
+            if (currentTextBlockId !== null) {
+              controller.enqueue({
+                type: "text-end",
+                id: currentTextBlockId
+              });
+            }
+            if (currentReasoningBlockId !== null) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: currentReasoningBlockId
+              });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              providerMetadata
+            });
+          }
+        })
+      ),
+      response: { headers: responseHeaders },
+      request: { body }
+    };
+  }
+};
+function getToolCallsFromParts({
+  parts,
+  generateId: generateId3,
+  useToolCallId = false,
+  providerKey
+}) {
+  const functionCallParts = parts == null ? void 0 : parts.filter(
+    (part) => "functionCall" in part
+  );
+  return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
+    type: "tool-call",
+    // Use provided id for Claude models, generate for others
+    toolCallId: useToolCallId && part.functionCall.id ? part.functionCall.id : generateId3(),
+    toolName: part.functionCall.name,
+    args: JSON.stringify(part.functionCall.args),
+    providerMetadata: part.thoughtSignature ? {
+      [providerKey != null ? providerKey : "google"]: {
+        thoughtSignature: part.thoughtSignature
+      }
+    } : void 0
+  }));
+}
+function extractSources({
+  groundingMetadata,
+  generateId: generateId3
+}) {
+  var _a, _b, _c, _d, _e;
+  if (!(groundingMetadata == null ? void 0 : groundingMetadata.groundingChunks)) {
+    return void 0;
+  }
+  const sources = [];
+  for (const chunk of groundingMetadata.groundingChunks) {
+    if (chunk.web != null) {
+      sources.push({
+        type: "source",
+        sourceType: "url",
+        id: generateId3(),
+        url: chunk.web.uri,
+        title: (_a = chunk.web.title) != null ? _a : void 0
+      });
+    } else if (chunk.retrievedContext != null) {
+      const uri = chunk.retrievedContext.uri;
+      const fileSearchStore = chunk.retrievedContext.fileSearchStore;
+      if (uri && (uri.startsWith("http://") || uri.startsWith("https://"))) {
+        sources.push({
+          type: "source",
+          sourceType: "url",
+          id: generateId3(),
+          url: uri,
+          title: (_b = chunk.retrievedContext.title) != null ? _b : void 0
+        });
+      } else if (uri) {
+        const title = (_c = chunk.retrievedContext.title) != null ? _c : "Unknown Document";
+        let mediaType = "application/octet-stream";
+        let filename = void 0;
+        if (uri.endsWith(".pdf")) {
+          mediaType = "application/pdf";
+          filename = uri.split("/").pop();
+        } else if (uri.endsWith(".txt")) {
+          mediaType = "text/plain";
+          filename = uri.split("/").pop();
+        } else if (uri.endsWith(".docx")) {
+          mediaType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+          filename = uri.split("/").pop();
+        } else if (uri.endsWith(".doc")) {
+          mediaType = "application/msword";
+          filename = uri.split("/").pop();
+        } else if (uri.match(/\.(md|markdown)$/)) {
+          mediaType = "text/markdown";
+          filename = uri.split("/").pop();
+        } else {
+          filename = uri.split("/").pop();
+        }
+        sources.push({
+          type: "source",
+          sourceType: "document",
+          id: generateId3(),
+          mediaType,
+          title,
+          filename
+        });
+      } else if (fileSearchStore) {
+        const title = (_d = chunk.retrievedContext.title) != null ? _d : "Unknown Document";
+        sources.push({
+          type: "source",
+          sourceType: "document",
+          id: generateId3(),
+          mediaType: "application/octet-stream",
+          title,
+          filename: fileSearchStore.split("/").pop()
+        });
+      }
+    } else if (chunk.maps != null) {
+      if (chunk.maps.uri) {
+        sources.push({
+          type: "source",
+          sourceType: "url",
+          id: generateId3(),
+          url: chunk.maps.uri,
+          title: (_e = chunk.maps.title) != null ? _e : void 0
+        });
+      }
+    }
+  }
+  return sources.length > 0 ? sources : void 0;
+}
+var getGroundingMetadataSchema = () => import_v45.z.object({
+  webSearchQueries: import_v45.z.array(import_v45.z.string()).nullish(),
+  retrievalQueries: import_v45.z.array(import_v45.z.string()).nullish(),
+  searchEntryPoint: import_v45.z.object({ renderedContent: import_v45.z.string() }).nullish(),
+  groundingChunks: import_v45.z.array(
+    import_v45.z.object({
+      web: import_v45.z.object({ uri: import_v45.z.string(), title: import_v45.z.string().nullish() }).nullish(),
+      retrievedContext: import_v45.z.object({
+        uri: import_v45.z.string().nullish(),
+        title: import_v45.z.string().nullish(),
+        text: import_v45.z.string().nullish(),
+        fileSearchStore: import_v45.z.string().nullish()
+      }).nullish(),
+      maps: import_v45.z.object({
+        uri: import_v45.z.string().nullish(),
+        title: import_v45.z.string().nullish(),
+        text: import_v45.z.string().nullish(),
+        placeId: import_v45.z.string().nullish()
+      }).nullish()
+    })
+  ).nullish(),
+  groundingSupports: import_v45.z.array(
+    import_v45.z.object({
+      segment: import_v45.z.object({
+        startIndex: import_v45.z.number().nullish(),
+        endIndex: import_v45.z.number().nullish(),
+        text: import_v45.z.string().nullish()
+      }),
+      segment_text: import_v45.z.string().nullish(),
+      groundingChunkIndices: import_v45.z.array(import_v45.z.number()).nullish(),
+      supportChunkIndices: import_v45.z.array(import_v45.z.number()).nullish(),
+      confidenceScores: import_v45.z.array(import_v45.z.number()).nullish(),
+      confidenceScore: import_v45.z.array(import_v45.z.number()).nullish()
+    })
+  ).nullish(),
+  retrievalMetadata: import_v45.z.union([
+    import_v45.z.object({
+      webDynamicRetrievalScore: import_v45.z.number()
+    }),
+    import_v45.z.object({})
+  ]).nullish()
+});
+var getContentSchema = () => import_v45.z.object({
+  parts: import_v45.z.array(
+    import_v45.z.union([
+      // note: order matters since text can be fully empty
+      import_v45.z.object({
+        functionCall: import_v45.z.object({
+          name: import_v45.z.string(),
+          args: import_v45.z.unknown(),
+          id: import_v45.z.string().nullish()
+          // Claude models include tool call ID
+        }),
+        thoughtSignature: import_v45.z.string().nullish()
+      }),
+      import_v45.z.object({
+        inlineData: import_v45.z.object({
+          mimeType: import_v45.z.string(),
+          data: import_v45.z.string()
+        })
+      }),
+      import_v45.z.object({
+        executableCode: import_v45.z.object({
+          language: import_v45.z.string(),
+          code: import_v45.z.string()
+        }).nullish(),
+        codeExecutionResult: import_v45.z.object({
+          outcome: import_v45.z.string(),
+          output: import_v45.z.string()
+        }).nullish(),
+        text: import_v45.z.string().nullish(),
+        thought: import_v45.z.boolean().nullish(),
+        thoughtSignature: import_v45.z.string().nullish()
+      })
+    ])
+  ).nullish()
+});
+var getSafetyRatingSchema = () => import_v45.z.object({
+  category: import_v45.z.string().nullish(),
+  probability: import_v45.z.string().nullish(),
+  probabilityScore: import_v45.z.number().nullish(),
+  severity: import_v45.z.string().nullish(),
+  severityScore: import_v45.z.number().nullish(),
+  blocked: import_v45.z.boolean().nullish()
+});
+var usageSchema = import_v45.z.object({
+  cachedContentTokenCount: import_v45.z.number().nullish(),
+  thoughtsTokenCount: import_v45.z.number().nullish(),
+  promptTokenCount: import_v45.z.number().nullish(),
+  candidatesTokenCount: import_v45.z.number().nullish(),
+  totalTokenCount: import_v45.z.number().nullish(),
+  // https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1/GenerateContentResponse#TrafficType
+  trafficType: import_v45.z.string().nullish()
+});
+var getUrlContextMetadataSchema = () => import_v45.z.object({
+  urlMetadata: import_v45.z.array(
+    import_v45.z.object({
+      retrievedUrl: import_v45.z.string(),
+      urlRetrievalStatus: import_v45.z.string()
+    })
+  )
+});
+var responseSchema = (0, import_provider_utils6.lazySchema)(
+  () => (0, import_provider_utils6.zodSchema)(
+    import_v45.z.object({
+      candidates: import_v45.z.array(
+        import_v45.z.object({
+          content: getContentSchema().nullish().or(import_v45.z.object({}).strict()),
+          finishReason: import_v45.z.string().nullish(),
+          safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish(),
+          groundingMetadata: getGroundingMetadataSchema().nullish(),
+          urlContextMetadata: getUrlContextMetadataSchema().nullish()
+        })
+      ),
+      usageMetadata: usageSchema.nullish(),
+      promptFeedback: import_v45.z.object({
+        blockReason: import_v45.z.string().nullish(),
+        safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish()
+      }).nullish()
+    })
+  )
+);
+var getResponseContentSchema = () => import_v45.z.object({
+  candidates: import_v45.z.array(
+    import_v45.z.object({
+      content: getContentSchema().nullish(),
+      finishReason: import_v45.z.string().nullish(),
+      safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish(),
+      groundingMetadata: getGroundingMetadataSchema().nullish(),
+      urlContextMetadata: getUrlContextMetadataSchema().nullish()
+    })
+  ).nullish(),
+  usageMetadata: usageSchema.nullish(),
+  promptFeedback: import_v45.z.object({
+    blockReason: import_v45.z.string().nullish(),
+    safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish()
+  }).nullish(),
+  modelVersion: import_v45.z.string().nullish(),
+  responseId: import_v45.z.string().nullish()
+});
+var chunkSchema = (0, import_provider_utils6.lazySchema)(
+  () => (0, import_provider_utils6.zodSchema)(
+    import_v45.z.object({
+      // Cloud Assist wrapper fields
+      response: getResponseContentSchema().nullish(),
+      traceId: import_v45.z.string().nullish(),
+      // Also allow direct fields for compatibility
+      candidates: import_v45.z.array(
+        import_v45.z.object({
+          content: getContentSchema().nullish(),
+          finishReason: import_v45.z.string().nullish(),
+          safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish(),
+          groundingMetadata: getGroundingMetadataSchema().nullish(),
+          urlContextMetadata: getUrlContextMetadataSchema().nullish()
+        })
+      ).nullish(),
+      usageMetadata: usageSchema.nullish(),
+      promptFeedback: import_v45.z.object({
+        blockReason: import_v45.z.string().nullish(),
+        safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish()
+      }).nullish()
+    })
+  )
+);
+
+// src/tool/code-execution.ts
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_v46 = require("zod/v4");
+var codeExecution = (0, import_provider_utils7.createProviderDefinedToolFactoryWithOutputSchema)({
+  id: "google.code_execution",
+  name: "code_execution",
+  inputSchema: import_v46.z.object({
+    language: import_v46.z.string().describe("The programming language of the code."),
+    code: import_v46.z.string().describe("The code to be executed.")
+  }),
+  outputSchema: import_v46.z.object({
+    outcome: import_v46.z.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
+    output: import_v46.z.string().describe("The output from the code execution.")
+  })
+});
+
+// src/tool/enterprise-web-search.ts
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_v47 = require("zod/v4");
+var enterpriseWebSearch = (0, import_provider_utils8.createProviderDefinedToolFactory)({
+  id: "google.enterprise_web_search",
+  name: "enterprise_web_search",
+  inputSchema: (0, import_provider_utils8.lazySchema)(() => (0, import_provider_utils8.zodSchema)(import_v47.z.object({})))
+});
+
+// src/tool/file-search.ts
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_v48 = require("zod/v4");
+var fileSearchArgsBaseSchema = import_v48.z.object({
+  /** The names of the file_search_stores to retrieve from.
+   *  Example: `fileSearchStores/my-file-search-store-123`
+   */
+  fileSearchStoreNames: import_v48.z.array(import_v48.z.string()).describe(
+    "The names of the file_search_stores to retrieve from. Example: `fileSearchStores/my-file-search-store-123`"
+  ),
+  /** The number of file search retrieval chunks to retrieve. */
+  topK: import_v48.z.number().int().positive().describe("The number of file search retrieval chunks to retrieve.").optional(),
+  /** Metadata filter to apply to the file search retrieval documents.
+   *  See https://google.aip.dev/160 for the syntax of the filter expression.
+   */
+  metadataFilter: import_v48.z.string().describe(
+    "Metadata filter to apply to the file search retrieval documents. See https://google.aip.dev/160 for the syntax of the filter expression."
+  ).optional()
+}).passthrough();
+var fileSearchArgsSchema = (0, import_provider_utils9.lazySchema)(
+  () => (0, import_provider_utils9.zodSchema)(fileSearchArgsBaseSchema)
+);
+var fileSearch = (0, import_provider_utils9.createProviderDefinedToolFactory)({
+  id: "google.file_search",
+  name: "file_search",
+  inputSchema: fileSearchArgsSchema
+});
+
+// src/tool/google-maps.ts
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_v49 = require("zod/v4");
+var googleMaps = (0, import_provider_utils10.createProviderDefinedToolFactory)({
+  id: "google.google_maps",
+  name: "google_maps",
+  inputSchema: (0, import_provider_utils10.lazySchema)(() => (0, import_provider_utils10.zodSchema)(import_v49.z.object({})))
+});
+
+// src/tool/google-search.ts
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
+var import_v410 = require("zod/v4");
+var googleSearch = (0, import_provider_utils11.createProviderDefinedToolFactory)({
+  id: "google.google_search",
+  name: "google_search",
+  inputSchema: (0, import_provider_utils11.lazySchema)(
+    () => (0, import_provider_utils11.zodSchema)(
+      import_v410.z.object({
+        mode: import_v410.z.enum(["MODE_DYNAMIC", "MODE_UNSPECIFIED"]).default("MODE_UNSPECIFIED"),
+        dynamicThreshold: import_v410.z.number().default(1)
+      })
+    )
+  )
+});
+
+// src/tool/url-context.ts
+var import_provider_utils12 = require("@ai-sdk/provider-utils");
+var import_v411 = require("zod/v4");
+var urlContext = (0, import_provider_utils12.createProviderDefinedToolFactory)({
+  id: "google.url_context",
+  name: "url_context",
+  inputSchema: (0, import_provider_utils12.lazySchema)(() => (0, import_provider_utils12.zodSchema)(import_v411.z.object({})))
+});
+
+// src/tool/vertex-rag-store.ts
+var import_provider_utils13 = require("@ai-sdk/provider-utils");
+var import_v412 = require("zod/v4");
+var vertexRagStore = (0, import_provider_utils13.createProviderDefinedToolFactory)({
+  id: "google.vertex_rag_store",
+  name: "vertex_rag_store",
+  inputSchema: import_v412.z.object({
+    ragCorpus: import_v412.z.string(),
+    topK: import_v412.z.number().optional()
+  })
+});
+
+// src/google-tools.ts
+var googleTools = {
+  /**
+   * Creates a Google search tool that gives Google direct access to real-time web content.
+   * Must have name "google_search".
+   */
+  googleSearch,
+  /**
+   * Creates an Enterprise Web Search tool for grounding responses using a compliance-focused web index.
+   * Designed for highly-regulated industries (finance, healthcare, public sector).
+   * Does not log customer data and supports VPC service controls.
+   * Must have name "enterprise_web_search".
+   *
+   * @note Only available on Vertex AI. Requires Gemini 2.0 or newer.
+   *
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+   */
+  enterpriseWebSearch,
+  /**
+   * Creates a Google Maps grounding tool that gives the model access to Google Maps data.
+   * Must have name "google_maps".
+   *
+   * @see https://ai.google.dev/gemini-api/docs/maps-grounding
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
+   */
+  googleMaps,
+  /**
+   * Creates a URL context tool that gives Google direct access to real-time web content.
+   * Must have name "url_context".
+   */
+  urlContext,
+  /**
+   * Enables Retrieval Augmented Generation (RAG) via the Gemini File Search tool.
+   * Must have name "file_search".
+   *
+   * @param fileSearchStoreNames - Fully-qualified File Search store resource names.
+   * @param metadataFilter - Optional filter expression to restrict the files that can be retrieved.
+   * @param topK - Optional result limit for the number of chunks returned from File Search.
+   *
+   * @see https://ai.google.dev/gemini-api/docs/file-search
+   */
+  fileSearch,
+  /**
+   * A tool that enables the model to generate and run Python code.
+   * Must have name "code_execution".
+   *
+   * @note Ensure the selected model supports Code Execution.
+   * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
+   *
+   * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
+   */
+  codeExecution,
+  /**
+   * Creates a Vertex RAG Store tool that enables the model to perform RAG searches against a Vertex RAG Store.
+   * Must have name "vertex_rag_store".
+   */
+  vertexRagStore
+};
+
+// src/google-generative-ai-image-model.ts
+var import_provider_utils14 = require("@ai-sdk/provider-utils");
+var import_v413 = require("zod/v4");
+var GoogleGenerativeAIImageModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.specificationVersion = "v2";
+  }
+  get maxImagesPerCall() {
+    var _a;
+    return (_a = this.settings.maxImagesPerCall) != null ? _a : 4;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    const {
+      prompt,
+      n = 1,
+      size = "1024x1024",
+      aspectRatio = "1:1",
+      seed,
+      providerOptions,
+      headers,
+      abortSignal
+    } = options;
+    const warnings = [];
+    if (size != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "size",
+        details: "This model does not support the `size` option. Use `aspectRatio` instead."
+      });
+    }
+    if (seed != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "seed",
+        details: "This model does not support the `seed` option through this provider."
+      });
+    }
+    const providerKey = getProviderKey(providerOptions);
+    const googleOptions = await (0, import_provider_utils14.parseProviderOptions)({
+      provider: providerKey != null ? providerKey : "google",
+      providerOptions,
+      schema: googleImageProviderOptionsSchema
+    });
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const parameters = {
+      sampleCount: n
+    };
+    if (aspectRatio != null) {
+      parameters.aspectRatio = aspectRatio;
+    }
+    if (googleOptions) {
+      Object.assign(parameters, googleOptions);
+    }
+    const body = {
+      instances: [{ prompt }],
+      parameters
+    };
+    const { responseHeaders, value: response } = await (0, import_provider_utils14.postJsonToApi)({
+      url: `${this.config.baseURL}/models/${this.modelId}:predict`,
+      headers: (0, import_provider_utils14.combineHeaders)(await (0, import_provider_utils14.resolve)(this.config.headers), headers),
+      body,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils14.createJsonResponseHandler)(
+        googleImageResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      images: response.predictions.map(
+        (p) => p.bytesBase64Encoded
+      ),
+      warnings: warnings != null ? warnings : [],
+      providerMetadata: {
+        [providerKey != null ? providerKey : "google"]: {
+          images: response.predictions.map((prediction) => ({
+            // Add any prediction-specific metadata here
+          }))
+        }
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      }
+    };
+  }
+};
+var googleImageResponseSchema = (0, import_provider_utils14.lazySchema)(
+  () => (0, import_provider_utils14.zodSchema)(
+    import_v413.z.object({
+      predictions: import_v413.z.array(import_v413.z.object({ bytesBase64Encoded: import_v413.z.string() })).default([])
+    })
+  )
+);
+var googleImageProviderOptionsSchema = (0, import_provider_utils14.lazySchema)(
+  () => (0, import_provider_utils14.zodSchema)(
+    import_v413.z.object({
+      personGeneration: import_v413.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      aspectRatio: import_v413.z.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).nullish()
+    })
+  )
+);
+
+// src/google-provider.ts
+function createGoogleGenerativeAI(options = {}) {
+  var _a, _b;
+  const baseURL = (_a = (0, import_provider_utils15.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://cloudcode-pa.googleapis.com";
+  const providerName = (_b = options.name) != null ? _b : "cloudassist";
+  const getHeaders = () => (0, import_provider_utils15.withUserAgentSuffix)(
+    {
+      Authorization: `Bearer ${(0, import_provider_utils15.loadApiKey)({
+        apiKey: options.apiKey,
+        environmentVariableName: "GOOGLE_CLOUD_ACCESS_TOKEN",
+        description: "Google Cloud Access Token"
+      })}`,
+      ...options.headers
+    },
+    `ai-sdk/google-cloudassist/${VERSION}`
+  );
+  const createChatModel = (modelId) => {
+    var _a2;
+    return new GoogleGenerativeAILanguageModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils15.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 provider = function(modelId) {
+    if (new.target) {
+      throw new Error(
+        "The Google Generative AI model function cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(modelId);
+  };
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.generativeAI = createChatModel;
+  provider.embedding = createEmbeddingModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.tools = googleTools;
+  return provider;
+}
+var google = createGoogleGenerativeAI();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION,
+  createGoogleGenerativeAI,
+  google
+});
+//# sourceMappingURL=index.js.map