@ai-sdk/google 2.0.0-canary.0 → 2.0.0-canary.2

package/dist/index.js

@@ -26,12 +26,95 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/google-provider.ts
+var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
-// src/google-generative-ai-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+// src/google-generative-ai-embedding-model.ts
+var import_provider = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_zod2 = require("zod");
 
+// src/google-error.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_zod = require("zod");
+var googleErrorDataSchema = import_zod.z.object({
+  error: import_zod.z.object({
+    code: import_zod.z.number().nullable(),
+    message: import_zod.z.string(),
+    status: import_zod.z.string()
+  })
+});
+var googleFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+  errorSchema: googleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/google-generative-ai-embedding-model.ts
+var GoogleGenerativeAIEmbeddingModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v1";
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get maxEmbeddingsPerCall() {
+    return 2048;
+  }
+  get supportsParallelCalls() {
+    return true;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal
+  }) {
+    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_utils2.combineHeaders)(
+      await (0, import_provider_utils2.resolve)(this.config.headers),
+      headers
+    );
+    const { responseHeaders, value: response } = await (0, import_provider_utils2.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: this.settings.outputDimensionality
+        }))
+      },
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+        googleGenerativeAITextEmbeddingResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.embeddings.map((item) => item.values),
+      usage: void 0,
+      rawResponse: { headers: responseHeaders }
+    };
+  }
+};
+var googleGenerativeAITextEmbeddingResponseSchema = import_zod2.z.object({
+  embeddings: import_zod2.z.array(import_zod2.z.object({ values: import_zod2.z.array(import_zod2.z.number()) }))
+});
+
+// src/google-generative-ai-language-model.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_zod3 = require("zod");
+
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
   if (isEmptyObjectSchema(jsonSchema)) {
@@ -130,8 +213,8 @@ function isEmptyObjectSchema(jsonSchema) {
 }
 
 // src/convert-to-google-generative-ai-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 function convertToGoogleGenerativeAIMessages(prompt) {
   var _a, _b;
   const systemInstructionParts = [];
@@ -141,7 +224,7 @@ function convertToGoogleGenerativeAIMessages(prompt) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new import_provider.UnsupportedFunctionalityError({
+          throw new import_provider2.UnsupportedFunctionalityError({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -167,7 +250,7 @@ function convertToGoogleGenerativeAIMessages(prompt) {
                 } : {
                   inlineData: {
                     mimeType: (_b = part.mimeType) != null ? _b : "image/jpeg",
-                    data: (0, import_provider_utils.convertUint8ArrayToBase64)(part.image)
+                    data: (0, import_provider_utils3.convertUint8ArrayToBase64)(part.image)
                   }
                 }
               );
@@ -205,12 +288,12 @@ function convertToGoogleGenerativeAIMessages(prompt) {
               }
               case "file": {
                 if (part.mimeType !== "image/png") {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new import_provider2.UnsupportedFunctionalityError({
                     functionality: "Only PNG images are supported in assistant messages"
                   });
                 }
                 if (part.data instanceof URL) {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new import_provider2.UnsupportedFunctionalityError({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
@@ -263,23 +346,8 @@ function getModelPath(modelId) {
   return modelId.includes("/") ? modelId : `models/${modelId}`;
 }
 
-// src/google-error.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod = require("zod");
-var googleErrorDataSchema = import_zod.z.object({
-  error: import_zod.z.object({
-    code: import_zod.z.number().nullable(),
-    message: import_zod.z.string(),
-    status: import_zod.z.string()
-  })
-});
-var googleFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
-  errorSchema: googleErrorDataSchema,
-  errorToMessage: (data) => data.error.message
-});
-
 // src/google-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
+var import_provider3 = require("@ai-sdk/provider");
 function prepareTools(mode, useSearchGrounding, dynamicRetrievalConfig, modelId) {
   var _a, _b;
   const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
@@ -351,7 +419,7 @@ function prepareTools(mode, useSearchGrounding, dynamicRetrievalConfig, modelId)
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new import_provider3.UnsupportedFunctionalityError({
         functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -388,7 +456,7 @@ function mapGoogleGenerativeAIFinishReason({
 // src/google-generative-ai-language-model.ts
 var GoogleGenerativeAILanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
     this.defaultObjectGenerationMode = "json";
     this.supportsImageUrls = false;
     this.modelId = modelId;
@@ -419,12 +487,10 @@ var GoogleGenerativeAILanguageModel = class {
     var _a, _b;
     const type = mode.type;
     const warnings = [];
-    const googleOptions = (0, import_provider_utils3.parseProviderOptions)({
+    const googleOptions = (0, import_provider_utils4.parseProviderOptions)({
       provider: "google",
       providerOptions: providerMetadata,
-      schema: import_zod2.z.object({
-        responseModalities: import_zod2.z.array(import_zod2.z.enum(["TEXT", "IMAGE"])).nullish()
-      })
+      schema: googleGenerativeAIProviderOptionsSchema
     });
     const generationConfig = {
       // standardized settings:
@@ -523,22 +589,22 @@ var GoogleGenerativeAILanguageModel = class {
     var _a, _b, _c, _d, _e;
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const mergedHeaders = (0, import_provider_utils3.combineHeaders)(
-      await (0, import_provider_utils3.resolve)(this.config.headers),
+    const mergedHeaders = (0, import_provider_utils4.combineHeaders)(
+      await (0, import_provider_utils4.resolve)(this.config.headers),
       options.headers
     );
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await (0, import_provider_utils4.postJsonToApi)({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:generateContent`,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(responseSchema),
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(responseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -584,18 +650,18 @@ var GoogleGenerativeAILanguageModel = class {
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const headers = (0, import_provider_utils3.combineHeaders)(
-      await (0, import_provider_utils3.resolve)(this.config.headers),
+    const headers = (0, import_provider_utils4.combineHeaders)(
+      await (0, import_provider_utils4.resolve)(this.config.headers),
       options.headers
     );
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:streamGenerateContent?alt=sse`,
       headers,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(chunkSchema),
+      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(chunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -746,160 +812,98 @@ function extractSources({
     title: chunk.web.title
   }));
 }
-var contentSchema = import_zod2.z.object({
-  role: import_zod2.z.string(),
-  parts: import_zod2.z.array(
-    import_zod2.z.union([
-      import_zod2.z.object({
-        text: import_zod2.z.string()
+var contentSchema = import_zod3.z.object({
+  role: import_zod3.z.string(),
+  parts: import_zod3.z.array(
+    import_zod3.z.union([
+      import_zod3.z.object({
+        text: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        functionCall: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          args: import_zod2.z.unknown()
+      import_zod3.z.object({
+        functionCall: import_zod3.z.object({
+          name: import_zod3.z.string(),
+          args: import_zod3.z.unknown()
         })
       }),
-      import_zod2.z.object({
-        inlineData: import_zod2.z.object({
-          mimeType: import_zod2.z.string(),
-          data: import_zod2.z.string()
+      import_zod3.z.object({
+        inlineData: import_zod3.z.object({
+          mimeType: import_zod3.z.string(),
+          data: import_zod3.z.string()
         })
       })
     ])
   ).nullish()
 });
-var groundingChunkSchema = import_zod2.z.object({
-  web: import_zod2.z.object({ uri: import_zod2.z.string(), title: import_zod2.z.string() }).nullish(),
-  retrievedContext: import_zod2.z.object({ uri: import_zod2.z.string(), title: import_zod2.z.string() }).nullish()
+var groundingChunkSchema = import_zod3.z.object({
+  web: import_zod3.z.object({ uri: import_zod3.z.string(), title: import_zod3.z.string() }).nullish(),
+  retrievedContext: import_zod3.z.object({ uri: import_zod3.z.string(), title: import_zod3.z.string() }).nullish()
 });
-var groundingMetadataSchema = import_zod2.z.object({
-  webSearchQueries: import_zod2.z.array(import_zod2.z.string()).nullish(),
-  retrievalQueries: import_zod2.z.array(import_zod2.z.string()).nullish(),
-  searchEntryPoint: import_zod2.z.object({ renderedContent: import_zod2.z.string() }).nullish(),
-  groundingChunks: import_zod2.z.array(groundingChunkSchema).nullish(),
-  groundingSupports: import_zod2.z.array(
-    import_zod2.z.object({
-      segment: import_zod2.z.object({
-        startIndex: import_zod2.z.number().nullish(),
-        endIndex: import_zod2.z.number().nullish(),
-        text: import_zod2.z.string().nullish()
+var groundingMetadataSchema = import_zod3.z.object({
+  webSearchQueries: import_zod3.z.array(import_zod3.z.string()).nullish(),
+  retrievalQueries: import_zod3.z.array(import_zod3.z.string()).nullish(),
+  searchEntryPoint: import_zod3.z.object({ renderedContent: import_zod3.z.string() }).nullish(),
+  groundingChunks: import_zod3.z.array(groundingChunkSchema).nullish(),
+  groundingSupports: import_zod3.z.array(
+    import_zod3.z.object({
+      segment: import_zod3.z.object({
+        startIndex: import_zod3.z.number().nullish(),
+        endIndex: import_zod3.z.number().nullish(),
+        text: import_zod3.z.string().nullish()
       }),
-      segment_text: import_zod2.z.string().nullish(),
-      groundingChunkIndices: import_zod2.z.array(import_zod2.z.number()).nullish(),
-      supportChunkIndices: import_zod2.z.array(import_zod2.z.number()).nullish(),
-      confidenceScores: import_zod2.z.array(import_zod2.z.number()).nullish(),
-      confidenceScore: import_zod2.z.array(import_zod2.z.number()).nullish()
+      segment_text: import_zod3.z.string().nullish(),
+      groundingChunkIndices: import_zod3.z.array(import_zod3.z.number()).nullish(),
+      supportChunkIndices: import_zod3.z.array(import_zod3.z.number()).nullish(),
+      confidenceScores: import_zod3.z.array(import_zod3.z.number()).nullish(),
+      confidenceScore: import_zod3.z.array(import_zod3.z.number()).nullish()
     })
   ).nullish(),
-  retrievalMetadata: import_zod2.z.union([
-    import_zod2.z.object({
-      webDynamicRetrievalScore: import_zod2.z.number()
+  retrievalMetadata: import_zod3.z.union([
+    import_zod3.z.object({
+      webDynamicRetrievalScore: import_zod3.z.number()
     }),
-    import_zod2.z.object({})
+    import_zod3.z.object({})
   ]).nullish()
 });
-var safetyRatingSchema = import_zod2.z.object({
-  category: import_zod2.z.string(),
-  probability: import_zod2.z.string(),
-  probabilityScore: import_zod2.z.number().nullish(),
-  severity: import_zod2.z.string().nullish(),
-  severityScore: import_zod2.z.number().nullish(),
-  blocked: import_zod2.z.boolean().nullish()
+var safetyRatingSchema = import_zod3.z.object({
+  category: import_zod3.z.string(),
+  probability: import_zod3.z.string(),
+  probabilityScore: import_zod3.z.number().nullish(),
+  severity: import_zod3.z.string().nullish(),
+  severityScore: import_zod3.z.number().nullish(),
+  blocked: import_zod3.z.boolean().nullish()
 });
-var responseSchema = import_zod2.z.object({
-  candidates: import_zod2.z.array(
-    import_zod2.z.object({
-      content: contentSchema.nullish().or(import_zod2.z.object({}).strict()),
-      finishReason: import_zod2.z.string().nullish(),
-      safetyRatings: import_zod2.z.array(safetyRatingSchema).nullish(),
+var responseSchema = import_zod3.z.object({
+  candidates: import_zod3.z.array(
+    import_zod3.z.object({
+      content: contentSchema.nullish().or(import_zod3.z.object({}).strict()),
+      finishReason: import_zod3.z.string().nullish(),
+      safetyRatings: import_zod3.z.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish()
     })
   ),
-  usageMetadata: import_zod2.z.object({
-    promptTokenCount: import_zod2.z.number().nullish(),
-    candidatesTokenCount: import_zod2.z.number().nullish(),
-    totalTokenCount: import_zod2.z.number().nullish()
+  usageMetadata: import_zod3.z.object({
+    promptTokenCount: import_zod3.z.number().nullish(),
+    candidatesTokenCount: import_zod3.z.number().nullish(),
+    totalTokenCount: import_zod3.z.number().nullish()
   }).nullish()
 });
-var chunkSchema = import_zod2.z.object({
-  candidates: import_zod2.z.array(
-    import_zod2.z.object({
+var chunkSchema = import_zod3.z.object({
+  candidates: import_zod3.z.array(
+    import_zod3.z.object({
       content: contentSchema.nullish(),
-      finishReason: import_zod2.z.string().nullish(),
-      safetyRatings: import_zod2.z.array(safetyRatingSchema).nullish(),
+      finishReason: import_zod3.z.string().nullish(),
+      safetyRatings: import_zod3.z.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish()
     })
   ).nullish(),
-  usageMetadata: import_zod2.z.object({
-    promptTokenCount: import_zod2.z.number().nullish(),
-    candidatesTokenCount: import_zod2.z.number().nullish(),
-    totalTokenCount: import_zod2.z.number().nullish()
+  usageMetadata: import_zod3.z.object({
+    promptTokenCount: import_zod3.z.number().nullish(),
+    candidatesTokenCount: import_zod3.z.number().nullish(),
+    totalTokenCount: import_zod3.z.number().nullish()
   }).nullish()
 });
-
-// src/google-generative-ai-embedding-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
-var GoogleGenerativeAIEmbeddingModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
-    this.modelId = modelId;
-    this.settings = settings;
-    this.config = config;
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  get maxEmbeddingsPerCall() {
-    return 2048;
-  }
-  get supportsParallelCalls() {
-    return true;
-  }
-  async doEmbed({
-    values,
-    headers,
-    abortSignal
-  }) {
-    if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider3.TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    const mergedHeaders = (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
-      headers
-    );
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.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: this.settings.outputDimensionality
-        }))
-      },
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-        googleGenerativeAITextEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      embeddings: response.embeddings.map((item) => item.values),
-      usage: void 0,
-      rawResponse: { headers: responseHeaders }
-    };
-  }
-};
-var googleGenerativeAITextEmbeddingResponseSchema = import_zod3.z.object({
-  embeddings: import_zod3.z.array(import_zod3.z.object({ values: import_zod3.z.array(import_zod3.z.number()) }))
+var googleGenerativeAIProviderOptionsSchema = import_zod3.z.object({
+  responseModalities: import_zod3.z.array(import_zod3.z.enum(["TEXT", "IMAGE"])).nullish()
 });
 
 // src/google-supported-file-url.ts
@@ -950,6 +954,9 @@ function createGoogleGenerativeAI(options = {}) {
   provider.embedding = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
   return provider;
 }
 var google = createGoogleGenerativeAI();