@aigne/gemini 0.14.3 → 0.14.4-beta.2

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## [0.14.4-beta.2](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.4-beta.1...gemini-v0.14.4-beta.2) (2025-10-24)
+
+
+### Features
+
+* **model:** support video model ([#647](https://github.com/AIGNE-io/aigne-framework/issues/647)) ([de81742](https://github.com/AIGNE-io/aigne-framework/commit/de817421ef1dd3246d0d8c51ff12f0a855658f9f))
+
+
+### Bug Fixes
+
+* **model:** updated default video duration settings for AI video models ([#663](https://github.com/AIGNE-io/aigne-framework/issues/663)) ([1203941](https://github.com/AIGNE-io/aigne-framework/commit/12039411aaef77ba665e8edfb0fe6f8097c43e39))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.65.0-beta
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.57-beta.1
+
+## [0.14.4-beta.1](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.4-beta...gemini-v0.14.4-beta.1) (2025-10-24)
+
+
+### Bug Fixes
+
+* **gemini:** use StructuredOutputError to trigger retry for missing JSON response ([#660](https://github.com/AIGNE-io/aigne-framework/issues/660)) ([e8826ed](https://github.com/AIGNE-io/aigne-framework/commit/e8826ed96db57bfcce0b577881bf0d2fd828c269))
+
+## [0.14.4-beta](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.3...gemini-v0.14.4-beta) (2025-10-23)
+
+
+### Bug Fixes
+
+* **models:** improve message structure handling and enable auto-message options ([#657](https://github.com/AIGNE-io/aigne-framework/issues/657)) ([233d70c](https://github.com/AIGNE-io/aigne-framework/commit/233d70cb292b937200fada8434f33d957d766ad6))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.64.1-beta
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.57-beta
+
 ## [0.14.3](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.3-beta.1...gemini-v0.14.3) (2025-10-22)
 
 

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

@@ -41,4 +41,5 @@ export declare class GeminiChatModel extends ChatModel {
     private buildConfig;
     private buildTools;
     private buildContents;
+    private ensureMessagesHasUserMessage;
 }

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

@@ -151,7 +151,7 @@ class GeminiChatModel extends core_1.ChatModel {
                 yield { delta: { json: { json: (0, core_1.safeParseJSON)(text) } } };
             }
             else if (!toolCalls.length) {
-                throw new Error("No JSON response from the model");
+                throw new core_1.StructuredOutputError("No JSON response from the model");
             }
         }
         else if (!toolCalls.length) {
@@ -342,17 +342,26 @@ class GeminiChatModel extends core_1.ChatModel {
             }
             return content;
         }))).filter(type_utils_js_1.isNonNullable);
-        if (!result.contents.length && systemParts.length) {
-            const system = systemParts.pop();
-            if (system) {
-                result.contents.push({ role: "user", parts: [system] });
-            }
-        }
+        this.ensureMessagesHasUserMessage(systemParts, result.contents);
         if (systemParts.length) {
             result.config ??= {};
             result.config.systemInstruction = systemParts;
         }
         return result;
     }
+    ensureMessagesHasUserMessage(systems, contents) {
+        // no messages but system messages
+        if (!contents.length && systems.length) {
+            const system = systems.pop();
+            if (system)
+                contents.push({ role: "user", parts: [system] });
+        }
+        // first message is from model
+        if (contents[0]?.role === "model") {
+            const system = systems.pop();
+            if (system)
+                contents.unshift({ role: "user", parts: [system] });
+        }
+    }
 }
 exports.GeminiChatModel = GeminiChatModel;

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

@@ -0,0 +1,107 @@
+import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
+import { GoogleGenAI } from "@google/genai";
+/**
+ * Input options for Gemini Video Model
+ */
+export interface GeminiVideoModelInput extends VideoModelInput {
+    /**
+     * Text describing content that should not appear in the video
+     */
+    negativePrompt?: string;
+    /**
+     * Aspect ratio of the video
+     *
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Control person generation
+     *
+     * For text-to-video and image-to-video:
+     * - Veo 3.1: "allow_all" for image-to-video, frame interpolation and reference images; only "allow_adult" for text-to-video
+     * - Veo 3: "allow_all" for image-to-video; only "allow_adult" for text-to-video
+     * - Veo 2: "allow_all", "allow_adult", "dont_allow"
+     */
+    personGeneration?: string;
+}
+/**
+ * Output from Gemini Video Model
+ */
+export interface GeminiVideoModelOutput extends VideoModelOutput {
+}
+/**
+ * Configuration options for Gemini Video Model
+ */
+export interface GeminiVideoModelOptions extends VideoModelOptions<GeminiVideoModelInput, GeminiVideoModelOutput> {
+    /**
+     * API key for Gemini API
+     *
+     * If not provided, will look for GEMINI_API_KEY in environment variables
+     */
+    apiKey?: string;
+    /**
+     * Base URL for Gemini API
+     *
+     * Useful for proxies or alternate endpoints
+     */
+    baseURL?: string;
+    /**
+     * Gemini model to use
+     *
+     * Defaults to 'veo-3.1-generate-preview'
+     */
+    model?: string;
+    /**
+     * Additional model options to control behavior
+     */
+    modelOptions?: Omit<Partial<GeminiVideoModelInput>, "model">;
+    /**
+     * Client options for Gemini API
+     */
+    clientOptions?: Record<string, any>;
+    /**
+     * Polling interval in milliseconds for checking video generation status
+     *
+     * Defaults to 10000ms (10 seconds)
+     */
+    pollingInterval?: number;
+}
+export declare class GeminiVideoModel extends VideoModel<GeminiVideoModelInput, GeminiVideoModelOutput> {
+    options?: GeminiVideoModelOptions | undefined;
+    constructor(options?: GeminiVideoModelOptions | undefined);
+    /**
+     * @hidden
+     */
+    protected _client?: GoogleGenAI;
+    protected apiKeyEnvName: string;
+    get client(): GoogleGenAI;
+    get credential(): {
+        url: string | undefined;
+        apiKey: string | undefined;
+        model: string;
+    };
+    get modelOptions(): Omit<Partial<GeminiVideoModelInput>, "model"> | undefined;
+    downloadToFile(dir: string, videoId: string, videoFile: {
+        uri?: string;
+        videoBytes?: any;
+    }): Promise<string>;
+    process(input: GeminiVideoModelInput, options: AgentInvokeOptions): Promise<GeminiVideoModelOutput>;
+}

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiVideoModel = void 0;
+const core_1 = require("@aigne/core");
+const logger_js_1 = require("@aigne/core/utils/logger.js");
+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 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(),
+    personGeneration: zod_1.z.string().optional(),
+});
+const geminiVideoModelOptionsSchema = zod_1.z.object({
+    apiKey: zod_1.z.string().optional(),
+    baseURL: zod_1.z.string().optional(),
+    model: zod_1.z.string().optional(),
+    modelOptions: zod_1.z.object({}).optional(),
+    clientOptions: zod_1.z.object({}).optional(),
+    pollingInterval: zod_1.z.number().optional(),
+});
+class GeminiVideoModel extends core_1.VideoModel {
+    options;
+    constructor(options) {
+        super({
+            ...options,
+            description: options?.description ?? "Generate videos using Google Gemini Veo models",
+            inputSchema: geminiVideoModelInputSchema,
+        });
+        this.options = options;
+        if (options)
+            (0, type_utils_js_1.checkArguments)(this.name, geminiVideoModelOptionsSchema, options);
+    }
+    /**
+     * @hidden
+     */
+    _client;
+    apiKeyEnvName = "GEMINI_API_KEY";
+    get client() {
+        const { apiKey } = this.credential;
+        if (!apiKey)
+            throw new Error(`${this.name} requires an API key. Please provide it via \`options.apiKey\`, or set the \`${this.apiKeyEnvName}\` environment variable`);
+        this._client ??= new genai_1.GoogleGenAI({ apiKey, ...this.options?.clientOptions });
+        return this._client;
+    }
+    get credential() {
+        return {
+            url: this.options?.baseURL || process.env.GEMINI_BASE_URL,
+            apiKey: this.options?.apiKey || process.env[this.apiKeyEnvName],
+            model: this.options?.model || DEFAULT_MODEL,
+        };
+    }
+    get modelOptions() {
+        return this.options?.modelOptions;
+    }
+    async downloadToFile(dir, videoId, videoFile) {
+        logger_js_1.logger.debug("Downloading video content...");
+        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));
+        const buffer = await index_js_1.nodejs.fs.readFile(localPath);
+        const base64 = buffer.toString("base64");
+        const dataUrl = `data:video/mp4;base64,${base64}`;
+        return dataUrl;
+    }
+    async process(input, options) {
+        const model = input.model ?? this.credential.model;
+        const mergedInput = { ...this.modelOptions, ...input };
+        const config = {};
+        if (mergedInput.negativePrompt)
+            config.negativePrompt = mergedInput.negativePrompt;
+        if (mergedInput.aspectRatio)
+            config.aspectRatio = mergedInput.aspectRatio;
+        if (mergedInput.size)
+            config.resolution = mergedInput.size;
+        if (mergedInput.seconds)
+            config.durationSeconds = parseInt(mergedInput.seconds, 10);
+        if (mergedInput.personGeneration)
+            config.personGeneration = mergedInput.personGeneration;
+        const params = {
+            model,
+            prompt: mergedInput.prompt,
+            config,
+        };
+        // Start video generation
+        let operation = await this.client.models.generateVideos(params);
+        logger_js_1.logger.debug("Video generation started...");
+        // Poll operation status until complete
+        const pollingInterval = this.options?.pollingInterval ?? 10000;
+        while (!operation.done) {
+            logger_js_1.logger.debug("Waiting for video generation to complete...");
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            operation = await this.client.operations.getVideosOperation({ operation });
+        }
+        if (!operation.response?.generatedVideos?.[0]?.video) {
+            throw new Error("Video generation failed: No video generated");
+        }
+        // Download the generated video
+        const generatedVideo = operation.response.generatedVideos[0];
+        const videoFile = generatedVideo.video;
+        if (!videoFile) {
+            throw new Error("Video generation failed: No video file returned");
+        }
+        // Save to temporary directory
+        const dir = index_js_1.nodejs.path.join(index_js_1.nodejs.os.tmpdir(), options?.context?.id || "");
+        await index_js_1.nodejs.fs.mkdir(dir, { recursive: true });
+        const videoId = Date.now().toString();
+        return {
+            videos: [
+                {
+                    type: "file",
+                    data: await this.downloadToFile(dir, videoId, videoFile),
+                },
+            ],
+            usage: {
+                inputTokens: 0,
+                outputTokens: 0,
+            },
+            model,
+            seconds: mergedInput.seconds ? parseInt(mergedInput.seconds, 10) : DEFAULT_SECONDS,
+        };
+    }
+}
+exports.GeminiVideoModel = GeminiVideoModel;

