mulmocast 2.16.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/agents/tts_gemini_agent.d.ts

@@ -1,5 +1,61 @@
 import type { AgentFunction, AgentFunctionInfo } from "graphai";
+import { type GenerateContentConfig } from "@google/genai";
+import { buildGeminiInteractionsTtsRequest, type GeminiInteractionsTtsInput } from "../utils/gemini_tts.js";
 import type { GoogleTTSAgentParams, AgentBufferResult, AgentTextInputs, AgentErrorResult } from "../types/agent.js";
+import type { AgentUsage } from "../types/usage.js";
+type GeminiAudio = {
+    rawPcm: Buffer;
+    sampleRate: number;
+    usage: AgentUsage | undefined;
+};
+type InlineAudioResponse = {
+    candidates?: {
+        content?: {
+            parts?: {
+                inlineData?: {
+                    data?: string;
+                    mimeType?: string;
+                };
+            }[];
+        };
+    }[];
+    usageMetadata?: {
+        promptTokenCount?: number;
+        candidatesTokenCount?: number;
+        totalTokenCount?: number;
+    };
+};
+type InteractionAudioResponse = {
+    output_audio?: {
+        data?: string;
+        mime_type?: string;
+        sample_rate?: number;
+    };
+    usage?: {
+        total_input_tokens?: number;
+        total_output_tokens?: number;
+        total_tokens?: number;
+    };
+};
+export type GeminiTtsClient = {
+    models: {
+        generateContent: (params: {
+            model: string;
+            contents: {
+                parts: {
+                    text: string;
+                }[];
+            }[];
+            config: GenerateContentConfig;
+        }) => Promise<InlineAudioResponse>;
+    };
+    interactions: {
+        create: (params: ReturnType<typeof buildGeminiInteractionsTtsRequest>, options?: {
+            timeout?: number;
+        }) => Promise<InteractionAudioResponse>;
+    };
+};
+export declare const generateGeminiTts: (ai: GeminiTtsClient, input: GeminiInteractionsTtsInput) => Promise<GeminiAudio>;
 export declare const ttsGeminiAgent: AgentFunction<GoogleTTSAgentParams, AgentBufferResult | AgentErrorResult, AgentTextInputs>;
 declare const ttsGeminiAgentInfo: AgentFunctionInfo;
 export default ttsGeminiAgentInfo;

package/lib/agents/tts_gemini_agent.js

@@ -3,16 +3,51 @@ import { GoogleGenAI } from "@google/genai";
 import { provider2TTSAgent } from "../types/provider2agent.js";
 import { agentIncorrectAPIKeyError, apiKeyMissingError, agentGenerationError, audioAction, audioFileTarget, getGenAIErrorReason, } from "../utils/error_cause.js";
 import { pcmToMp3 } from "../utils/ffmpeg_utils.js";
+import { GEMINI_TTS_SAMPLE_RATE, buildGeminiInteractionsTtsRequest, geminiDirectorsNotesPrompt, pcmFromInteractionAudio, usesGeminiInteractionsTts, } from "../utils/gemini_tts.js";
 // Per-request timeout so a stalled GenAI TTS call rejects (and GraphAI retry can
 // recover) instead of hanging. Generous vs. normal generation time.
 const GENAI_REQUEST_TIMEOUT_MS = 120_000;
