@aigne/gemini 0.14.4-beta.1 → 0.14.4-beta.3

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [0.14.4-beta.3](https://github.com/AIGNE-io/aigne-framework/compare/gemini-v0.14.4-beta.2...gemini-v0.14.4-beta.3) (2025-10-26)
+
+
+### Bug Fixes
+
+* **models:** add mineType for transform file ([#667](https://github.com/AIGNE-io/aigne-framework/issues/667)) ([155a173](https://github.com/AIGNE-io/aigne-framework/commit/155a173e75aff1dbe870a1305455a4300942e07a))
+* **models:** aigne hub video params ([#665](https://github.com/AIGNE-io/aigne-framework/issues/665)) ([d00f836](https://github.com/AIGNE-io/aigne-framework/commit/d00f8368422d8e3707b974e1aff06714731ebb28))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.65.0-beta.1
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.57-beta.2
+
+## [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)
 
 

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);
+        return buffer.toString("base64");
+    }
+    async process(input, options) {
+        const model = input.model ?? input.modelOptions?.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),
+                    mimeType: "video/mp4",
+                    filename: `${videoId}.mp4`,
+                },
+            ],
+            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-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-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);
+        return buffer.toString("base64");
+    }
+    async process(input, options) {
+        const model = input.model ?? input.modelOptions?.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),
+                    mimeType: "video/mp4",
+                    filename: `${videoId}.mp4`,
+                },
+            ],
+            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.4-beta.1",
+  "version": "0.14.4-beta.3",
   "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.1-beta",
+    "@aigne/core": "^1.65.0-beta.1",
     "@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"
+    "@aigne/test-utils": "^0.5.57-beta.2"
   },
   "scripts": {
     "lint": "tsc --noEmit",