package/lib/cjs/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./gemini-chat-model.js";
 export * from "./gemini-image-model.js";
+export * from "./gemini-video-model.js";

package/lib/cjs/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./gemini-chat-model.js"), exports);
 __exportStar(require("./gemini-image-model.js"), exports);
+__exportStar(require("./gemini-video-model.js"), exports);

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

@@ -41,4 +41,5 @@ export declare class GeminiChatModel extends ChatModel {
     private buildConfig;
     private buildTools;
     private buildContents;
+    private ensureMessagesHasUserMessage;
 }

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

@@ -0,0 +1,107 @@
+import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
+import { GoogleGenAI } from "@google/genai";
+/**
+ * Input options for Gemini Video Model
+ */
+export interface GeminiVideoModelInput extends VideoModelInput {
+    /**
+     * Text describing content that should not appear in the video
+     */
+    negativePrompt?: string;
+    /**
+     * Aspect ratio of the video
+     *
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Control person generation
+     *
+     * For text-to-video and image-to-video:
+     * - Veo 3.1: "allow_all" for image-to-video, frame interpolation and reference images; only "allow_adult" for text-to-video
+     * - Veo 3: "allow_all" for image-to-video; only "allow_adult" for text-to-video
+     * - Veo 2: "allow_all", "allow_adult", "dont_allow"
+     */
+    personGeneration?: string;
+}
+/**
+ * Output from Gemini Video Model
+ */
+export interface GeminiVideoModelOutput extends VideoModelOutput {
+}
+/**
+ * Configuration options for Gemini Video Model
+ */
+export interface GeminiVideoModelOptions extends VideoModelOptions<GeminiVideoModelInput, GeminiVideoModelOutput> {
+    /**
+     * API key for Gemini API
+     *
+     * If not provided, will look for GEMINI_API_KEY in environment variables
+     */
+    apiKey?: string;
+    /**
+     * Base URL for Gemini API
+     *
+     * Useful for proxies or alternate endpoints
+     */
+    baseURL?: string;
+    /**
+     * Gemini model to use
+     *
+     * Defaults to 'veo-3.1-generate-preview'
+     */
+    model?: string;
+    /**
+     * Additional model options to control behavior
+     */
+    modelOptions?: Omit<Partial<GeminiVideoModelInput>, "model">;
+    /**
+     * Client options for Gemini API
+     */
+    clientOptions?: Record<string, any>;
+    /**
+     * Polling interval in milliseconds for checking video generation status
+     *
+     * Defaults to 10000ms (10 seconds)
+     */
+    pollingInterval?: number;
+}
+export declare class GeminiVideoModel extends VideoModel<GeminiVideoModelInput, GeminiVideoModelOutput> {
+    options?: GeminiVideoModelOptions | undefined;
+    constructor(options?: GeminiVideoModelOptions | undefined);
+    /**
+     * @hidden
+     */
+    protected _client?: GoogleGenAI;
+    protected apiKeyEnvName: string;
+    get client(): GoogleGenAI;
+    get credential(): {
+        url: string | undefined;
+        apiKey: string | undefined;
+        model: string;
+    };
+    get modelOptions(): Omit<Partial<GeminiVideoModelInput>, "model"> | undefined;
+    downloadToFile(dir: string, videoId: string, videoFile: {
+        uri?: string;
+        videoBytes?: any;
+    }): Promise<string>;
+    process(input: GeminiVideoModelInput, options: AgentInvokeOptions): Promise<GeminiVideoModelOutput>;
+}