-const getPrompt = (text, instructions) => {
-    // https://ai.google.dev/gemini-api/docs/speech-generation?hl=ja#controllable
-    if (instructions) {
-        return `### DIRECTOR'S NOTES\n${instructions}\n\n#### TRANSCRIPT\n${text}`;
-    }
-    return text;
+const geminiUsage = (model, inputTokens, outputTokens, totalTokens) => ({
+    provider: "gemini",
+    model,
+    inputTokens,
+    outputTokens,
+    totalTokens,
+});
+// 2.5 TTS: generateContent, direction embedded in the prompt, headerless PCM with the rate in the mimeType.
+const generateWithContent = async (ai, { model, text, voice, instructions }) => {
+    const response = await ai.models.generateContent({
+        model,
+        contents: [{ parts: [{ text: geminiDirectorsNotesPrompt(text, instructions) }] }],
+        config: {
+            responseModalities: ["AUDIO"],
+            speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: voice } } },
+        },
+    });
+    const inlineData = response.candidates?.[0]?.content?.parts?.[0]?.inlineData;
+    const pcmBase64 = inlineData?.data;
+    if (!pcmBase64 || typeof pcmBase64 !== "string")
+        throw new Error("No audio data returned");
+    // Extract sample rate from mimeType (e.g., "audio/L16;codec=pcm;rate=24000")
+    const rateMatch = inlineData?.mimeType?.match(/rate=(\d+)/);
+    const sampleRate = rateMatch ? parseInt(rateMatch[1]) : GEMINI_TTS_SAMPLE_RATE;
+    const metadata = response.usageMetadata;
+    return {
+        rawPcm: Buffer.from(pcmBase64, "base64"),
+        sampleRate,
+        usage: metadata ? geminiUsage(model, metadata.promptTokenCount, metadata.candidatesTokenCount, metadata.totalTokenCount) : undefined,
+    };
+};
+const generateWithInteractions = async (ai, input) => {
+    // Passed per request too: the Interactions client is built apart from the models client.
+    const interaction = await ai.interactions.create(buildGeminiInteractionsTtsRequest(input), { timeout: GENAI_REQUEST_TIMEOUT_MS });
+    const usage = interaction.usage;
+    return {
+        ...pcmFromInteractionAudio(interaction.output_audio),
+        usage: usage ? geminiUsage(input.model, usage.total_input_tokens, usage.total_output_tokens, usage.total_tokens) : undefined,
+    };
 };
