mulmocast 2.17.0 → 2.18.0

package/lib/agents/movie_genai_agent.js

@@ -5,11 +5,14 @@ import { apiKeyMissingError, agentGenerationError, agentInvalidResponseError, im
 import { getAspectRatio } from "../utils/utils.js";
 import { ffmpegGetMediaDuration } from "../utils/ffmpeg_utils.js";
 import { ASPECT_RATIOS } from "../types/const.js";
-import { getModelDuration, provider2MovieAgent, AUDIO_MODE_NEVER, AUDIO_MODE_ALWAYS, defaultMovieModel, veoExtensionCount, VEO_EXTENSION_MODEL, VEO_SEGMENT_SEC, } from "../types/provider2agent.js";
+import { getModelDuration, provider2MovieAgent, AUDIO_MODE_NEVER, AUDIO_MODE_ALWAYS, defaultMovieModel, unsupportedGoogleMovieModelMessage, } from "../types/provider2agent.js";
+import { GEMINI_OMNI_MAX_TOTAL_SEC, buildGeminiOmniVideoRequest, geminiOmniAspectRatio, geminiOmniExtensionPrompt, geminiOmniSegments, isGeminiOmniVideoModel, videoFromInteraction, } from "../utils/gemini_omni_video.js";
 // Per-request timeout so a stalled GenAI video API call rejects instead of hanging.
 const GENAI_REQUEST_TIMEOUT_MS = 120_000;
 // Wall-clock cap on the long-running video operation poll loop (Veo runs minutes).
 const VIDEO_POLL_TIMEOUT_MS = 1_200_000;
+// A Gemini Omni call answers synchronously with the whole video (10s at 720p took about 45s).
+const GEMINI_OMNI_REQUEST_TIMEOUT_MS = 600_000;
 const pollUntilDone = async (ai, operation) => {
     const response = { operation };
     const deadline = Date.now() + VIDEO_POLL_TIMEOUT_MS;
@@ -78,47 +81,53 @@ const downloadVideo = async (ai, video, movieFile, isVertexAI, model) => {
     const usage = predictSec !== undefined ? { provider: "google", model, predictSec } : undefined;
     return { saved: movieFile, usage };
 };
-const createVeo31Payload = (model, prompt, aspectRatio, source) => ({
-    model,
-    prompt,
-    config: {
-        aspectRatio,
-        resolution: "720p",
-        numberOfVideos: 1,
-    },
-    ...source,
-});
-const generateExtendedVideo = async (ai, model, prompt, aspectRatio, imagePath, requestedDuration, movieFile, isVertexAI) => {
-    const extensionsNeeded = veoExtensionCount(requestedDuration);
-    GraphAILogger.info(`Veo 3.1 video extension: ${extensionsNeeded} extensions needed for ${requestedDuration}s target`);
-    const generateIteration = async (iteration, accumulatedDuration, previousVideo) => {
-        const isInitial = iteration === 0;
-        const remainingDuration = requestedDuration - accumulatedDuration;
-        const extensionDuration = isInitial ? VEO_SEGMENT_SEC : (getModelDuration("google", model, remainingDuration) ?? VEO_SEGMENT_SEC);
-        const getSource = () => {
-            if (isInitial)
-                return imagePath ? { image: loadImageAsBase64(imagePath) } : undefined;
-            return previousVideo?.uri ? { video: { uri: previousVideo.uri } } : undefined;
-        };
-        const payload = createVeo31Payload(model, prompt, aspectRatio, getSource());
-        GraphAILogger.info(isInitial ? "Generating initial 8s video..." : `Extending video: iteration ${iteration}/${extensionsNeeded} (+${extensionDuration}s)...`);
-        const operation = await ai.models.generateVideos(payload);
-        const response = await pollUntilDone(ai, operation);
-        const video = getVideoFromResponse(response, iteration);
-        const totalDuration = accumulatedDuration + extensionDuration;
-        GraphAILogger.info(`Video ${isInitial ? "generated" : "extended"}: ~${totalDuration}s total`);
-        return { video, duration: totalDuration };
-    };
-    const result = await Array.from({ length: extensionsNeeded + 1 }).reduce(async (prev, _, index) => {
-        const { video, duration } = await prev;
-        return generateIteration(index, duration, video);
-    }, Promise.resolve({ video: undefined, duration: 0 }));
-    if (!result.video) {
-        throw new Error("Failed to generate extended video", {
-            cause: agentInvalidResponseError("movieGenAIAgent", imageAction, movieFileTarget),
+const isOmniImage = (frame) => frame !== undefined;
+const nextOmniRequest = (input, durationSec, previous, frames) => {
+    if (!previous)
+        return buildGeminiOmniVideoRequest({ ...input, durationSec, frames });
+    if (!previous.id)
+        throw new Error("Gemini Omni returned no interaction id to extend");
+    return buildGeminiOmniVideoRequest({ ...input, prompt: geminiOmniExtensionPrompt(input.prompt), durationSec, previousInteractionId: previous.id });
+};
+// Each call after the first extends the previous interaction's video and answers with the whole video so far.
+export const generateGeminiOmniVideo = async (ai, input) => {
+    const segments = geminiOmniSegments(input.requestedSec);
+    const frames = [input.firstFrame, segments.length === 1 ? input.lastFrame : undefined].filter(isOmniImage);
+    const last = await segments.reduce(async (previousPromise, durationSec) => {
+        const request = nextOmniRequest(input, durationSec, await previousPromise, frames);
+        return ai.interactions.create(request, { timeout: GEMINI_OMNI_REQUEST_TIMEOUT_MS });
+    }, Promise.resolve(undefined));
+    return videoFromInteraction(last?.output_video);
+};
+const omniImage = (imagePath) => {
+    const { imageBytes, mimeType } = loadImageAsBase64(imagePath);
+    return { data: imageBytes, mime_type: mimeType };
+};
+const omniFrames = (input, { imagePath, lastFrameImagePath, referenceImages }) => {
+    if (referenceImages && referenceImages.length > 0) {
+        GraphAILogger.warn(`movieGenAIAgent: model ${input.model} does not support referenceImages — ignoring`);
+    }
+    if (lastFrameImagePath && !imagePath) {
+        GraphAILogger.warn(`movieGenAIAgent: lastFrame requires a first frame image (imagePrompt or firstFrameImageName) — ignoring lastFrameImageName`);
+    }
+    else if (lastFrameImagePath && geminiOmniSegments(input.requestedSec).length > 1) {
+        GraphAILogger.warn(`movieGenAIAgent: lastFrame applies to a single ${input.model} segment — ignoring lastFrameImageName for a ${input.requestedSec}s beat`);
+    }
+    const lastFrame = lastFrameImagePath && imagePath ? omniImage(lastFrameImagePath) : undefined;
+    return { firstFrame: imagePath ? omniImage(imagePath) : undefined, lastFrame };
+};
+const generateOmniVideoFile = async (ai, isVertexAI, input, sources, movieFile) => {
+    if (isVertexAI) {
+        throw new Error(`Model ${input.model} is supported on the Gemini API only; use veo-3.1-generate-001 with Vertex AI.`, {
+            cause: agentGenerationError("movieGenAIAgent", imageAction, unsupportedModelTarget),
         });
     }
-    return downloadVideo(ai, result.video, movieFile, isVertexAI, model);
+    if (input.requestedSec > GEMINI_OMNI_MAX_TOTAL_SEC) {
+        GraphAILogger.warn(`movieGenAIAgent: ${input.model} makes at most ${GEMINI_OMNI_MAX_TOTAL_SEC}s — the ${input.requestedSec}s beat gets a shorter video`);
+    }
+    writeFileSync(movieFile, await generateGeminiOmniVideo(ai, { ...input, ...omniFrames(input, sources) }));
+    const predictSec = await probeDurationSec(movieFile);
+    return { saved: movieFile, usage: predictSec !== undefined ? { provider: "google", model: input.model, predictSec } : undefined };
 };
 const generateStandardVideo = async (ai, model, prompt, aspectRatio, imagePath, lastFrameImagePath, referenceImages, duration, movieFile, isVertexAI) => {
     const capabilities = provider2MovieAgent.google.modelParams[model];
@@ -173,6 +182,10 @@ export const movieGenAIAgent = async ({ namedInputs, params, config, }) => {
     const model = params.model ?? defaultMovieModel("google", params);
     const apiKey = config?.apiKey;
     try {
+        const unsupportedMessage = unsupportedGoogleMovieModelMessage(model);
+        if (unsupportedMessage) {
+            throw new Error(unsupportedMessage, { cause: agentGenerationError("movieGenAIAgent", imageAction, unsupportedModelTarget) });
+        }
         const requestedDuration = params.duration ?? 8;
         const duration = getModelDuration("google", model, requestedDuration);
         if (duration === undefined) {
@@ -208,9 +221,9 @@ export const movieGenAIAgent = async ({ namedInputs, params, config, }) => {
                 }
                 return new GoogleGenAI({ apiKey, httpOptions: { timeout: GENAI_REQUEST_TIMEOUT_MS } });
             })();
-        // Veo 3.1: Video extension mode for videos longer than 8s
-        if (model === VEO_EXTENSION_MODEL && requestedDuration > VEO_SEGMENT_SEC && params.canvasSize) {
-            return generateExtendedVideo(ai, model, prompt, aspectRatio, imagePath, requestedDuration, movieFile, isVertexAI);
+        if (isGeminiOmniVideoModel(model)) {
+            const omniInput = { model, prompt, aspectRatio: geminiOmniAspectRatio(params.canvasSize), requestedSec: requestedDuration };
+            return generateOmniVideoFile(ai, isVertexAI, omniInput, { imagePath, lastFrameImagePath, referenceImages }, movieFile);
         }
         // Standard mode
         return generateStandardVideo(ai, model, prompt, aspectRatio, imagePath, lastFrameImagePath, referenceImages, duration, movieFile, isVertexAI);

package/lib/cli/commands/bundle/builder.d.ts

@@ -11,6 +11,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     g: boolean;
 } & {
     backup: boolean;
+} & {
+    "strict-network": boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/html/builder.d.ts

@@ -11,6 +11,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     g: boolean;
 } & {
     backup: boolean;
+} & {
+    "strict-network": boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/markdown/builder.d.ts

@@ -11,6 +11,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     g: boolean;
 } & {
     backup: boolean;
+} & {
+    "strict-network": boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/commands/viewer/builder.d.ts

@@ -11,6 +11,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     g: boolean;
 } & {
     backup: boolean;
+} & {
+    "strict-network": boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/common.d.ts

@@ -16,6 +16,8 @@ export declare const commonOptions: (yargs: Argv) => Argv<{
     g: boolean;
 } & {
     backup: boolean;
+} & {
+    "strict-network": boolean;
 } & {
     p: string | undefined;
 } & {

package/lib/cli/common.js

@@ -49,6 +49,11 @@ export const commonOptions = (yargs) => {
         describe: "create backup media file",
         type: "boolean",
         default: false,
+    })
+        .option("strict-network", {
+        describe: "Let HTML renderers reach only local files and the CDNs mulmocast's templates use (also MULMO_STRICT_NETWORK=1)",
+        type: "boolean",
+        default: false,
     })
         .option("p", {
         alias: "presentationStyle",

package/lib/cli/helpers.js

@@ -10,6 +10,7 @@ import { translate } from "../actions/translate.js";
 import { initializeContextFromFiles } from "../utils/context.js";
 import { estimateUsage, actionEstimateProcesses } from "../utils/estimate_usage.js";
 import { formatUsageEstimates } from "../utils/estimate_usage_format.js";
+import { strictNetworkFromEnv } from "../utils/render_network_policy.js";
 export const runTranslateIfNeeded = async (context, includeCaption = false) => {
     if (MulmoStudioContextMethods.needTranslate(context, includeCaption)) {
         GraphAILogger.log("run translate");
@@ -151,5 +152,6 @@ export const initializeContext = async (argv, raiseError = false) => {
         grouped: Boolean(argv.g),
     });
     setGraphAILogger(Boolean(argv.v), { files });
-    return await initializeContextFromFiles(files, raiseError, Boolean(argv.f), Boolean(argv.backup), argv.c, argv.l);
+    const context = await initializeContextFromFiles(files, raiseError, Boolean(argv.f), Boolean(argv.backup), argv.c, argv.l);
+    return context && { ...context, strictNetwork: Boolean(argv.strictNetwork) || strictNetworkFromEnv(process.env) };
 };

package/lib/methods/mulmo_studio_context.d.ts

@@ -12,6 +12,10 @@ export declare const MulmoStudioContextMethods: {
     getImageDirPath(context: MulmoStudioContext): string;
     getImageProjectDirPath(context: MulmoStudioContext): string;
     getOutDirPath(context: MulmoStudioContext): string;
+    getRenderNetworkOptions(context: MulmoStudioContext): {
+        strictNetwork: boolean;
+        allowedFileRoots: string[];
+    };
     getFileName(context: MulmoStudioContext): string;
     getCaption(context: MulmoStudioContext): string | undefined;
     setSessionState(context: MulmoStudioContext, sessionType: SessionType, value: boolean, result?: boolean): void;

package/lib/methods/mulmo_studio_context.js

@@ -53,6 +53,13 @@ export const MulmoStudioContextMethods = {
     getOutDirPath(context) {
         return context.fileDirs.outDirPath;
     },
+    // In strict network mode a renderer may read files only from the script's folder and mulmocast's output folders.
+    // A script loaded by URL has no local folder: its mulmoFileDirPath is the parent of the base directory.
+    getRenderNetworkOptions(context) {
+        const { mulmoFileDirPath, outDirPath, imageDirPath, audioDirPath, isHttpPath } = context.fileDirs;
+        const scriptRoots = isHttpPath ? [] : [mulmoFileDirPath];
+        return { strictNetwork: Boolean(context.strictNetwork), allowedFileRoots: [...scriptRoots, outDirPath, imageDirPath, audioDirPath] };
+    },
     getFileName(context) {
         return context.studio.filename;
     },

package/lib/types/provider2agent.d.ts

@@ -233,13 +233,10 @@ export declare const ProviderName: {
 export declare const isImageProvider: (provider: string | undefined) => provider is keyof typeof provider2ImageAgent;
 export declare const getMaxImageReferenceImages: (provider: string | undefined, model: string) => number | undefined;
 export declare const getModelAudio: (provider: keyof typeof provider2MovieAgent, model: string) => MovieAudioSpec | undefined;
+export declare const unsupportedGoogleMovieModelMessage: (model: string) => string | null;
 export declare const defaultMovieModel: (provider: keyof typeof provider2MovieAgent, movieParams?: {
     vertexai_project?: string;
 }) => string;
-export declare const VEO_EXTENSION_MODEL = "veo-3.1-generate-preview";
-export declare const VEO_SEGMENT_SEC = 8;
-export declare const veoExtensionCount: (requestedSec: number) => number;
-export declare const veoExtendedSeconds: (requestedSec: number) => number;
 export declare const getModelDuration: (provider: keyof typeof provider2MovieAgent, model: string, movieDuration?: number) => number | undefined;
 export type ModelPricing = {
     unit: "tokens" | "chars" | "seconds" | "images";

package/lib/types/provider2agent.js

@@ -383,20 +383,21 @@ export const provider2MovieAgent = {
     },
     google: {
         agentName: "movieGenAIAgent",
-        // veo-2.0 and veo-3.0 were shut down on 2026-06-30; the Gemini API now lists only the Veo 3.1 previews.
-        defaultModel: "veo-3.1-generate-preview",
-        models: ["veo-3.1-generate-preview", "veo-3.1-lite-generate-preview", "veo-3.1-generate-001"],
+        // The Veo 3.1 previews shut down on the Gemini API on 2026-10-22 (removed here ahead of that); Gemini Omni is their successor.
+        defaultModel: "gemini-omni-1.1-flash",
+        models: ["gemini-omni-1.1-flash", "veo-3.1-generate-001"],
         keyName: "GEMINI_API_KEY",
         modelParams: {
-            "veo-3.1-lite-generate-preview": {
-                durations: [4, 6, 8],
+            // Gemini API only. Longer beats are extended, up to 40 seconds (see gemini_omni_video.ts).
+            "gemini-omni-1.1-flash": {
+                durations: [3, 4, 5, 6, 7, 8, 9, 10],
                 supportsDuration: true,
                 supportsLastFrame: true,
                 supportsReferenceImages: false,
                 supportsPersonGeneration: false,
                 audio: { mode: AUDIO_MODE_ALWAYS },
             },
-            // Vertex AI only: the GA name of Veo 3.1 there, where the preview IDs are retired.
+            // Vertex AI only: the GA name of Veo 3.1 there.
             "veo-3.1-generate-001": {
                 durations: [4, 6, 8],
                 supportsDuration: true,
@@ -405,14 +406,6 @@ export const provider2MovieAgent = {
                 supportsPersonGeneration: false,
                 audio: { mode: AUDIO_MODE_ALWAYS },
             },
-            "veo-3.1-generate-preview": {
-                durations: [4, 6, 8],
-                supportsDuration: true,
-                supportsLastFrame: true,
-                supportsReferenceImages: true,
-                supportsPersonGeneration: false,
-                audio: { mode: AUDIO_MODE_ALWAYS },
-            },
         },
     },
     mock: {
@@ -585,15 +578,26 @@ export const getModelAudio = (provider, model) => {
     return modelParams?.[model]?.audio;
 };
 const GOOGLE_VERTEX_DEFAULT_MOVIE_MODEL = "veo-3.1-generate-001";
-// The default model is shared by the Gemini API and Vertex AI, but Vertex retired the Veo 3.1 preview IDs.
+const removedGoogleMovieModelHint = "Its Gemini API shutdown date is 2026-10-22, so mulmocast no longer offers it. Use 'gemini-omni-1.1-flash' on the Gemini API, or 'veo-3.1-generate-001' with movieParams.vertexai_project on Vertex AI (needed for referenceImages).";
+const removedGoogleMovieModelHints = {
+    "veo-3.1-generate-preview": removedGoogleMovieModelHint,
+    "veo-3.1-lite-generate-preview": removedGoogleMovieModelHint,
+};
+// An unknown model fails here with a hint, not with a TypeError in the duration lookup.
+export const unsupportedGoogleMovieModelMessage = (model) => {
+    if (Object.hasOwn(provider2MovieAgent.google.modelParams, model))
+        return null;
+    const hint = Object.hasOwn(removedGoogleMovieModelHints, model)
+        ? removedGoogleMovieModelHints[model]
+        : `Supported models: ${provider2MovieAgent.google.models.join(", ")}.`;
+    return `Google movie model "${model}" is not supported. ${hint}`;
+};
+// Gemini Omni is a Gemini API model here, so Vertex AI keeps Veo 3.1 as its default.
 export const defaultMovieModel = (provider, movieParams) => provider === "google" && movieParams?.vertexai_project ? GOOGLE_VERTEX_DEFAULT_MOVIE_MODEL : provider2MovieAgent[provider].defaultModel;
-// Veo 3.1 (preview) builds clips longer than one segment by extending an 8-second first segment 8 seconds at a time.
-export const VEO_EXTENSION_MODEL = "veo-3.1-generate-preview";
-export const VEO_SEGMENT_SEC = 8;
-export const veoExtensionCount = (requestedSec) => Math.ceil((requestedSec - VEO_SEGMENT_SEC) / VEO_SEGMENT_SEC);
-export const veoExtendedSeconds = (requestedSec) => VEO_SEGMENT_SEC * (1 + veoExtensionCount(requestedSec));
 export const getModelDuration = (provider, model, movieDuration) => {
     const modelParams = provider2MovieAgent[provider]?.modelParams;
+    if (!modelParams || !Object.hasOwn(modelParams, model))
+        return undefined;
     const { durations } = modelParams[model];
     if (durations && movieDuration) {
         const largerDurations = durations.filter((d) => d >= movieDuration);
@@ -656,12 +660,11 @@ export const modelPricing = {
         "gemini-2.5-flash-image": { unit: "images", inputPerMTokensUSD: 0.3, perImageUSD: 0.039, asOf: "2026-07-03" },
         // $0.0336 per 1K-resolution image
         "gemini-3.1-flash-lite-image": { unit: "images", inputPerMTokensUSD: 0.25, perImageUSD: 0.0336, asOf: "2026-10-07" },
-        // Veo per second of generated video (720p). veo-2.0-generate-001 and veo-3.0-generate-001
-        // were shut down on 2026-06-30, so they intentionally have no price.
-        "veo-3.1-generate-preview": { unit: "seconds", perSecUSD: 0.4, asOf: "2026-07-03" },
+        // Video per generated second at 720p. Shut-down models (veo-2.0, veo-3.0, the Veo 3.1 previews) intentionally have no price.
+        // Gemini Omni bills video output tokens at $17.50/1M, 5,792 tokens per second of 720p video.
+        "gemini-omni-1.1-flash": { unit: "seconds", perSecUSD: 0.1014, asOf: "2026-10-07" },
         // Vertex AI: https://cloud.google.com/vertex-ai/generative-ai/pricing (video + audio, 720p/1080p)
         "veo-3.1-generate-001": { unit: "seconds", perSecUSD: 0.4, asOf: "2026-10-07" },
-        "veo-3.1-lite-generate-preview": { unit: "seconds", perSecUSD: 0.05, asOf: "2026-07-03" },
         // Google Cloud Text-to-Speech per 1M characters, keyed by voice tier.
         // https://cloud.google.com/text-to-speech/pricing
         "tts-standard": { unit: "chars", perMCharsUSD: 4, asOf: "2026-07-03" },

package/lib/types/type.d.ts

@@ -77,6 +77,7 @@ export type MulmoStudioContext = {
     presentationStyle: MulmoPresentationStyle;
     multiLingual: MulmoStudioMultiLingualArray;
     usageCollector?: UsageCollectorAPI;
+    strictNetwork?: boolean;
 };
 export type ScriptingParams = {
     urls: string[];
@@ -162,6 +163,7 @@ export type InitOptions = {
     c?: string;
     p?: string;
     g?: boolean;
+    strictNetwork?: boolean;
 };
 export type PublicAPIArgs = {
     settings?: Record<string, string>;

package/lib/utils/estimate_usage.js

@@ -4,11 +4,12 @@
 // assume every asset is generated fresh.
 import { Tiktoken } from "js-tiktoken/lite";
 import o200k_base from "js-tiktoken/ranks/o200k_base";
-import { provider2TTSAgent, provider2MovieAgent, gptImageOutputTokens, isGptImage25Model, getModelDuration, defaultMovieModel, veoExtendedSeconds, VEO_EXTENSION_MODEL, VEO_SEGMENT_SEC, getModelPricing, defaultProviders, } from "../types/provider2agent.js";
+import { provider2TTSAgent, provider2MovieAgent, gptImageOutputTokens, isGptImage25Model, getModelDuration, defaultMovieModel, getModelPricing, defaultProviders, } from "../types/provider2agent.js";
 import { text2SpeechProviderSchema, text2MovieProviderSchema } from "../types/schema.js";
 import { MulmoPresentationStyleMethods } from "../methods/mulmo_presentation_style.js";
 import { MulmoBeatMethods } from "../methods/mulmo_beat.js";
 import { geminiTtsInputText } from "./gemini_tts.js";
+import { geminiOmniTotalSec, isGeminiOmniVideoModel } from "./gemini_omni_video.js";
 import { imagePrompt, htmlImageSystemPrompt, translateSystemPrompt, translatePrompts } from "./prompt.js";
 const MILLION = 1_000_000;
 const LATIN_CHARS_PER_TOKEN = 4;
@@ -217,8 +218,8 @@ const beatDurationMetric = (beat) => {
     }
     return estimated(beat.text ? estimateSpeechSec(beat.text) : DEFAULT_MOVIE_DURATION_SEC);
 };
-// The movie agent extends these clips past one segment instead of capping them, and Google bills every generated second.
-const isVeoExtension = (provider, model, duration) => provider === "google" && model === VEO_EXTENSION_MODEL && duration.value > VEO_SEGMENT_SEC;
+// Gemini Omni beats past one segment are extended rather than capped, and Google bills every generated second.
+const isGeminiOmniMovie = (provider, model) => provider === "google" && isGeminiOmniVideoModel(model);
 const snapMovieDuration = (provider, model, duration) => {
     if (!isKeyOf(provider2MovieAgent[provider].modelParams, model)) {
         return duration;
@@ -234,8 +235,8 @@ const estimateMovieGeneration = (style, beat, beatIndex, refKey) => {
     }
     const model = info.movieParams?.model ?? defaultMovieModel(provider, info.movieParams);
     const duration = beat ? beatDurationMetric(beat) : estimated(DEFAULT_MOVIE_DURATION_SEC);
-    const predictSec = isVeoExtension(provider, model, duration)
-        ? metric(veoExtendedSeconds(duration.value), duration.precision === "exact")
+    const predictSec = isGeminiOmniMovie(provider, model)
+        ? metric(geminiOmniTotalSec(duration.value), duration.precision === "exact")
         : snapMovieDuration(provider, model, duration);
     return attachCost({ process: refKey === undefined ? "movie" : "movieReference", beatIndex, refKey, provider, model, predictSec });
 };

package/lib/utils/gemini_omni_video.d.ts

@@ -0,0 +1,49 @@
+export declare const GEMINI_OMNI_MIN_SEGMENT_SEC = 3;
+export declare const GEMINI_OMNI_MAX_SEGMENT_SEC = 10;
+export declare const GEMINI_OMNI_MAX_TOTAL_SEC = 40;
+export declare const GEMINI_OMNI_RESOLUTION = "720p";
+export declare const isGeminiOmniVideoModel: (model: string) => boolean;
+export declare const geminiOmniTotalSec: (requestedSec: number) => number;
+export declare const geminiOmniSegments: (requestedSec: number) => number[];
+export declare const geminiOmniAspectRatio: (canvasSize: {
+    width: number;
+    height: number;
+}) => string;
+export type GeminiOmniImage = {
+    data: string;
+    mime_type: string;
+};
+export type GeminiOmniVideoRequestInput = {
+    model: string;
+    prompt: string;
+    aspectRatio: string;
+    durationSec: number;
+    frames?: GeminiOmniImage[];
+    previousInteractionId?: string;
+};
+export declare const geminiOmniExtensionPrompt: (prompt: string) => string;
+export declare const buildGeminiOmniVideoRequest: ({ model, prompt, aspectRatio, durationSec, frames, previousInteractionId }: GeminiOmniVideoRequestInput) => {
+    response_format: {
+        type: "video";
+        aspect_ratio: string;
+        resolution: string;
+        duration: string;
+    };
+    previous_interaction_id?: string | undefined;
+    model: string;
+    input: string | ({
+        data: string;
+        mime_type: string;
+        type: "image";
+    } | {
+        type: "text";
+        text: string;
+    })[];
+};
+export type GeminiOmniVideoRequest = ReturnType<typeof buildGeminiOmniVideoRequest>;
+type InteractionVideo = {
+    data?: string;
+    mime_type?: string;
+};
+export declare const videoFromInteraction: (video: InteractionVideo | undefined) => Buffer;
+export {};

package/lib/utils/gemini_omni_video.js

@@ -0,0 +1,36 @@
+import { getAspectRatio } from "./utils.js";
+// Gemini Omni video goes through the Interactions API: one call makes 3 to 10 whole seconds, and a call that
+// names the previous interaction extends that video, up to 40 seconds in all.
+export const GEMINI_OMNI_MIN_SEGMENT_SEC = 3;
+export const GEMINI_OMNI_MAX_SEGMENT_SEC = 10;
+export const GEMINI_OMNI_MAX_TOTAL_SEC = 40;
+export const GEMINI_OMNI_RESOLUTION = "720p";
+const GEMINI_OMNI_ASPECT_RATIOS = ["16:9", "9:16"];
+export const isGeminiOmniVideoModel = (model) => model.startsWith("gemini-omni-");
+export const geminiOmniTotalSec = (requestedSec) => {
+    if (!Number.isFinite(requestedSec))
+        throw new RangeError(`Invalid video duration: ${requestedSec}`);
+    return Math.min(Math.max(Math.ceil(requestedSec), GEMINI_OMNI_MIN_SEGMENT_SEC), GEMINI_OMNI_MAX_TOTAL_SEC);
+};
+// Split evenly so no segment falls under the 3-second minimum (11s is 6 + 5, not 10 + 1).
+export const geminiOmniSegments = (requestedSec) => {
+    const totalSec = geminiOmniTotalSec(requestedSec);
+    const count = Math.ceil(totalSec / GEMINI_OMNI_MAX_SEGMENT_SEC);
+    const baseSec = Math.floor(totalSec / count);
+    return Array.from({ length: count }, (_, index) => baseSec + (index < totalSec % count ? 1 : 0));
+};
+export const geminiOmniAspectRatio = (canvasSize) => getAspectRatio(canvasSize, GEMINI_OMNI_ASPECT_RATIOS);
+export const geminiOmniExtensionPrompt = (prompt) => `The scene continues: ${prompt}`;
+export const buildGeminiOmniVideoRequest = ({ model, prompt, aspectRatio, durationSec, frames = [], previousInteractionId }) => ({
+    model,
+    input: frames.length > 0 ? [...frames.map((frame) => ({ type: "image", ...frame })), { type: "text", text: prompt }] : prompt,
+    ...(previousInteractionId ? { previous_interaction_id: previousInteractionId } : {}),
+    response_format: { type: "video", aspect_ratio: aspectRatio, resolution: GEMINI_OMNI_RESOLUTION, duration: `${durationSec}s` },
+});
+export const videoFromInteraction = (video) => {
+    if (!video?.data)
+        throw new Error("No video data returned");
+    if (video.mime_type !== "video/mp4")
+        throw new Error(`Gemini Omni returned ${video.mime_type ?? "video of an unknown type"}, expected video/mp4`);
+    return Buffer.from(video.data, "base64");
+};

package/lib/utils/html_render.d.ts

@@ -1,4 +1,5 @@
-export declare const renderHTMLToImage: (html: string, outputPath: string, width: number, height: number, isMermaid?: boolean, omitBackground?: boolean) => Promise<void>;
+import { type RenderNetworkOptions } from "./render_network_policy.js";
+export declare const renderHTMLToImage: (html: string, outputPath: string, width: number, height: number, isMermaid?: boolean, omitBackground?: boolean, network?: RenderNetworkOptions) => Promise<void>;
 /**
  * Render an animated HTML page frame-by-frame using Puppeteer.
  *
@@ -9,18 +10,18 @@ export declare const renderHTMLToImage: (html: string, outputPath: string, width
  *
  * The user-defined render() function may be sync or async.
  */
-export declare const renderHTMLToFrames: (html: string, outputDir: string, width: number, height: number, totalFrames: number, fps: number) => Promise<string[]>;
+export declare const renderHTMLToFrames: (html: string, outputDir: string, width: number, height: number, totalFrames: number, fps: number, network?: RenderNetworkOptions) => Promise<string[]>;
 /**
  * Record an animated HTML page as video using Puppeteer's screencast API.
  * The animation plays in real-time via requestAnimationFrame, and
  * page.screencast() captures frames directly to an mp4 file.
  */
-export declare const renderHTMLToVideo: (html: string, videoPath: string, width: number, height: number, totalFrames: number, fps: number) => Promise<void>;
+export declare const renderHTMLToVideo: (html: string, videoPath: string, width: number, height: number, totalFrames: number, fps: number, network?: RenderNetworkOptions) => Promise<void>;
 /**
  * Render the final frame of an animated HTML page as a static image.
  * Loads the animated HTML, calls window.renderFinal() to set all animations
  * to their end state, then takes a screenshot. Used for PDF/thumbnail generation.
  */
-export declare const renderHTMLToFinalFrame: (html: string, outputPath: string, width: number, height: number) => Promise<void>;
-export declare const renderMarkdownToImage: (markdown: string, style: string, outputPath: string, width: number, height: number) => Promise<void>;
+export declare const renderHTMLToFinalFrame: (html: string, outputPath: string, width: number, height: number, network?: RenderNetworkOptions) => Promise<void>;
+export declare const renderMarkdownToImage: (markdown: string, style: string, outputPath: string, width: number, height: number, network?: RenderNetworkOptions) => Promise<void>;
 export declare const interpolate: (template: string, data: Record<string, string>) => string;