package/lib/dts/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./gemini-chat-model.js";
 export * from "./gemini-image-model.js";
+export * from "./gemini-video-model.js";

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

@@ -41,4 +41,5 @@ export declare class GeminiChatModel extends ChatModel {
     private buildConfig;
     private buildTools;
     private buildContents;
+    private ensureMessagesHasUserMessage;
 }

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

@@ -148,7 +148,7 @@ export class GeminiChatModel extends ChatModel {
                 yield { delta: { json: { json: safeParseJSON(text) } } };
             }
             else if (!toolCalls.length) {
-                throw new Error("No JSON response from the model");
+                throw new StructuredOutputError("No JSON response from the model");
             }
         }
         else if (!toolCalls.length) {
@@ -339,16 +339,25 @@ export class GeminiChatModel extends ChatModel {
             }
             return content;
         }))).filter(isNonNullable);
-        if (!result.contents.length && systemParts.length) {
-            const system = systemParts.pop();
-            if (system) {
-                result.contents.push({ role: "user", parts: [system] });
-            }
-        }
+        this.ensureMessagesHasUserMessage(systemParts, result.contents);
         if (systemParts.length) {
             result.config ??= {};
             result.config.systemInstruction = systemParts;
         }
         return result;
     }
+    ensureMessagesHasUserMessage(systems, contents) {
+        // no messages but system messages
+        if (!contents.length && systems.length) {
+            const system = systems.pop();
+            if (system)
+                contents.push({ role: "user", parts: [system] });
+        }
+        // first message is from model
+        if (contents[0]?.role === "model") {
+            const system = systems.pop();
+            if (system)
+                contents.unshift({ role: "user", parts: [system] });
+        }
+    }
 }

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

