@ai-sdk/google 3.0.19 → 3.0.21

package/dist/index.mjs

@@ -7,7 +7,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.19" : "0.0.0-test";
+var VERSION = true ? "3.0.21" : "0.0.0-test";
 
 // src/google-generative-ai-embedding-model.ts
 import {
@@ -1927,6 +1927,271 @@ var googleImageProviderOptionsSchema = lazySchema11(
   )
 );
 
+// src/google-generative-ai-video-model.ts
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  delay,
+  getFromApi,
+  lazySchema as lazySchema12,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
+var GoogleGenerativeAIVideoModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get maxVideosPerCall() {
+    return 4;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    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 warnings = [];
+    const googleOptions = await parseProviderOptions4({
+      provider: "google",
+      providerOptions: options.providerOptions,
+      schema: googleVideoProviderOptionsSchema
+    });
+    const instances = [{}];
+    const instance = instances[0];
+    if (options.prompt != null) {
+      instance.prompt = options.prompt;
+    }
+    if (options.image != null) {
+      if (options.image.type === "url") {
+        warnings.push({
+          type: "unsupported",
+          feature: "URL-based image input",
+          details: "Google Generative AI video models require base64-encoded images. URL will be ignored."
+        });
+      } else {
+        const base64Data = typeof options.image.data === "string" ? options.image.data : convertUint8ArrayToBase64(options.image.data);
+        instance.image = {
+          inlineData: {
+            mimeType: options.image.mediaType || "image/png",
+            data: base64Data
+          }
+        };
+      }
+    }
+    if ((googleOptions == null ? void 0 : googleOptions.referenceImages) != null) {
+      instance.referenceImages = googleOptions.referenceImages.map((refImg) => {
+        if (refImg.bytesBase64Encoded) {
+          return {
+            inlineData: {
+              mimeType: "image/png",
+              data: refImg.bytesBase64Encoded
+            }
+          };
+        } else if (refImg.gcsUri) {
+          return {
+            gcsUri: refImg.gcsUri
+          };
+        }
+        return refImg;
+      });
+    }
+    const parameters = {
+      sampleCount: options.n
+    };
+    if (options.aspectRatio) {
+      parameters.aspectRatio = options.aspectRatio;
+    }
+    if (options.resolution) {
+      const resolutionMap = {
+        "1280x720": "720p",
+        "1920x1080": "1080p",
+        "3840x2160": "4k"
+      };
+      parameters.resolution = resolutionMap[options.resolution] || options.resolution;
+    }
+    if (options.duration) {
+      parameters.durationSeconds = options.duration;
+    }
+    if (options.seed) {
+      parameters.seed = options.seed;
+    }
+    if (googleOptions != null) {
+      const opts = googleOptions;
+      if (opts.personGeneration !== void 0 && opts.personGeneration !== null) {
+        parameters.personGeneration = opts.personGeneration;
+      }
+      if (opts.negativePrompt !== void 0 && opts.negativePrompt !== null) {
+        parameters.negativePrompt = opts.negativePrompt;
+      }
+      for (const [key, value] of Object.entries(opts)) {
+        if (![
+          "pollIntervalMs",
+          "pollTimeoutMs",
+          "personGeneration",
+          "negativePrompt",
+          "referenceImages"
+        ].includes(key)) {
+          parameters[key] = value;
+        }
+      }
+    }
+    const { value: operation } = await postJsonToApi4({
+      url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
+      headers: combineHeaders4(
+        await resolve4(this.config.headers),
+        options.headers
+      ),
+      body: {
+        instances,
+        parameters
+      },
+      successfulResponseHandler: createJsonResponseHandler4(
+        googleOperationSchema
+      ),
+      failedResponseHandler: googleFailedResponseHandler,
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const operationName = operation.name;
+    if (!operationName) {
+      throw new AISDKError({
+        name: "GOOGLE_VIDEO_GENERATION_ERROR",
+        message: "No operation name returned from API"
+      });
+    }
+    const pollIntervalMs = (_d = googleOptions == null ? void 0 : googleOptions.pollIntervalMs) != null ? _d : 1e4;
+    const pollTimeoutMs = (_e = googleOptions == null ? void 0 : googleOptions.pollTimeoutMs) != null ? _e : 6e5;
+    const startTime = Date.now();
+    let finalOperation = operation;
+    let responseHeaders;
+    while (!finalOperation.done) {
+      if (Date.now() - startTime > pollTimeoutMs) {
+        throw new AISDKError({
+          name: "GOOGLE_VIDEO_GENERATION_TIMEOUT",
+          message: `Video generation timed out after ${pollTimeoutMs}ms`
+        });
+      }
+      await delay(pollIntervalMs);
+      if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
+        throw new AISDKError({
+          name: "GOOGLE_VIDEO_GENERATION_ABORTED",
+          message: "Video generation request was aborted"
+        });
+      }
+      const { value: statusOperation, responseHeaders: pollHeaders } = await getFromApi({
+        url: `${this.config.baseURL}/${operationName}`,
+        headers: combineHeaders4(
+          await resolve4(this.config.headers),
+          options.headers
+        ),
+        successfulResponseHandler: createJsonResponseHandler4(
+          googleOperationSchema
+        ),
+        failedResponseHandler: googleFailedResponseHandler,
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch
+      });
+      finalOperation = statusOperation;
+      responseHeaders = pollHeaders;
+    }
+    if (finalOperation.error) {
+      throw new AISDKError({
+        name: "GOOGLE_VIDEO_GENERATION_FAILED",
+        message: `Video generation failed: ${finalOperation.error.message}`
+      });
+    }
+    const response = finalOperation.response;
+    if (!((_g = response == null ? void 0 : response.generateVideoResponse) == null ? void 0 : _g.generatedSamples) || response.generateVideoResponse.generatedSamples.length === 0) {
+      throw new AISDKError({
+        name: "GOOGLE_VIDEO_GENERATION_ERROR",
+        message: `No videos in response. Response: ${JSON.stringify(finalOperation)}`
+      });
+    }
+    const videos = [];
+    const videoMetadata = [];
+    const resolvedHeaders = await resolve4(this.config.headers);
+    const apiKey = resolvedHeaders == null ? void 0 : resolvedHeaders["x-goog-api-key"];
+    for (const generatedSample of response.generateVideoResponse.generatedSamples) {
+      if ((_h = generatedSample.video) == null ? void 0 : _h.uri) {
+        const urlWithAuth = apiKey ? `${generatedSample.video.uri}${generatedSample.video.uri.includes("?") ? "&" : "?"}key=${apiKey}` : generatedSample.video.uri;
+        videos.push({
+          type: "url",
+          url: urlWithAuth,
+          mediaType: "video/mp4"
+        });
+        videoMetadata.push({
+          uri: generatedSample.video.uri
+        });
+      }
+    }
+    if (videos.length === 0) {
+      throw new AISDKError({
+        name: "GOOGLE_VIDEO_GENERATION_ERROR",
+        message: "No valid videos in response"
+      });
+    }
+    return {
+      videos,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      },
+      providerMetadata: {
+        google: {
+          videos: videoMetadata
+        }
+      }
+    };
+  }
+};
+var googleOperationSchema = z14.object({
+  name: z14.string().nullish(),
+  done: z14.boolean().nullish(),
+  error: z14.object({
+    code: z14.number().nullish(),
+    message: z14.string(),
+    status: z14.string().nullish()
+  }).nullish(),
+  response: z14.object({
+    generateVideoResponse: z14.object({
+      generatedSamples: z14.array(
+        z14.object({
+          video: z14.object({
+            uri: z14.string().nullish()
+          }).nullish()
+        })
+      ).nullish()
+    }).nullish()
+  }).nullish()
+});
+var googleVideoProviderOptionsSchema = lazySchema12(
+  () => zodSchema12(
+    z14.object({
+      pollIntervalMs: z14.number().positive().nullish(),
+      pollTimeoutMs: z14.number().positive().nullish(),
+      personGeneration: z14.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      negativePrompt: z14.string().nullish(),
+      referenceImages: z14.array(
+        z14.object({
+          bytesBase64Encoded: z14.string().nullish(),
+          gcsUri: z14.string().nullish()
+        })
+      ).nullish()
+    }).passthrough()
+  )
+);
+
 // src/google-provider.ts
 function createGoogleGenerativeAI(options = {}) {
   var _a, _b;
@@ -1977,6 +2242,16 @@ function createGoogleGenerativeAI(options = {}) {
     headers: getHeaders,
     fetch: options.fetch
   });
+  const createVideoModel = (modelId) => {
+    var _a2;
+    return new GoogleGenerativeAIVideoModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2
+    });
+  };
   const provider = function(modelId) {
     if (new.target) {
       throw new Error(
@@ -1995,6 +2270,7 @@ function createGoogleGenerativeAI(options = {}) {
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.image = createImageModel;
   provider.imageModel = createImageModel;
+  provider.video = createVideoModel;
   provider.tools = googleTools;
   return provider;
 }