@depup/ai-sdk__google 3.0.43-depup.0

package/src/google-generative-ai-options.ts

@@ -0,0 +1,198 @@
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type GoogleGenerativeAIModelId =
+  // Stable models
+  // https://ai.google.dev/gemini-api/docs/models/gemini
+  | 'gemini-2.0-flash'
+  | 'gemini-2.0-flash-001'
+  | 'gemini-2.0-flash-lite'
+  | 'gemini-2.0-flash-exp-image-generation'
+  | 'gemini-2.0-flash-lite-001'
+  | 'gemini-2.5-pro'
+  | 'gemini-2.5-flash'
+  | 'gemini-2.5-flash-image'
+  | 'gemini-2.5-flash-lite'
+  | 'gemini-2.5-flash-lite-preview-09-2025'
+  | 'gemini-2.5-flash-preview-tts'
+  | 'gemini-2.5-pro-preview-tts'
+  | 'gemini-2.5-flash-native-audio-latest'
+  | 'gemini-2.5-flash-native-audio-preview-09-2025'
+  | 'gemini-2.5-flash-native-audio-preview-12-2025'
+  | 'gemini-2.5-computer-use-preview-10-2025'
+  | 'gemini-3-pro-preview'
+  | 'gemini-3-pro-image-preview'
+  | 'gemini-3-flash-preview'
+  | 'gemini-3.1-pro-preview'
+  | 'gemini-3.1-pro-preview-customtools'
+  | 'gemini-3.1-flash-image-preview'
+  | 'gemini-3.1-flash-lite-preview'
+  // latest version
+  // https://ai.google.dev/gemini-api/docs/models#latest
+  | 'gemini-pro-latest'
+  | 'gemini-flash-latest'
+  | 'gemini-flash-lite-latest'
+  | 'deep-research-pro-preview-12-2025'
+  | 'nano-banana-pro-preview'
+  | 'aqa'
+  // Experimental models
+  // https://ai.google.dev/gemini-api/docs/models/experimental-models
+  | 'gemini-robotics-er-1.5-preview'
+  | 'gemma-3-1b-it'
+  | 'gemma-3-4b-it'
+  | 'gemma-3n-e4b-it'
+  | 'gemma-3n-e2b-it'
+  | 'gemma-3-12b-it'
+  | 'gemma-3-27b-it'
+  | (string & {});
+
+export const googleLanguageModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      responseModalities: z.array(z.enum(['TEXT', 'IMAGE'])).optional(),
+
+      thinkingConfig: z
+        .object({
+          thinkingBudget: z.number().optional(),
+          includeThoughts: z.boolean().optional(),
+          // https://ai.google.dev/gemini-api/docs/gemini-3?thinking=high#thinking_level
+          thinkingLevel: 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: 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: z.boolean().optional(),
+
+      /**
+       * Optional. A list of unique safety settings for blocking unsafe content.
+       */
+      safetySettings: z
+        .array(
+          z.object({
+            category: 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: z.enum([
+              'HARM_BLOCK_THRESHOLD_UNSPECIFIED',
+              'BLOCK_LOW_AND_ABOVE',
+              'BLOCK_MEDIUM_AND_ABOVE',
+              'BLOCK_ONLY_HIGH',
+              'BLOCK_NONE',
+              'OFF',
+            ]),
+          }),
+        )
+        .optional(),
+
+      threshold: 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: 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: z.record(z.string(), z.string()).optional(),
+
+      /**
+       * Optional. If specified, the media resolution specified will be used.
+       *
+       * https://ai.google.dev/api/generate-content#MediaResolution
+       */
+      mediaResolution: 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: z
+        .object({
+          aspectRatio: z
+            .enum([
+              '1:1',
+              '2:3',
+              '3:2',
+              '3:4',
+              '4:3',
+              '4:5',
+              '5:4',
+              '9:16',
+              '16:9',
+              '21:9',
+              '1:8',
+              '8:1',
+              '1:4',
+              '4:1',
+            ])
+            .optional(),
+          imageSize: z.enum(['1K', '2K', '4K', '512']).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: z
+        .object({
+          latLng: z
+            .object({
+              latitude: z.number(),
+              longitude: z.number(),
+            })
+            .optional(),
+        })
+        .optional(),
+    }),
+  ),
+);
+
+export type GoogleLanguageModelOptions = InferSchema<
+  typeof googleLanguageModelOptions
+>;