@@ -0,0 +1,107 @@
+import { type AgentInvokeOptions, VideoModel, type VideoModelInput, type VideoModelOptions, type VideoModelOutput } from "@aigne/core";
+import { GoogleGenAI } from "@google/genai";
+/**
+ * Input options for Gemini Video Model
+ */
+export interface GeminiVideoModelInput extends VideoModelInput {
+    /**
+     * Text describing content that should not appear in the video
+     */
+    negativePrompt?: string;
+    /**
+     * Aspect ratio of the video
+     *
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Control person generation
+     *
+     * For text-to-video and image-to-video:
+     * - Veo 3.1: "allow_all" for image-to-video, frame interpolation and reference images; only "allow_adult" for text-to-video
+     * - Veo 3: "allow_all" for image-to-video; only "allow_adult" for text-to-video
+     * - Veo 2: "allow_all", "allow_adult", "dont_allow"
+     */
+    personGeneration?: string;
+}
+/**
+ * Output from Gemini Video Model
+ */
+export interface GeminiVideoModelOutput extends VideoModelOutput {
+}
+/**
+ * Configuration options for Gemini Video Model
+ */
+export interface GeminiVideoModelOptions extends VideoModelOptions<GeminiVideoModelInput, GeminiVideoModelOutput> {
+    /**
+     * API key for Gemini API
+     *
+     * If not provided, will look for GEMINI_API_KEY in environment variables
+     */
+    apiKey?: string;
+    /**
+     * Base URL for Gemini API
+     *
+     * Useful for proxies or alternate endpoints
+     */
+    baseURL?: string;
+    /**
+     * Gemini model to use
+     *
+     * Defaults to 'veo-3.1-generate-preview'
+     */
+    model?: string;
+    /**
+     * Additional model options to control behavior
+     */
+    modelOptions?: Omit<Partial<GeminiVideoModelInput>, "model">;
+    /**
+     * Client options for Gemini API
+     */
+    clientOptions?: Record<string, any>;
+    /**
+     * Polling interval in milliseconds for checking video generation status
+     *
+     * Defaults to 10000ms (10 seconds)
+     */
+    pollingInterval?: number;
+}
+export declare class GeminiVideoModel extends VideoModel<GeminiVideoModelInput, GeminiVideoModelOutput> {
+    options?: GeminiVideoModelOptions | undefined;
+    constructor(options?: GeminiVideoModelOptions | undefined);
+    /**
+     * @hidden
+     */
+    protected _client?: GoogleGenAI;
+    protected apiKeyEnvName: string;
+    get client(): GoogleGenAI;
+    get credential(): {
+        url: string | undefined;
+        apiKey: string | undefined;
+        model: string;
+    };
+    get modelOptions(): Omit<Partial<GeminiVideoModelInput>, "model"> | undefined;
+    downloadToFile(dir: string, videoId: string, videoFile: {
+        uri?: string;
+        videoBytes?: any;
+    }): Promise<string>;
+    process(input: GeminiVideoModelInput, options: AgentInvokeOptions): Promise<GeminiVideoModelOutput>;
+}

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

