@ai-sdk/google 2.0.17 → 2.0.18

package/dist/internal/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/internal/index.ts
@@ -28,7 +38,7 @@ module.exports = __toCommonJS(internal_exports);
 
 // src/google-generative-ai-language-model.ts
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+var z5 = __toESM(require("zod/v4"));
 
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
@@ -53,12 +63,9 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema) {
     enum: enumValues
   } = jsonSchema;
   const result = {};
-  if (description)
-    result.description = description;
-  if (required)
-    result.required = required;
-  if (format)
-    result.format = format;
+  if (description) result.description = description;
+  if (required) result.required = required;
+  if (format) result.format = format;
   if (constValue !== void 0) {
     result.enum = [constValue];
   }
@@ -304,12 +311,12 @@ function getModelPath(modelId) {
 
 // src/google-error.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var googleErrorDataSchema = 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 z = __toESM(require("zod/v4"));
+var googleErrorDataSchema = z.object({
+  error: z.object({
+    code: z.number().nullable(),
+    message: z.string(),
+    status: z.string()
   })
 });
 var googleFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
@@ -318,19 +325,19 @@ var googleFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResp
 });
 
 // src/google-generative-ai-options.ts
-var import_v42 = require("zod/v4");
-var googleGenerativeAIProviderOptions = import_v42.z.object({
-  responseModalities: import_v42.z.array(import_v42.z.enum(["TEXT", "IMAGE"])).optional(),
-  thinkingConfig: import_v42.z.object({
-    thinkingBudget: import_v42.z.number().optional(),
-    includeThoughts: import_v42.z.boolean().optional()
+var z2 = __toESM(require("zod/v4"));
+var googleGenerativeAIProviderOptions = z2.object({
+  responseModalities: z2.array(z2.enum(["TEXT", "IMAGE"])).optional(),
+  thinkingConfig: z2.object({
+    thinkingBudget: z2.number().optional(),
+    includeThoughts: z2.boolean().optional()
   }).optional(),
   /**
   Optional.
   The name of the cached content used as context to serve the prediction.
   Format: cachedContents/{cachedContent}
      */
-  cachedContent: import_v42.z.string().optional(),
+  cachedContent: z2.string().optional(),
   /**
    * Optional. Enable structured output. Default is true.
    *
@@ -339,13 +346,13 @@ var googleGenerativeAIProviderOptions = import_v42.z.object({
    * Google Generative AI uses. You can use this to disable
    * structured outputs if you need to.
    */
-  structuredOutputs: import_v42.z.boolean().optional(),
+  structuredOutputs: z2.boolean().optional(),
   /**
   Optional. A list of unique safety settings for blocking unsafe content.
    */
-  safetySettings: import_v42.z.array(
-    import_v42.z.object({
-      category: import_v42.z.enum([
+  safetySettings: z2.array(
+    z2.object({
+      category: z2.enum([
         "HARM_CATEGORY_UNSPECIFIED",
         "HARM_CATEGORY_HATE_SPEECH",
         "HARM_CATEGORY_DANGEROUS_CONTENT",
@@ -353,7 +360,7 @@ var googleGenerativeAIProviderOptions = import_v42.z.object({
         "HARM_CATEGORY_SEXUALLY_EXPLICIT",
         "HARM_CATEGORY_CIVIC_INTEGRITY"
       ]),
-      threshold: import_v42.z.enum([
+      threshold: z2.enum([
         "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
         "BLOCK_LOW_AND_ABOVE",
         "BLOCK_MEDIUM_AND_ABOVE",
@@ -363,7 +370,7 @@ var googleGenerativeAIProviderOptions = import_v42.z.object({
       ])
     })
   ).optional(),
-  threshold: import_v42.z.enum([
+  threshold: z2.enum([
     "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
     "BLOCK_LOW_AND_ABOVE",
     "BLOCK_MEDIUM_AND_ABOVE",
@@ -376,13 +383,13 @@ var googleGenerativeAIProviderOptions = import_v42.z.object({
    *
    * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
    */
-  audioTimestamp: import_v42.z.boolean().optional(),
+  audioTimestamp: z2.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_v42.z.record(import_v42.z.string(), import_v42.z.string()).optional()
+  labels: z2.record(z2.string(), z2.string()).optional()
 });
 
 // src/google-prepare-tools.ts
@@ -556,60 +563,60 @@ function mapGoogleGenerativeAIFinishReason({
 
 // src/tool/google-search.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
-var groundingChunkSchema = import_v43.z.object({
-  web: import_v43.z.object({ uri: import_v43.z.string(), title: import_v43.z.string() }).nullish(),
-  retrievedContext: import_v43.z.object({ uri: import_v43.z.string(), title: import_v43.z.string() }).nullish()
+var z3 = __toESM(require("zod/v4"));
+var groundingChunkSchema = z3.object({
+  web: z3.object({ uri: z3.string(), title: z3.string() }).nullish(),
+  retrievedContext: z3.object({ uri: z3.string(), title: z3.string() }).nullish()
 });
-var groundingMetadataSchema = import_v43.z.object({
-  webSearchQueries: import_v43.z.array(import_v43.z.string()).nullish(),
-  retrievalQueries: import_v43.z.array(import_v43.z.string()).nullish(),
-  searchEntryPoint: import_v43.z.object({ renderedContent: import_v43.z.string() }).nullish(),
-  groundingChunks: import_v43.z.array(groundingChunkSchema).nullish(),
-  groundingSupports: import_v43.z.array(
-    import_v43.z.object({
-      segment: import_v43.z.object({
-        startIndex: import_v43.z.number().nullish(),
-        endIndex: import_v43.z.number().nullish(),
-        text: import_v43.z.string().nullish()
+var groundingMetadataSchema = z3.object({
+  webSearchQueries: z3.array(z3.string()).nullish(),
+  retrievalQueries: z3.array(z3.string()).nullish(),
+  searchEntryPoint: z3.object({ renderedContent: z3.string() }).nullish(),
+  groundingChunks: z3.array(groundingChunkSchema).nullish(),
+  groundingSupports: z3.array(
+    z3.object({
+      segment: z3.object({
+        startIndex: z3.number().nullish(),
+        endIndex: z3.number().nullish(),
+        text: z3.string().nullish()
       }),
-      segment_text: import_v43.z.string().nullish(),
-      groundingChunkIndices: import_v43.z.array(import_v43.z.number()).nullish(),
-      supportChunkIndices: import_v43.z.array(import_v43.z.number()).nullish(),
-      confidenceScores: import_v43.z.array(import_v43.z.number()).nullish(),
-      confidenceScore: import_v43.z.array(import_v43.z.number()).nullish()
+      segment_text: z3.string().nullish(),
+      groundingChunkIndices: z3.array(z3.number()).nullish(),
+      supportChunkIndices: z3.array(z3.number()).nullish(),
+      confidenceScores: z3.array(z3.number()).nullish(),
+      confidenceScore: z3.array(z3.number()).nullish()
     })
   ).nullish(),
-  retrievalMetadata: import_v43.z.union([
-    import_v43.z.object({
-      webDynamicRetrievalScore: import_v43.z.number()
+  retrievalMetadata: z3.union([
+    z3.object({
+      webDynamicRetrievalScore: z3.number()
     }),
-    import_v43.z.object({})
+    z3.object({})
   ]).nullish()
 });
 var googleSearch = (0, import_provider_utils3.createProviderDefinedToolFactory)({
   id: "google.google_search",
   name: "google_search",
-  inputSchema: import_v43.z.object({
-    mode: import_v43.z.enum(["MODE_DYNAMIC", "MODE_UNSPECIFIED"]).default("MODE_UNSPECIFIED"),
-    dynamicThreshold: import_v43.z.number().default(1)
+  inputSchema: z3.object({
+    mode: z3.enum(["MODE_DYNAMIC", "MODE_UNSPECIFIED"]).default("MODE_UNSPECIFIED"),
+    dynamicThreshold: z3.number().default(1)
   })
 });
 
 // src/tool/url-context.ts
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var urlMetadataSchema = import_v44.z.object({
-  retrievedUrl: import_v44.z.string(),
-  urlRetrievalStatus: import_v44.z.string()
+var z4 = __toESM(require("zod/v4"));
+var urlMetadataSchema = z4.object({
+  retrievedUrl: z4.string(),
+  urlRetrievalStatus: z4.string()
 });
-var urlContextMetadataSchema = import_v44.z.object({
-  urlMetadata: import_v44.z.array(urlMetadataSchema)
+var urlContextMetadataSchema = z4.object({
+  urlMetadata: z4.array(urlMetadataSchema)
 });
 var urlContext = (0, import_provider_utils4.createProviderDefinedToolFactory)({
   id: "google.url_context",
   name: "url_context",
-  inputSchema: import_v44.z.object({})
+  inputSchema: z4.object({})
 });
 
 // src/google-generative-ai-language-model.ts
@@ -1104,100 +1111,100 @@ function extractSources({
     title: chunk.web.title
   }));
 }
-var contentSchema = import_v45.z.object({
-  parts: import_v45.z.array(
-    import_v45.z.union([
+var contentSchema = z5.object({
+  parts: z5.array(
+    z5.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()
+      z5.object({
+        functionCall: z5.object({
+          name: z5.string(),
+          args: z5.unknown()
         }),
-        thoughtSignature: import_v45.z.string().nullish()
+        thoughtSignature: z5.string().nullish()
       }),
-      import_v45.z.object({
-        inlineData: import_v45.z.object({
-          mimeType: import_v45.z.string(),
-          data: import_v45.z.string()
+      z5.object({
+        inlineData: z5.object({
+          mimeType: z5.string(),
+          data: z5.string()
         })
       }),
-      import_v45.z.object({
-        executableCode: import_v45.z.object({
-          language: import_v45.z.string(),
-          code: import_v45.z.string()
+      z5.object({
+        executableCode: z5.object({
+          language: z5.string(),
+          code: z5.string()
         }).nullish(),
-        codeExecutionResult: import_v45.z.object({
-          outcome: import_v45.z.string(),
-          output: import_v45.z.string()
+        codeExecutionResult: z5.object({
+          outcome: z5.string(),
+          output: z5.string()
         }).nullish(),
-        text: import_v45.z.string().nullish(),
-        thought: import_v45.z.boolean().nullish(),
-        thoughtSignature: import_v45.z.string().nullish()
+        text: z5.string().nullish(),
+        thought: z5.boolean().nullish(),
+        thoughtSignature: z5.string().nullish()
       })
     ])
   ).nullish()
 });
-var safetyRatingSchema = 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 safetyRatingSchema = z5.object({
+  category: z5.string().nullish(),
+  probability: z5.string().nullish(),
+  probabilityScore: z5.number().nullish(),
+  severity: z5.string().nullish(),
+  severityScore: z5.number().nullish(),
+  blocked: z5.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()
+var usageSchema = z5.object({
+  cachedContentTokenCount: z5.number().nullish(),
+  thoughtsTokenCount: z5.number().nullish(),
+  promptTokenCount: z5.number().nullish(),
+  candidatesTokenCount: z5.number().nullish(),
+  totalTokenCount: z5.number().nullish()
 });
-var responseSchema = import_v45.z.object({
-  candidates: import_v45.z.array(
-    import_v45.z.object({
-      content: contentSchema.nullish().or(import_v45.z.object({}).strict()),
-      finishReason: import_v45.z.string().nullish(),
-      safetyRatings: import_v45.z.array(safetyRatingSchema).nullish(),
+var responseSchema = z5.object({
+  candidates: z5.array(
+    z5.object({
+      content: contentSchema.nullish().or(z5.object({}).strict()),
+      finishReason: z5.string().nullish(),
+      safetyRatings: z5.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish(),
       urlContextMetadata: urlContextMetadataSchema.nullish()
     })
   ),
   usageMetadata: usageSchema.nullish(),
-  promptFeedback: import_v45.z.object({
-    blockReason: import_v45.z.string().nullish(),
-    safetyRatings: import_v45.z.array(safetyRatingSchema).nullish()
+  promptFeedback: z5.object({
+    blockReason: z5.string().nullish(),
+    safetyRatings: z5.array(safetyRatingSchema).nullish()
   }).nullish()
 });
-var chunkSchema = import_v45.z.object({
-  candidates: import_v45.z.array(
-    import_v45.z.object({
+var chunkSchema = z5.object({
+  candidates: z5.array(
+    z5.object({
       content: contentSchema.nullish(),
-      finishReason: import_v45.z.string().nullish(),
-      safetyRatings: import_v45.z.array(safetyRatingSchema).nullish(),
+      finishReason: z5.string().nullish(),
+      safetyRatings: z5.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish(),
       urlContextMetadata: urlContextMetadataSchema.nullish()
     })
   ).nullish(),
   usageMetadata: usageSchema.nullish(),
-  promptFeedback: import_v45.z.object({
-    blockReason: import_v45.z.string().nullish(),
-    safetyRatings: import_v45.z.array(safetyRatingSchema).nullish()
+  promptFeedback: z5.object({
+    blockReason: z5.string().nullish(),
+    safetyRatings: z5.array(safetyRatingSchema).nullish()
   }).nullish()
 });
 
 // src/tool/code-execution.ts
 var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
+var z6 = __toESM(require("zod/v4"));
 var codeExecution = (0, import_provider_utils6.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.")
+  inputSchema: z6.object({
+    language: z6.string().describe("The programming language of the code."),
+    code: z6.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.")
+  outputSchema: z6.object({
+    outcome: z6.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
+    output: z6.string().describe("The output from the code execution.")
   })
 });