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

package/dist/index.mjs

@@ -1,21 +1,113 @@
 // src/google-provider.ts
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
 import {
   generateId,
   loadApiKey,
   withoutTrailingSlash
 } from "@ai-sdk/provider-utils";
 
-// src/google-generative-ai-language-model.ts
+// src/google-generative-ai-embedding-model.ts
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
 import {
   combineHeaders,
-  createEventSourceResponseHandler,
   createJsonResponseHandler,
-  parseProviderOptions,
   postJsonToApi,
   resolve
 } from "@ai-sdk/provider-utils";
 import { z as z2 } from "zod";
 
+// src/google-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+var googleErrorDataSchema = z.object({
+  error: z.object({
+    code: z.number().nullable(),
+    message: z.string(),
+    status: z.string()
+  })
+});
+var googleFailedResponseHandler = 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 TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const mergedHeaders = combineHeaders(
+      await resolve(this.config.headers),
+      headers
+    );
+    const { responseHeaders, value: response } = await 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: createJsonResponseHandler(
+        googleGenerativeAITextEmbeddingResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.embeddings.map((item) => item.values),
+      usage: void 0,
+      rawResponse: { headers: responseHeaders }
+    };
+  }
+};
+var googleGenerativeAITextEmbeddingResponseSchema = z2.object({
+  embeddings: z2.array(z2.object({ values: z2.array(z2.number()) }))
+});
+
+// src/google-generative-ai-language-model.ts
+import {
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  parseProviderOptions,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod";
+
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
   if (isEmptyObjectSchema(jsonSchema)) {
@@ -249,21 +341,6 @@ function getModelPath(modelId) {
   return modelId.includes("/") ? modelId : `models/${modelId}`;
 }
 
-// src/google-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z } from "zod";
-var googleErrorDataSchema = z.object({
-  error: z.object({
-    code: z.number().nullable(),
-    message: z.string(),
-    status: z.string()
-  })
-});
-var googleFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: googleErrorDataSchema,
-  errorToMessage: (data) => data.error.message
-});
-
 // src/google-prepare-tools.ts
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
@@ -376,7 +453,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;
@@ -410,9 +487,7 @@ var GoogleGenerativeAILanguageModel = class {
     const googleOptions = parseProviderOptions({
       provider: "google",
       providerOptions: providerMetadata,
-      schema: z2.object({
-        responseModalities: z2.array(z2.enum(["TEXT", "IMAGE"])).nullish()
-      })
+      schema: googleGenerativeAIProviderOptionsSchema
     });
     const generationConfig = {
       // standardized settings:
@@ -511,22 +586,22 @@ var GoogleGenerativeAILanguageModel = class {
     var _a, _b, _c, _d, _e;
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const mergedHeaders = combineHeaders(
-      await resolve(this.config.headers),
+    const mergedHeaders = combineHeaders2(
+      await resolve2(this.config.headers),
       options.headers
     );
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await postJsonToApi({
+    } = await postJsonToApi2({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:generateContent`,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(responseSchema),
+      successfulResponseHandler: createJsonResponseHandler2(responseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -572,11 +647,11 @@ var GoogleGenerativeAILanguageModel = class {
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const headers = combineHeaders(
-      await resolve(this.config.headers),
+    const headers = combineHeaders2(
+      await resolve2(this.config.headers),
       options.headers
     );
-    const { responseHeaders, value: response } = await postJsonToApi({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:streamGenerateContent?alt=sse`,
@@ -734,167 +809,98 @@ function extractSources({
     title: chunk.web.title
   }));
 }
-var contentSchema = z2.object({
-  role: z2.string(),
-  parts: z2.array(
-    z2.union([
-      z2.object({
-        text: z2.string()
+var contentSchema = z3.object({
+  role: z3.string(),
+  parts: z3.array(
+    z3.union([
+      z3.object({
+        text: z3.string()
       }),
-      z2.object({
-        functionCall: z2.object({
-          name: z2.string(),
-          args: z2.unknown()
+      z3.object({
+        functionCall: z3.object({
+          name: z3.string(),
+          args: z3.unknown()
         })
       }),
-      z2.object({
-        inlineData: z2.object({
-          mimeType: z2.string(),
-          data: z2.string()
+      z3.object({
+        inlineData: z3.object({
+          mimeType: z3.string(),
+          data: z3.string()
         })
       })
     ])
   ).nullish()
 });
-var groundingChunkSchema = z2.object({
-  web: z2.object({ uri: z2.string(), title: z2.string() }).nullish(),
-  retrievedContext: z2.object({ uri: z2.string(), title: z2.string() }).nullish()
+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 = z2.object({
-  webSearchQueries: z2.array(z2.string()).nullish(),
-  retrievalQueries: z2.array(z2.string()).nullish(),
-  searchEntryPoint: z2.object({ renderedContent: z2.string() }).nullish(),
-  groundingChunks: z2.array(groundingChunkSchema).nullish(),
-  groundingSupports: z2.array(
-    z2.object({
-      segment: z2.object({
-        startIndex: z2.number().nullish(),
-        endIndex: z2.number().nullish(),
-        text: z2.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: z2.string().nullish(),
-      groundingChunkIndices: z2.array(z2.number()).nullish(),
-      supportChunkIndices: z2.array(z2.number()).nullish(),
-      confidenceScores: z2.array(z2.number()).nullish(),
-      confidenceScore: z2.array(z2.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: z2.union([
-    z2.object({
-      webDynamicRetrievalScore: z2.number()
+  retrievalMetadata: z3.union([
+    z3.object({
+      webDynamicRetrievalScore: z3.number()
     }),
-    z2.object({})
+    z3.object({})
   ]).nullish()
 });
-var safetyRatingSchema = z2.object({
-  category: z2.string(),
-  probability: z2.string(),
-  probabilityScore: z2.number().nullish(),
-  severity: z2.string().nullish(),
-  severityScore: z2.number().nullish(),
-  blocked: z2.boolean().nullish()
+var safetyRatingSchema = z3.object({
+  category: z3.string(),
+  probability: z3.string(),
+  probabilityScore: z3.number().nullish(),
+  severity: z3.string().nullish(),
+  severityScore: z3.number().nullish(),
+  blocked: z3.boolean().nullish()
 });
-var responseSchema = z2.object({
-  candidates: z2.array(
-    z2.object({
-      content: contentSchema.nullish().or(z2.object({}).strict()),
-      finishReason: z2.string().nullish(),
-      safetyRatings: z2.array(safetyRatingSchema).nullish(),
+var responseSchema = z3.object({
+  candidates: z3.array(
+    z3.object({
+      content: contentSchema.nullish().or(z3.object({}).strict()),
+      finishReason: z3.string().nullish(),
+      safetyRatings: z3.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish()
     })
   ),
-  usageMetadata: z2.object({
-    promptTokenCount: z2.number().nullish(),
-    candidatesTokenCount: z2.number().nullish(),
-    totalTokenCount: z2.number().nullish()
+  usageMetadata: z3.object({
+    promptTokenCount: z3.number().nullish(),
+    candidatesTokenCount: z3.number().nullish(),
+    totalTokenCount: z3.number().nullish()
   }).nullish()
 });
-var chunkSchema = z2.object({
-  candidates: z2.array(
-    z2.object({
+var chunkSchema = z3.object({
+  candidates: z3.array(
+    z3.object({
       content: contentSchema.nullish(),
-      finishReason: z2.string().nullish(),
-      safetyRatings: z2.array(safetyRatingSchema).nullish(),
+      finishReason: z3.string().nullish(),
+      safetyRatings: z3.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish()
     })
   ).nullish(),
-  usageMetadata: z2.object({
-    promptTokenCount: z2.number().nullish(),
-    candidatesTokenCount: z2.number().nullish(),
-    totalTokenCount: z2.number().nullish()
+  usageMetadata: z3.object({
+    promptTokenCount: z3.number().nullish(),
+    candidatesTokenCount: z3.number().nullish(),
+    totalTokenCount: z3.number().nullish()
   }).nullish()
 });
-
-// src/google-generative-ai-embedding-model.ts
-import {
-  TooManyEmbeddingValuesForCallError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders2,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  postJsonToApi as postJsonToApi2,
-  resolve as resolve2
-} from "@ai-sdk/provider-utils";
-import { z as z3 } from "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 TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    const mergedHeaders = combineHeaders2(
-      await resolve2(this.config.headers),
-      headers
-    );
-    const { responseHeaders, value: response } = await postJsonToApi2({
-      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: createJsonResponseHandler2(
-        googleGenerativeAITextEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      embeddings: response.embeddings.map((item) => item.values),
-      usage: void 0,
-      rawResponse: { headers: responseHeaders }
-    };
-  }
-};
-var googleGenerativeAITextEmbeddingResponseSchema = z3.object({
-  embeddings: z3.array(z3.object({ values: z3.array(z3.number()) }))
+var googleGenerativeAIProviderOptionsSchema = z3.object({
+  responseModalities: z3.array(z3.enum(["TEXT", "IMAGE"])).nullish()
 });
 
 // src/google-supported-file-url.ts
@@ -945,6 +951,9 @@ function createGoogleGenerativeAI(options = {}) {
   provider.embedding = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
   return provider;
 }
 var google = createGoogleGenerativeAI();