@@ -0,0 +1,124 @@
+import { 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";
+const DEFAULT_MODEL = "veo-3.1-generate-preview";
+const DEFAULT_SECONDS = 8;
+const geminiVideoModelInputSchema = videoModelInputSchema.extend({
+    negativePrompt: z.string().optional(),
+    aspectRatio: z.string().optional(),
+    personGeneration: z.string().optional(),
+});
+const geminiVideoModelOptionsSchema = z.object({
+    apiKey: z.string().optional(),
+    baseURL: z.string().optional(),
+    model: z.string().optional(),
+    modelOptions: z.object({}).optional(),
+    clientOptions: z.object({}).optional(),
+    pollingInterval: z.number().optional(),
+});
+export class GeminiVideoModel extends VideoModel {
+    options;
+    constructor(options) {
+        super({
+            ...options,
+            description: options?.description ?? "Generate videos using Google Gemini Veo models",
+            inputSchema: geminiVideoModelInputSchema,
+        });
+        this.options = options;
+        if (options)
+            checkArguments(this.name, geminiVideoModelOptionsSchema, options);
+    }
+    /**
+     * @hidden
+     */
+    _client;
+    apiKeyEnvName = "GEMINI_API_KEY";
+    get client() {
+        const { apiKey } = this.credential;
+        if (!apiKey)
+            throw new Error(`${this.name} requires an API key. Please provide it via \`options.apiKey\`, or set the \`${this.apiKeyEnvName}\` environment variable`);
+        this._client ??= new GoogleGenAI({ apiKey, ...this.options?.clientOptions });
+        return this._client;
+    }
+    get credential() {
+        return {
+            url: this.options?.baseURL || process.env.GEMINI_BASE_URL,
+            apiKey: this.options?.apiKey || process.env[this.apiKeyEnvName],
+            model: this.options?.model || DEFAULT_MODEL,
+        };
+    }
+    get modelOptions() {
+        return this.options?.modelOptions;
+    }
+    async downloadToFile(dir, videoId, videoFile) {
+        logger.debug("Downloading video content...");
+        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));
+        const buffer = await nodejs.fs.readFile(localPath);
+        const base64 = buffer.toString("base64");
+        const dataUrl = `data:video/mp4;base64,${base64}`;
+        return dataUrl;
+    }
+    async process(input, options) {
+        const model = input.model ?? this.credential.model;
+        const mergedInput = { ...this.modelOptions, ...input };
+        const config = {};
+        if (mergedInput.negativePrompt)
+            config.negativePrompt = mergedInput.negativePrompt;
+        if (mergedInput.aspectRatio)
+            config.aspectRatio = mergedInput.aspectRatio;
+        if (mergedInput.size)
+            config.resolution = mergedInput.size;
+        if (mergedInput.seconds)
+            config.durationSeconds = parseInt(mergedInput.seconds, 10);
+        if (mergedInput.personGeneration)
+            config.personGeneration = mergedInput.personGeneration;
+        const params = {
+            model,
+            prompt: mergedInput.prompt,
+            config,
+        };
+        // Start video generation
+        let operation = await this.client.models.generateVideos(params);
+        logger.debug("Video generation started...");
+        // Poll operation status until complete
+        const pollingInterval = this.options?.pollingInterval ?? 10000;
+        while (!operation.done) {
+            logger.debug("Waiting for video generation to complete...");
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            operation = await this.client.operations.getVideosOperation({ operation });
+        }
+        if (!operation.response?.generatedVideos?.[0]?.video) {
+            throw new Error("Video generation failed: No video generated");
+        }
+        // Download the generated video
+        const generatedVideo = operation.response.generatedVideos[0];
+        const videoFile = generatedVideo.video;
+        if (!videoFile) {
+            throw new Error("Video generation failed: No video file returned");
+        }
+        // Save to temporary directory
+        const dir = nodejs.path.join(nodejs.os.tmpdir(), options?.context?.id || "");
+        await nodejs.fs.mkdir(dir, { recursive: true });
+        const videoId = Date.now().toString();
+        return {
+            videos: [
+                {
+                    type: "file",
+                    data: await this.downloadToFile(dir, videoId, videoFile),
+                },
+            ],
+            usage: {
+                inputTokens: 0,
+                outputTokens: 0,
+            },
+            model,
+            seconds: mergedInput.seconds ? parseInt(mergedInput.seconds, 10) : DEFAULT_SECONDS,
+        };
+    }
+}

package/lib/esm/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./gemini-chat-model.js";
 export * from "./gemini-image-model.js";
+export * from "./gemini-video-model.js";

package/lib/esm/index.js

@@ -1,2 +1,3 @@
 export * from "./gemini-chat-model.js";
 export * from "./gemini-image-model.js";
+export * from "./gemini-video-model.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/gemini",
-  "version": "0.14.3",
+  "version": "0.14.4-beta.2",
   "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.64.0",
+    "@aigne/core": "^1.65.0-beta",
     "@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.56"
+    "@aigne/test-utils": "^0.5.57-beta.1"
   },
   "scripts": {
     "lint": "tsc --noEmit",