package/src/google-generative-ai-prompt.ts

@@ -0,0 +1,38 @@
+import {
+  GroundingMetadataSchema,
+  UrlContextMetadataSchema,
+} from './google-generative-ai-language-model';
+import { type SafetyRatingSchema } from './google-generative-ai-language-model';
+
+export type GoogleGenerativeAIPrompt = {
+  systemInstruction?: GoogleGenerativeAISystemInstruction;
+  contents: Array<GoogleGenerativeAIContent>;
+};
+
+export type GoogleGenerativeAISystemInstruction = {
+  parts: Array<{ text: string }>;
+};
+
+export type GoogleGenerativeAIContent = {
+  role: 'user' | 'model';
+  parts: Array<GoogleGenerativeAIContentPart>;
+};
+
+export type GoogleGenerativeAIContentPart =
+  | { text: string; thought?: boolean; thoughtSignature?: string }
+  | { inlineData: { mimeType: string; data: string } }
+  | { functionCall: { name: string; args: unknown }; thoughtSignature?: string }
+  | { functionResponse: { name: string; response: unknown } }
+  | { fileData: { mimeType: string; fileUri: string } };
+
+export type GoogleGenerativeAIGroundingMetadata = GroundingMetadataSchema;
+
+export type GoogleGenerativeAIUrlContextMetadata = UrlContextMetadataSchema;
+
+export type GoogleGenerativeAISafetyRating = SafetyRatingSchema;
+
+export interface GoogleGenerativeAIProviderMetadata {
+  groundingMetadata: GoogleGenerativeAIGroundingMetadata | null;
+  urlContextMetadata: GoogleGenerativeAIUrlContextMetadata | null;
+  safetyRatings: GoogleGenerativeAISafetyRating[] | null;
+}

package/src/google-generative-ai-video-model.ts

