@aigne/gemini 0.14.4-beta.6 → 0.14.4-beta.8

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [0.14.4-beta.8](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.4-beta.7...gemini-v0.14.4-beta.8) (2025-10-31)
+
+
+### Bug Fixes
+
+* **models:** add image parameters support for video generation ([#684](https://github.com/AIGNE-io/aigne-framework/issues/684)) ([b048b7f](https://github.com/AIGNE-io/aigne-framework/commit/b048b7f92bd7a532dbdbeb6fb5fa5499bae6b953))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.65.0-beta.5
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.57-beta.6
+
+## [0.14.4-beta.7](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.4-beta.6...gemini-v0.14.4-beta.7) (2025-10-29)
+
+
+### Features
+
+* add reasoningEffort option for chat model ([#680](https://github.com/AIGNE-io/aigne-framework/issues/680)) ([f69d232](https://github.com/AIGNE-io/aigne-framework/commit/f69d232d714d4a3e4946bdc8c6598747c9bcbd57))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.65.0-beta.4
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.57-beta.5
+
 ## [0.14.4-beta.6](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.4-beta.5...gemini-v0.14.4-beta.6) (2025-10-28)
 
 

package/lib/cjs/gemini-chat-model.d.ts

@@ -1,4 +1,4 @@
-import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
+import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelInputOptions, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
 import { GoogleGenAI, type GoogleGenAIOptions } from "@google/genai";
 export interface GeminiChatModelOptions extends ChatModelOptions {
@@ -34,10 +34,30 @@ export declare class GeminiChatModel extends ChatModel {
         apiKey: string | undefined;
         model: string;
     };
-    get modelOptions(): Omit<import("@aigne/core").ChatModelInputOptions, "model"> | undefined;
+    get modelOptions(): Omit<ChatModelInputOptions, "model"> | undefined;
     process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    protected thinkingBudgetModelMap: ({
+        pattern: RegExp;
+        support: boolean;
+        min: number;
+        max: number;
+    } | {
+        pattern: RegExp;
+        support: boolean;
+        min?: undefined;
+        max?: undefined;
+    })[];
+    protected thinkingBudgetLevelMap: {
+        high: number;
+        medium: number;
+        low: number;
+        minimal: number;
+    };
+    protected getThinkingBudget(model: string, effort: ChatModelInputOptions["reasoningEffort"]): {
+        support: boolean;
+        budget?: number;
+    };
     private processInput;
-    protected supportThinkingModels: string[];
     private buildConfig;
     private buildTools;
     private buildContents;

package/lib/cjs/gemini-chat-model.js

@@ -61,15 +61,63 @@ class GeminiChatModel extends core_1.ChatModel {
     process(input) {
         return this.processInput(input);
     }
+    // References: https://ai.google.dev/gemini-api/docs/thinking#set-budget
+    thinkingBudgetModelMap = [
+        {
+            pattern: /gemini-2.5-pro/,
+            support: true,
+            min: 128,
+            max: 32768,
+        },
+        {
+            pattern: /gemini-2.5-flash/,
+            support: true,
+            min: 0,
+            max: 24576,
+        },
+        {
+            pattern: /2.5-flash-lite/,
+            support: true,
+            min: 512,
+            max: 24576,
+        },
+        {
+            pattern: /.*/,
+            support: false,
+        },
+    ];
+    thinkingBudgetLevelMap = {
+        high: 100000, // use 100k for high, finally capped by model max
+        medium: 10000,
+        low: 5000,
+        minimal: 200,
+    };
+    getThinkingBudget(model, effort) {
+        const m = this.thinkingBudgetModelMap.find((i) => i.pattern.test(model));
+        if (!m?.support)
+            return { support: false };
+        let budget = typeof effort === "string" ? this.thinkingBudgetLevelMap[effort] || undefined : effort;
+        if (typeof budget === "undefined")
+            return { support: true };
+        if (typeof m.min === "number")
+            budget = Math.max(m.min, budget);
+        if (typeof m.max === "number")
+            budget = Math.min(m.max, budget);
+        return { support: true, budget };
+    }
     async *processInput(input) {
         const model = input.modelOptions?.model || this.credential.model;
         const { contents, config } = await this.buildContents(input);
+        const thinkingBudget = this.getThinkingBudget(model, input.modelOptions?.reasoningEffort ?? this.modelOptions?.reasoningEffort);
         const parameters = {
             model,
             contents,
             config: {
-                thinkingConfig: this.supportThinkingModels.includes(model)
-                    ? { includeThoughts: true }
+                thinkingConfig: thinkingBudget.support
+                    ? {
+                        includeThoughts: true,
+                        thinkingBudget: thinkingBudget.budget,
+                    }
                     : undefined,
                 responseModalities: input.modelOptions?.modalities,
                 temperature: input.modelOptions?.temperature || this.modelOptions?.temperature,
@@ -201,9 +249,18 @@ class GeminiChatModel extends core_1.ChatModel {
                 }
             }
         }
-        yield { delta: { json: { usage, files: files.length ? files : undefined } } };
+        yield {
+            delta: {
+                json: {
+                    usage,
+                    files: files.length ? files : undefined,
+                    modelOptions: {
+                        reasoningEffort: parameters.config?.thinkingConfig?.thinkingBudget,
+                    },
+                },
+            },
+        };
     }
-    supportThinkingModels = ["gemini-2.5-pro", "gemini-2.5-flash"];
     async buildConfig(input) {
         const config = {};
         const { tools, toolConfig } = await this.buildTools(input);

package/lib/cjs/gemini-video-model.d.ts

@@ -1,4 +1,5 @@
-import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
+import type { AgentInvokeOptions, FileUnionContent, VideoModelInput, VideoModelOptions, VideoModelOutput } from "@aigne/core";
+import { VideoModel } from "@aigne/core";
 import { GoogleGenAI } from "@google/genai";
 /**
  * Input options for Gemini Video Model
@@ -13,25 +14,22 @@ export interface GeminiVideoModelInput extends VideoModelInput {
      *
      * Veo 3.1: "16:9" (default, 720p and 1080p), "9:16" (720p and 1080p)
      * Veo 3: "16:9" (default, 720p and 1080p), "9:16" (720p and 1080p)
-     * Veo 2: "16:9" (default, 720p), "9:16" (720p)
      */
-    aspectRatio?: string;
+    aspectRatio?: "16:9" | "9:16";
     /**
      * Resolution of the video
      *
      * Veo 3.1: "720p" (default), "1080p" (only supports 8 seconds duration)
      * Veo 3: "720p" (default), "1080p" (16:9 only)
-     * Veo 2: Not supported
      */
-    size?: string;
+    size?: "720p" | "1080p";
     /**
      * Duration of the generated video in seconds
      *
      * Veo 3.1: "4", "6", "8"
      * Veo 3: "4", "6", "8"
-     * Veo 2: "5", "6", "8"
      */
-    seconds?: string;
+    seconds?: "4" | "6" | "8";
     /**
      * Control person generation
      *
@@ -41,6 +39,15 @@ export interface GeminiVideoModelInput extends VideoModelInput {
      * - Veo 2: "allow_all", "allow_adult", "dont_allow"
      */
     personGeneration?: string;
+    /**
+     * Last frame for video generation (frame interpolation)
+     */
+    lastFrame?: FileUnionContent;
+    /**
+     * Reference images for video generation
+     * Only supported in Veo 3.1 models
+     */
+    referenceImages?: FileUnionContent[];
 }
 /**
  * Output from Gemini Video Model

package/lib/cjs/gemini-video-model.js

@@ -7,12 +7,17 @@ const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
 const genai_1 = require("@google/genai");
 const zod_1 = require("zod");
+const utils_js_1 = require("./utils.js");
 const DEFAULT_MODEL = "veo-3.1-generate-preview";
 const DEFAULT_SECONDS = 8;
 const geminiVideoModelInputSchema = core_1.videoModelInputSchema.extend({
     negativePrompt: zod_1.z.string().optional(),
-    aspectRatio: zod_1.z.string().optional(),
+    aspectRatio: zod_1.z.enum(["16:9", "9:16"]).optional(),
+    size: zod_1.z.enum(["720p", "1080p"]).optional(),
+    seconds: zod_1.z.enum(["4", "6", "8"]).optional(),
     personGeneration: zod_1.z.string().optional(),
+    lastFrame: core_1.fileUnionContentSchema.optional(),
+    referenceImages: core_1.fileUnionContentSchema.array().optional(),
 });
 const geminiVideoModelOptionsSchema = zod_1.z.object({
     apiKey: zod_1.z.string().optional(),
@@ -61,13 +66,16 @@ class GeminiVideoModel extends core_1.VideoModel {
         const localPath = index_js_1.nodejs.path.join(dir, `${videoId}.mp4`);
         await this.client.files.download({ file: videoFile, downloadPath: localPath });
         logger_js_1.logger.debug(`Generated video saved to ${localPath}`);
-        await new Promise((resolve) => setTimeout(resolve, 300));
+        await (0, utils_js_1.waitFileSizeStable)(localPath);
         const buffer = await index_js_1.nodejs.fs.readFile(localPath);
         return buffer.toString("base64");
     }
     async process(input, options) {
         const model = input.model ?? input.modelOptions?.model ?? this.credential.model;
         const mergedInput = { ...this.modelOptions, ...input };
+        if (mergedInput.referenceImages && !model.includes("veo-3.1")) {
+            throw new Error("referenceImages is only supported in Veo 3.1 models");
+        }
         const config = {};
         if (mergedInput.negativePrompt)
             config.negativePrompt = mergedInput.negativePrompt;
@@ -79,11 +87,39 @@ class GeminiVideoModel extends core_1.VideoModel {
             config.durationSeconds = parseInt(mergedInput.seconds, 10);
         if (mergedInput.personGeneration)
             config.personGeneration = mergedInput.personGeneration;
+        if (mergedInput.lastFrame) {
+            config.lastFrame = await this.transformFileType("file", mergedInput.lastFrame, options).then((file) => {
+                return {
+                    imageBytes: file.data,
+                    mimeType: file.mimeType,
+                };
+            });
+        }
+        if (mergedInput.referenceImages) {
+            config.referenceImages = await Promise.all(mergedInput.referenceImages.map(async (image) => {
+                return await this.transformFileType("file", image, options).then((file) => {
+                    return {
+                        image: {
+                            imageBytes: file.data,
+                            mimeType: file.mimeType,
+                        },
+                    };
+                });
+            }));
+        }
         const params = {
             model,
             prompt: mergedInput.prompt,
             config,
         };
+        if (mergedInput.image) {
+            params.image = await this.transformFileType("file", mergedInput.image, options).then((file) => {
+                return {
+                    imageBytes: file.data,
+                    mimeType: file.mimeType,
+                };
+            });
+        }
         // Start video generation
         let operation = await this.client.models.generateVideos(params);
         logger_js_1.logger.debug("Video generation started...");

package/lib/cjs/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wait for file size to stabilize, ensuring the file download is complete.
+ *
+ * @param filePath - The path to the file to check
+ * @param options - Configuration options
+ * @param options.checkInterval - Check interval in milliseconds (default: 500ms)
+ * @param options.stableCount - Number of consecutive checks with same size to consider stable (default: 3)
+ * @param options.timeout - Timeout in milliseconds (default: 60000ms)
+ * @throws Error when timeout is reached
+ */
+export declare function waitFileSizeStable(filePath: string, options?: {
+    checkInterval?: number;
+    stableCount?: number;
+    timeout?: number;
+}): Promise<void>;

package/lib/cjs/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFileSizeStable = waitFileSizeStable;
+const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
+/**
+ * Wait for file size to stabilize, ensuring the file download is complete.
+ *
+ * @param filePath - The path to the file to check
+ * @param options - Configuration options
+ * @param options.checkInterval - Check interval in milliseconds (default: 500ms)
+ * @param options.stableCount - Number of consecutive checks with same size to consider stable (default: 3)
+ * @param options.timeout - Timeout in milliseconds (default: 60000ms)
+ * @throws Error when timeout is reached
+ */
+async function waitFileSizeStable(filePath, options) {
+    const checkInterval = options?.checkInterval ?? 500;
+    const requiredStableCount = options?.stableCount ?? 3;
+    const timeout = options?.timeout ?? 60000;
+    const startTime = Date.now();
+    let previousSize = 0;
+    let stableCount = 0;
+    while (stableCount < requiredStableCount) {
+        if (Date.now() - startTime > timeout) {
+            throw new Error(`Timeout waiting for file to stabilize: ${filePath}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        const stats = await index_js_1.nodejs.fs.stat(filePath);
+        const currentSize = stats.size;
+        if (currentSize === previousSize && currentSize > 0) {
+            stableCount++;
+        }
+        else {
+            stableCount = 0;
+            previousSize = currentSize;
+        }
+    }
+}

package/lib/dts/gemini-chat-model.d.ts

@@ -1,4 +1,4 @@
-import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
+import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelInputOptions, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
 import { GoogleGenAI, type GoogleGenAIOptions } from "@google/genai";
 export interface GeminiChatModelOptions extends ChatModelOptions {
@@ -34,10 +34,30 @@ export declare class GeminiChatModel extends ChatModel {
         apiKey: string | undefined;
         model: string;
     };
-    get modelOptions(): Omit<import("@aigne/core").ChatModelInputOptions, "model"> | undefined;
+    get modelOptions(): Omit<ChatModelInputOptions, "model"> | undefined;
     process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    protected thinkingBudgetModelMap: ({
+        pattern: RegExp;
+        support: boolean;
+        min: number;
+        max: number;
+    } | {
+        pattern: RegExp;
+        support: boolean;
+        min?: undefined;
+        max?: undefined;
+    })[];
+    protected thinkingBudgetLevelMap: {
+        high: number;
+        medium: number;
+        low: number;
+        minimal: number;
+    };
+    protected getThinkingBudget(model: string, effort: ChatModelInputOptions["reasoningEffort"]): {
+        support: boolean;
+        budget?: number;
+    };
     private processInput;
-    protected supportThinkingModels: string[];
     private buildConfig;
     private buildTools;
     private buildContents;

package/lib/dts/gemini-video-model.d.ts

@@ -1,4 +1,5 @@
-import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
+import type { AgentInvokeOptions, FileUnionContent, VideoModelInput, VideoModelOptions, VideoModelOutput } from "@aigne/core";
+import { VideoModel } from "@aigne/core";
 import { GoogleGenAI } from "@google/genai";
 /**
  * Input options for Gemini Video Model
@@ -13,25 +14,22 @@ export interface GeminiVideoModelInput extends VideoModelInput {
      *
      * Veo 3.1: "16:9" (default, 720p and 1080p), "9:16" (720p and 1080p)
      * Veo 3: "16:9" (default, 720p and 1080p), "9:16" (720p and 1080p)
-     * Veo 2: "16:9" (default, 720p), "9:16" (720p)
      */
-    aspectRatio?: string;
+    aspectRatio?: "16:9" | "9:16";
     /**
      * Resolution of the video
      *
      * Veo 3.1: "720p" (default), "1080p" (only supports 8 seconds duration)
      * Veo 3: "720p" (default), "1080p" (16:9 only)
-     * Veo 2: Not supported
      */
-    size?: string;
+    size?: "720p" | "1080p";
     /**
      * Duration of the generated video in seconds
      *
      * Veo 3.1: "4", "6", "8"
      * Veo 3: "4", "6", "8"
-     * Veo 2: "5", "6", "8"
      */
-    seconds?: string;
+    seconds?: "4" | "6" | "8";
     /**
      * Control person generation
      *
@@ -41,6 +39,15 @@ export interface GeminiVideoModelInput extends VideoModelInput {
      * - Veo 2: "allow_all", "allow_adult", "dont_allow"
      */
     personGeneration?: string;
+    /**
+     * Last frame for video generation (frame interpolation)
+     */
+    lastFrame?: FileUnionContent;
+    /**
+     * Reference images for video generation
+     * Only supported in Veo 3.1 models
+     */
+    referenceImages?: FileUnionContent[];
 }
 /**
  * Output from Gemini Video Model

package/lib/dts/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wait for file size to stabilize, ensuring the file download is complete.
+ *
+ * @param filePath - The path to the file to check
+ * @param options - Configuration options
+ * @param options.checkInterval - Check interval in milliseconds (default: 500ms)
+ * @param options.stableCount - Number of consecutive checks with same size to consider stable (default: 3)
+ * @param options.timeout - Timeout in milliseconds (default: 60000ms)
+ * @throws Error when timeout is reached
+ */
+export declare function waitFileSizeStable(filePath: string, options?: {
+    checkInterval?: number;
+    stableCount?: number;
+    timeout?: number;
+}): Promise<void>;

package/lib/esm/gemini-chat-model.d.ts

@@ -1,4 +1,4 @@
-import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
+import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelInputOptions, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
 import { GoogleGenAI, type GoogleGenAIOptions } from "@google/genai";
 export interface GeminiChatModelOptions extends ChatModelOptions {
@@ -34,10 +34,30 @@ export declare class GeminiChatModel extends ChatModel {
         apiKey: string | undefined;
         model: string;
     };
-    get modelOptions(): Omit<import("@aigne/core").ChatModelInputOptions, "model"> | undefined;
+    get modelOptions(): Omit<ChatModelInputOptions, "model"> | undefined;
     process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    protected thinkingBudgetModelMap: ({
+        pattern: RegExp;
+        support: boolean;
+        min: number;
+        max: number;
+    } | {
+        pattern: RegExp;
+        support: boolean;
+        min?: undefined;
+        max?: undefined;
+    })[];
+    protected thinkingBudgetLevelMap: {
+        high: number;
+        medium: number;
+        low: number;
+        minimal: number;
+    };
+    protected getThinkingBudget(model: string, effort: ChatModelInputOptions["reasoningEffort"]): {
+        support: boolean;
+        budget?: number;
+    };
     private processInput;
-    protected supportThinkingModels: string[];
     private buildConfig;
     private buildTools;
     private buildContents;

package/lib/esm/gemini-chat-model.js

@@ -58,15 +58,63 @@ export class GeminiChatModel extends ChatModel {
     process(input) {
         return this.processInput(input);
     }
+    // References: https://ai.google.dev/gemini-api/docs/thinking#set-budget
+    thinkingBudgetModelMap = [
+        {
+            pattern: /gemini-2.5-pro/,
+            support: true,
+            min: 128,
+            max: 32768,
+        },
+        {
+            pattern: /gemini-2.5-flash/,
+            support: true,
+            min: 0,
+            max: 24576,
+        },
+        {
+            pattern: /2.5-flash-lite/,
+            support: true,
+            min: 512,
+            max: 24576,
+        },
+        {
+            pattern: /.*/,
+            support: false,
+        },
+    ];
+    thinkingBudgetLevelMap = {
+        high: 100000, // use 100k for high, finally capped by model max
+        medium: 10000,
+        low: 5000,
+        minimal: 200,
+    };
+    getThinkingBudget(model, effort) {
+        const m = this.thinkingBudgetModelMap.find((i) => i.pattern.test(model));
+        if (!m?.support)
+            return { support: false };
+        let budget = typeof effort === "string" ? this.thinkingBudgetLevelMap[effort] || undefined : effort;
+        if (typeof budget === "undefined")
+            return { support: true };
+        if (typeof m.min === "number")
+            budget = Math.max(m.min, budget);
+        if (typeof m.max === "number")
+            budget = Math.min(m.max, budget);
+        return { support: true, budget };
+    }
     async *processInput(input) {
         const model = input.modelOptions?.model || this.credential.model;
         const { contents, config } = await this.buildContents(input);
+        const thinkingBudget = this.getThinkingBudget(model, input.modelOptions?.reasoningEffort ?? this.modelOptions?.reasoningEffort);
         const parameters = {
             model,
             contents,
             config: {
-                thinkingConfig: this.supportThinkingModels.includes(model)
-                    ? { includeThoughts: true }
+                thinkingConfig: thinkingBudget.support
+                    ? {
+                        includeThoughts: true,
+                        thinkingBudget: thinkingBudget.budget,
+                    }
                     : undefined,
                 responseModalities: input.modelOptions?.modalities,
                 temperature: input.modelOptions?.temperature || this.modelOptions?.temperature,
@@ -198,9 +246,18 @@ export class GeminiChatModel extends ChatModel {
                 }
             }
         }
-        yield { delta: { json: { usage, files: files.length ? files : undefined } } };
+        yield {
+            delta: {
+                json: {
+                    usage,
+                    files: files.length ? files : undefined,
+                    modelOptions: {
+                        reasoningEffort: parameters.config?.thinkingConfig?.thinkingBudget,
+                    },
+                },
+            },
+        };
     }
-    supportThinkingModels = ["gemini-2.5-pro", "gemini-2.5-flash"];
     async buildConfig(input) {
         const config = {};
         const { tools, toolConfig } = await this.buildTools(input);

package/lib/esm/gemini-video-model.d.ts

@@ -1,4 +1,5 @@
-import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
+import type { AgentInvokeOptions, FileUnionContent, VideoModelInput, VideoModelOptions, VideoModelOutput } from "@aigne/core";
+import { VideoModel } from "@aigne/core";
 import { GoogleGenAI } from "@google/genai";
 /**
  * Input options for Gemini Video Model
@@ -13,25 +14,22 @@ export interface GeminiVideoModelInput extends VideoModelInput {
      *
      * Veo 3.1: "16:9" (default, 720p and 1080p), "9:16" (720p and 1080p)
      * Veo 3: "16:9" (default, 720p and 1080p), "9:16" (720p and 1080p)
-     * Veo 2: "16:9" (default, 720p), "9:16" (720p)
      */
-    aspectRatio?: string;
+    aspectRatio?: "16:9" | "9:16";
     /**
      * Resolution of the video
      *
      * Veo 3.1: "720p" (default), "1080p" (only supports 8 seconds duration)
      * Veo 3: "720p" (default), "1080p" (16:9 only)
-     * Veo 2: Not supported
      */
-    size?: string;
+    size?: "720p" | "1080p";
     /**
      * Duration of the generated video in seconds
      *
      * Veo 3.1: "4", "6", "8"
      * Veo 3: "4", "6", "8"
-     * Veo 2: "5", "6", "8"
      */
-    seconds?: string;
+    seconds?: "4" | "6" | "8";
     /**
      * Control person generation
      *
@@ -41,6 +39,15 @@ export interface GeminiVideoModelInput extends VideoModelInput {
      * - Veo 2: "allow_all", "allow_adult", "dont_allow"
      */
     personGeneration?: string;
+    /**
+     * Last frame for video generation (frame interpolation)
+     */
+    lastFrame?: FileUnionContent;
+    /**
+     * Reference images for video generation
+     * Only supported in Veo 3.1 models
+     */
+    referenceImages?: FileUnionContent[];
 }
 /**
  * Output from Gemini Video Model

package/lib/esm/gemini-video-model.js

@@ -1,15 +1,20 @@
-import { VideoModel, videoModelInputSchema, } from "@aigne/core";
+import { fileUnionContentSchema, VideoModel, videoModelInputSchema } from "@aigne/core";
 import { logger } from "@aigne/core/utils/logger.js";
 import { checkArguments } from "@aigne/core/utils/type-utils.js";
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { GoogleGenAI } from "@google/genai";
 import { z } from "zod";
+import { waitFileSizeStable } from "./utils.js";
 const DEFAULT_MODEL = "veo-3.1-generate-preview";
 const DEFAULT_SECONDS = 8;
 const geminiVideoModelInputSchema = videoModelInputSchema.extend({
     negativePrompt: z.string().optional(),
-    aspectRatio: z.string().optional(),
+    aspectRatio: z.enum(["16:9", "9:16"]).optional(),
+    size: z.enum(["720p", "1080p"]).optional(),
+    seconds: z.enum(["4", "6", "8"]).optional(),
     personGeneration: z.string().optional(),
+    lastFrame: fileUnionContentSchema.optional(),
+    referenceImages: fileUnionContentSchema.array().optional(),
 });
 const geminiVideoModelOptionsSchema = z.object({
     apiKey: z.string().optional(),
@@ -58,13 +63,16 @@ export class GeminiVideoModel extends VideoModel {
         const localPath = nodejs.path.join(dir, `${videoId}.mp4`);
         await this.client.files.download({ file: videoFile, downloadPath: localPath });
         logger.debug(`Generated video saved to ${localPath}`);
-        await new Promise((resolve) => setTimeout(resolve, 300));
+        await waitFileSizeStable(localPath);
         const buffer = await nodejs.fs.readFile(localPath);
         return buffer.toString("base64");
     }
     async process(input, options) {
         const model = input.model ?? input.modelOptions?.model ?? this.credential.model;
         const mergedInput = { ...this.modelOptions, ...input };
+        if (mergedInput.referenceImages && !model.includes("veo-3.1")) {
+            throw new Error("referenceImages is only supported in Veo 3.1 models");
+        }
         const config = {};
         if (mergedInput.negativePrompt)
             config.negativePrompt = mergedInput.negativePrompt;
@@ -76,11 +84,39 @@ export class GeminiVideoModel extends VideoModel {
             config.durationSeconds = parseInt(mergedInput.seconds, 10);
         if (mergedInput.personGeneration)
             config.personGeneration = mergedInput.personGeneration;
+        if (mergedInput.lastFrame) {
+            config.lastFrame = await this.transformFileType("file", mergedInput.lastFrame, options).then((file) => {
+                return {
+                    imageBytes: file.data,
+                    mimeType: file.mimeType,
+                };
+            });
+        }
+        if (mergedInput.referenceImages) {
+            config.referenceImages = await Promise.all(mergedInput.referenceImages.map(async (image) => {
+                return await this.transformFileType("file", image, options).then((file) => {
+                    return {
+                        image: {
+                            imageBytes: file.data,
+                            mimeType: file.mimeType,
+                        },
+                    };
+                });
+            }));
+        }
         const params = {
             model,
             prompt: mergedInput.prompt,
             config,
         };
+        if (mergedInput.image) {
+            params.image = await this.transformFileType("file", mergedInput.image, options).then((file) => {
+                return {
+                    imageBytes: file.data,
+                    mimeType: file.mimeType,
+                };
+            });
+        }
         // Start video generation
         let operation = await this.client.models.generateVideos(params);
         logger.debug("Video generation started...");

package/lib/esm/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wait for file size to stabilize, ensuring the file download is complete.
+ *
+ * @param filePath - The path to the file to check
+ * @param options - Configuration options
+ * @param options.checkInterval - Check interval in milliseconds (default: 500ms)
+ * @param options.stableCount - Number of consecutive checks with same size to consider stable (default: 3)
+ * @param options.timeout - Timeout in milliseconds (default: 60000ms)
+ * @throws Error when timeout is reached
+ */
+export declare function waitFileSizeStable(filePath: string, options?: {
+    checkInterval?: number;
+    stableCount?: number;
+    timeout?: number;
+}): Promise<void>;

package/lib/esm/utils.js

@@ -0,0 +1,34 @@
+import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
+/**
+ * Wait for file size to stabilize, ensuring the file download is complete.
+ *
+ * @param filePath - The path to the file to check
+ * @param options - Configuration options
+ * @param options.checkInterval - Check interval in milliseconds (default: 500ms)
+ * @param options.stableCount - Number of consecutive checks with same size to consider stable (default: 3)
+ * @param options.timeout - Timeout in milliseconds (default: 60000ms)
+ * @throws Error when timeout is reached
+ */
+export async function waitFileSizeStable(filePath, options) {
+    const checkInterval = options?.checkInterval ?? 500;
+    const requiredStableCount = options?.stableCount ?? 3;
+    const timeout = options?.timeout ?? 60000;
+    const startTime = Date.now();
+    let previousSize = 0;
+    let stableCount = 0;
+    while (stableCount < requiredStableCount) {
+        if (Date.now() - startTime > timeout) {
+            throw new Error(`Timeout waiting for file to stabilize: ${filePath}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        const stats = await nodejs.fs.stat(filePath);
+        const currentSize = stats.size;
+        if (currentSize === previousSize && currentSize > 0) {
+            stableCount++;
+        }
+        else {
+            stableCount = 0;
+            previousSize = currentSize;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/gemini",
-  "version": "0.14.4-beta.6",
+  "version": "0.14.4-beta.8",
   "description": "AIGNE Gemini SDK for integrating with Google's Gemini AI models",
   "publishConfig": {
     "access": "public"
@@ -39,7 +39,7 @@
     "@google/genai": "^1.24.0",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.6",
-    "@aigne/core": "^1.65.0-beta.3",
+    "@aigne/core": "^1.65.0-beta.5",
     "@aigne/platform-helpers": "^0.6.3"
   },
   "devDependencies": {
@@ -48,7 +48,7 @@
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2",
-    "@aigne/test-utils": "^0.5.57-beta.4"
+    "@aigne/test-utils": "^0.5.57-beta.6"
   },
   "scripts": {
     "lint": "tsc --noEmit",