+export const generateGeminiTts = (ai, input) => usesGeminiInteractionsTts(input.model) ? generateWithInteractions(ai, input) : generateWithContent(ai, input);
 export const ttsGeminiAgent = async ({ namedInputs, params, config, }) => {
     const { text } = namedInputs;
     const { model, voice, suppressError, instructions } = params;
@@ -25,38 +60,8 @@ export const ttsGeminiAgent = async ({ namedInputs, params, config, }) => {
     const geminiResult = await (async () => {
         try {
             const ai = new GoogleGenAI({ apiKey, httpOptions: { timeout: GENAI_REQUEST_TIMEOUT_MS } });
-            const response = await ai.models.generateContent({
-                model: model ?? provider2TTSAgent.gemini.defaultModel,
-                contents: [{ parts: [{ text: getPrompt(text, instructions) }] }],
-                config: {
-                    responseModalities: ["AUDIO"],
-                    speechConfig: {
-                        voiceConfig: {
-                            prebuiltVoiceConfig: { voiceName: voice ?? provider2TTSAgent.gemini.defaultVoice },
-                        },
-                    },
-                },
-            });
-            const inlineData = response.candidates?.[0]?.content?.parts?.[0]?.inlineData;
-            const pcmBase64 = inlineData?.data;
-            const mimeType = inlineData?.mimeType;
-            if (!pcmBase64 || typeof pcmBase64 !== "string")
-                throw new Error("No audio data returned");
-            // Extract sample rate from mimeType (e.g., "audio/L16;codec=pcm;rate=24000")
-            const rateMatch = mimeType?.match(/rate=(\d+)/);
-            const sampleRate = rateMatch ? parseInt(rateMatch[1]) : 24000;
-            const rawPcm = Buffer.from(pcmBase64, "base64");
-            const usedModel = model ?? provider2TTSAgent.gemini.defaultModel;
-            const usage = response.usageMetadata
-                ? {
-                    provider: "gemini",
-                    model: usedModel,
-                    inputTokens: response.usageMetadata.promptTokenCount,
-                    outputTokens: response.usageMetadata.candidatesTokenCount,
-                    totalTokens: response.usageMetadata.totalTokenCount,
-                }
-                : undefined;
-            return { rawPcm, sampleRate, usage };
+            const request = { model: model ?? provider2TTSAgent.gemini.defaultModel, text, voice: voice ?? provider2TTSAgent.gemini.defaultVoice, instructions };
+            return await generateGeminiTts(ai, request);
         }
         catch (e) {
             if (suppressError) {

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

@@ -42,6 +42,8 @@ export declare const provider2TTSAgent: {
     };
 };
 export declare const gptImages: string[];
+export declare const isGptImage25Model: (model: string) => boolean;
+export declare const gptImageQuality: <Quality extends string>(model: string, quality?: Quality) => Quality | "high" | undefined;
 export declare const deprecatedOpenAIImageModelHints: {
     readonly "dall-e-2": "Use 'gpt-image-2.5-sunburst' or another supported model.";
     readonly "dall-e-3": "Use 'gpt-image-2.5-sunburst' or another supported model.";
@@ -231,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

@@ -16,9 +16,10 @@ export const provider2TTSAgent = {
     gemini: {
         agentName: "ttsGeminiAgent",
         hasLimitedConcurrency: false,
-        defaultModel: "gemini-2.5-flash-preview-tts",
+        // The 2.5 preview TTS models shut down on 2026-11-17; Google names gemini-3.8-flash-tts as their successor.
+        defaultModel: "gemini-3.8-flash-tts",
         defaultVoice: "Kore",
-        models: ["gemini-2.5-flash-preview-tts", "gemini-2.5-pro-preview-tts"],
+        models: ["gemini-3.8-flash-tts", "gemini-3.8-flash-lite-tts", "gemini-2.5-flash-preview-tts", "gemini-2.5-pro-preview-tts"],
         keyName: "GEMINI_API_KEY",
     },
     elevenlabs: {
@@ -45,6 +46,11 @@ export const provider2TTSAgent = {
     },
 };
 export const gptImages = ["gpt-image-2.5-sunburst", "gpt-image-2.5-flare", "gpt-image-2", "gpt-image-1.5", "gpt-image-1", "gpt-image-1-mini"];
+// The 2.5 models render "auto" (their default) at "low", where gpt-image-1 rendered it at "high".
+export const isGptImage25Model = (model) => model.startsWith("gpt-image-2.5");
+// An unset quality on 2.5 is sent as "high" to keep the look scripts had before the default model changed;
+// an explicit "auto" is the script's choice and is sent as is.
+export const gptImageQuality = (model, quality) => quality ?? (isGptImage25Model(model) ? "high" : undefined);
 const supportedOpenAIImageReplacementHint = "Use 'gpt-image-2.5-sunburst' or another supported model.";
 export const deprecatedOpenAIImageModelHints = {
     "dall-e-2": supportedOpenAIImageReplacementHint,
@@ -377,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,
@@ -399,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: {
@@ -579,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);
@@ -641,18 +651,20 @@ export const modelPricing = {
         // https://ai.google.dev/gemini-api/docs/pricing
         "gemini-2.5-flash-preview-tts": { unit: "tokens", inputPerMTokensUSD: 0.5, outputPerMTokensUSD: 10, asOf: "2026-07-03" },
         "gemini-2.5-pro-preview-tts": { unit: "tokens", inputPerMTokensUSD: 1, outputPerMTokensUSD: 20, asOf: "2026-07-03" },
+        // through 2026-12-31; $1 / $18 (flash) and $1 / $12 (lite) from 2027-01-01
+        "gemini-3.8-flash-tts": { unit: "tokens", inputPerMTokensUSD: 0.5, outputPerMTokensUSD: 9, asOf: "2026-10-07" },
+        "gemini-3.8-flash-lite-tts": { unit: "tokens", inputPerMTokensUSD: 0.5, outputPerMTokensUSD: 6, asOf: "2026-10-07" },
     },
     google: {
         // https://ai.google.dev/gemini-api/docs/pricing ($0.039/image ≒ 1290 output tokens at $30/1M)
         "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/schema.d.ts

@@ -4466,8 +4466,8 @@ export declare const mulmoOpenAIImageModelSchema: z.ZodObject<{
         [x: string]: string;
     }>>;
     quality: z.ZodOptional<z.ZodEnum<{
-        low: "low";
         high: "high";
+        low: "low";
         auto: "auto";
         medium: "medium";
     }>>;

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>;