@@ -0,0 +1,374 @@
+import {
+  AISDKError,
+  type Experimental_VideoModelV3,
+  type SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler,
+  delay,
+  type FetchFunction,
+  getFromApi,
+  lazySchema,
+  parseProviderOptions,
+  postJsonToApi,
+  type Resolvable,
+  resolve,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { googleFailedResponseHandler } from './google-error';
+import type { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
+
+export type GoogleVideoModelOptions = {
+  // Polling configuration
+  pollIntervalMs?: number | null;
+  pollTimeoutMs?: number | null;
+
+  // Video generation options
+  personGeneration?: 'dont_allow' | 'allow_adult' | 'allow_all' | null;
+  negativePrompt?: string | null;
+
+  // Reference images (for style/asset reference)
+  referenceImages?: Array<{
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+  }> | null;
+
+  [key: string]: unknown; // For passthrough
+};
+
+interface GoogleGenerativeAIVideoModelConfig {
+  provider: string;
+  baseURL: string;
+  headers?: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class GoogleGenerativeAIVideoModel implements Experimental_VideoModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  get maxVideosPerCall(): number {
+    // Google supports multiple videos via sampleCount
+    return 4;
+  }
+
+  constructor(
+    readonly modelId: GoogleGenerativeAIVideoModelId,
+    private readonly config: GoogleGenerativeAIVideoModelConfig,
+  ) {}
+
+  async doGenerate(
+    options: Parameters<Experimental_VideoModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<Experimental_VideoModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const warnings: SharedV3Warning[] = [];
+
+    const googleOptions = (await parseProviderOptions({
+      provider: 'google',
+      providerOptions: options.providerOptions,
+      schema: googleVideoModelOptionsSchema,
+    })) as GoogleVideoModelOptions | undefined;
+
+    const instances: Array<Record<string, unknown>> = [{}];
+    const instance = instances[0];
+
+    if (options.prompt != null) {
+      instance.prompt = options.prompt;
+    }
+
+    // Handle image-to-video: convert image to base64
+    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?.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: Record<string, unknown> = {
+      sampleCount: options.n,
+    };
+
+    if (options.aspectRatio) {
+      parameters.aspectRatio = options.aspectRatio;
+    }
+
+    if (options.resolution) {
+      const resolutionMap: Record<string, string> = {
+        '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 as GoogleVideoModelOptions;
+
+      if (
+        opts.personGeneration !== undefined &&
+        opts.personGeneration !== null
+      ) {
+        parameters.personGeneration = opts.personGeneration;
+      }
+      if (opts.negativePrompt !== undefined && 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 postJsonToApi({
+      url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers,
+      ),
+      body: {
+        instances,
+        parameters,
+      },
+      successfulResponseHandler: createJsonResponseHandler(
+        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 = googleOptions?.pollIntervalMs ?? 10000; // 10 seconds (per Google docs)
+    const pollTimeoutMs = googleOptions?.pollTimeoutMs ?? 600000; // 10 minutes
+
+    const startTime = Date.now();
+    let finalOperation = operation;
+    let responseHeaders: Record<string, string> | undefined;
+
+    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 (options.abortSignal?.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: combineHeaders(
+            await resolve(this.config.headers),
+            options.headers,
+          ),
+          successfulResponseHandler: createJsonResponseHandler(
+            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 (
+      !response?.generateVideoResponse?.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: Array<{ type: 'url'; url: string; mediaType: string }> = [];
+    const videoMetadata: Array<{ uri: string }> = [];
+
+    // Get API key from headers to append to download URLs
+    const resolvedHeaders = await resolve(this.config.headers);
+    const apiKey = resolvedHeaders?.['x-goog-api-key'];
+
+    for (const generatedSample of response.generateVideoResponse
+      .generatedSamples) {
+      if (generatedSample.video?.uri) {
+        // Append API key to URL for authentication during download
+        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,
+        },
+      },
+    };
+  }
+}
+
+const googleOperationSchema = z.object({
+  name: z.string().nullish(),
+  done: z.boolean().nullish(),
+  error: z
+    .object({
+      code: z.number().nullish(),
+      message: z.string(),
+      status: z.string().nullish(),
+    })
+    .nullish(),
+  response: z
+    .object({
+      generateVideoResponse: z
+        .object({
+          generatedSamples: z
+            .array(
+              z.object({
+                video: z
+                  .object({
+                    uri: z.string().nullish(),
+                  })
+                  .nullish(),
+              }),
+            )
+            .nullish(),
+        })
+        .nullish(),
+    })
+    .nullish(),
+});
+
+const googleVideoModelOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        pollIntervalMs: z.number().positive().nullish(),
+        pollTimeoutMs: z.number().positive().nullish(),
+        personGeneration: z
+          .enum(['dont_allow', 'allow_adult', 'allow_all'])
+          .nullish(),
+        negativePrompt: z.string().nullish(),
+        referenceImages: z
+          .array(
+            z.object({
+              bytesBase64Encoded: z.string().nullish(),
+              gcsUri: z.string().nullish(),
+            }),
+          )
+          .nullish(),
+      })
+      .passthrough(),
+  ),
+);

package/src/google-generative-ai-video-settings.ts

@@ -0,0 +1,8 @@
+export type GoogleGenerativeAIVideoModelId =
+  | 'veo-3.1-fast-generate-preview'
+  | 'veo-3.1-generate-preview'
+  | 'veo-3.1-generate'
+  | 'veo-3.0-generate-001'
+  | 'veo-3.0-fast-generate-001'
+  | 'veo-2.0-generate-001'
+  | (string & {});