mulmocast 0.0.15 → 0.0.17

package/lib/actions/movie.js

@@ -1,6 +1,6 @@
 import { GraphAILogger, assert } from "graphai";
 import { mulmoTransitionSchema } from "../types/index.js";
-import { MulmoScriptMethods } from "../methods/index.js";
+import { MulmoPresentationStyleMethods } from "../methods/index.js";
 import { getAudioArtifactFilePath, getOutputVideoFilePath, writingMessage } from "../utils/file.js";
 import { FfmpegContextAddInput, FfmpegContextInit, FfmpegContextPushFormattedAudio, FfmpegContextGenerateOutput } from "../utils/ffmpeg_utils.js";
 import { MulmoStudioContextMethods } from "../methods/mulmo_studio_context.js";
@@ -59,22 +59,22 @@ const getOutputOption = (audioId, videoId) => {
         "-b:a 128k", // Audio bitrate
     ];
 };
-const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, caption) => {
+const createVideo = async (audioArtifactFilePath, outputVideoPath, context, caption) => {
     const start = performance.now();
     const ffmpegContext = FfmpegContextInit();
-    const missingIndex = studio.beats.findIndex((beat) => !beat.imageFile && !beat.movieFile);
+    const missingIndex = context.studio.beats.findIndex((beat) => !beat.imageFile && !beat.movieFile);
     if (missingIndex !== -1) {
         GraphAILogger.info(`ERROR: beat.imageFile or beat.movieFile is not set on beat ${missingIndex}.`);
         return false;
     }
-    const canvasInfo = MulmoScriptMethods.getCanvasSize(studio.script);
+    const canvasInfo = MulmoPresentationStyleMethods.getCanvasSize(context.presentationStyle);
     // Add each image input
     const filterComplexVideoIds = [];
     const filterComplexAudioIds = [];
     const transitionVideoIds = [];
     const beatTimestamps = [];
-    studio.beats.reduce((timestamp, studioBeat, index) => {
-        const beat = studio.script.beats[index];
+    context.studio.beats.reduce((timestamp, studioBeat, index) => {
+        const beat = context.studio.script.beats[index];
         const sourceFile = studioBeat.movieFile ?? studioBeat.imageFile;
         if (!sourceFile) {
             throw new Error(`studioBeat.imageFile or studioBeat.movieFile is not set: index=${index}`);
@@ -83,14 +83,14 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
             throw new Error(`studioBeat.duration is not set: index=${index}`);
         }
         const inputIndex = FfmpegContextAddInput(ffmpegContext, sourceFile);
-        const mediaType = studioBeat.movieFile ? "movie" : MulmoScriptMethods.getImageType(studio.script, beat);
+        const mediaType = studioBeat.movieFile ? "movie" : MulmoPresentationStyleMethods.getImageType(context.presentationStyle, beat);
         const extraPadding = (() => {
             // We need to consider only intro and outro padding because the other paddings were already added to the beat.duration
             if (index === 0) {
-                return studio.script.audioParams.introPadding;
+                return context.presentationStyle.audioParams.introPadding;
             }
-            else if (index === studio.beats.length - 1) {
-                return studio.script.audioParams.outroPadding;
+            else if (index === context.studio.beats.length - 1) {
+                return context.presentationStyle.audioParams.outroPadding;
             }
             return 0;
         })();
@@ -106,7 +106,7 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
         else {
             filterComplexVideoIds.push(videoId);
         }
-        if (studio.script.movieParams?.transition && index < studio.beats.length - 1) {
+        if (context.presentationStyle.movieParams?.transition && index < context.studio.beats.length - 1) {
             const sourceId = filterComplexVideoIds.pop();
             ffmpegContext.filterComplex.push(`[${sourceId}]split=2[${sourceId}_0][${sourceId}_1]`);
             filterComplexVideoIds.push(`${sourceId}_0`);
@@ -127,16 +127,16 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
         beatTimestamps.push(timestamp);
         return timestamp + duration;
     }, 0);
-    assert(filterComplexVideoIds.length === studio.beats.length, "videoIds.length !== studio.beats.length");
-    assert(beatTimestamps.length === studio.beats.length, "beatTimestamps.length !== studio.beats.length");
+    assert(filterComplexVideoIds.length === context.studio.beats.length, "videoIds.length !== studio.beats.length");
+    assert(beatTimestamps.length === context.studio.beats.length, "beatTimestamps.length !== studio.beats.length");
     // console.log("*** images", images.audioIds);
     // Concatenate the trimmed images
     const concatVideoId = "concat_video";
-    ffmpegContext.filterComplex.push(`${filterComplexVideoIds.map((id) => `[${id}]`).join("")}concat=n=${studio.beats.length}:v=1:a=0[${concatVideoId}]`);
+    ffmpegContext.filterComplex.push(`${filterComplexVideoIds.map((id) => `[${id}]`).join("")}concat=n=${context.studio.beats.length}:v=1:a=0[${concatVideoId}]`);
     // Add tranditions if needed
     const mixedVideoId = (() => {
-        if (studio.script.movieParams?.transition && transitionVideoIds.length > 1) {
-            const transition = mulmoTransitionSchema.parse(studio.script.movieParams.transition);
+        if (context.presentationStyle.movieParams?.transition && transitionVideoIds.length > 0) {
+            const transition = mulmoTransitionSchema.parse(context.presentationStyle.movieParams.transition);
             return transitionVideoIds.reduce((acc, transitionVideoId, index) => {
                 const transitionStartTime = beatTimestamps[index + 1] - 0.05; // 0.05 is to avoid flickering
                 const processedVideoId = `${transitionVideoId}_f`;
@@ -166,8 +166,8 @@ const createVideo = async (audioArtifactFilePath, outputVideoPath, studio, capti
     await FfmpegContextGenerateOutput(ffmpegContext, outputVideoPath, getOutputOption(ffmpegContextAudioId, mixedVideoId));
     const end = performance.now();
     GraphAILogger.info(`Video created successfully! ${Math.round(end - start) / 1000} sec`);
-    GraphAILogger.info(studio.script.title);
-    GraphAILogger.info((studio.script.references ?? []).map((reference) => `${reference.title} (${reference.url})`).join("\n"));
+    GraphAILogger.info(context.studio.script.title);
+    GraphAILogger.info((context.studio.script.references ?? []).map((reference) => `${reference.title} (${reference.url})`).join("\n"));
     return true;
 };
 export const movieFilePath = (context) => {
@@ -181,7 +181,7 @@ export const movie = async (context) => {
         const { outDirPath } = fileDirs;
         const audioArtifactFilePath = getAudioArtifactFilePath(outDirPath, studio.filename);
         const outputVideoPath = movieFilePath(context);
-        if (await createVideo(audioArtifactFilePath, outputVideoPath, studio, caption)) {
+        if (await createVideo(audioArtifactFilePath, outputVideoPath, context, caption)) {
             writingMessage(outputVideoPath);
         }
     }

package/lib/actions/pdf.js

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import puppeteer from "puppeteer";
-import { MulmoScriptMethods } from "../methods/index.js";
+import { MulmoPresentationStyleMethods } from "../methods/index.js";
 import { localizedText, isHttp } from "../utils/utils.js";
 import { getOutputPdfFilePath, writingMessage, getHTMLFile } from "../utils/file.js";
 import { interpolate } from "../utils/markdown.js";
@@ -95,9 +95,8 @@ const getHandoutTemplateData = (isLandscapeImage) => ({
     item_flex: isLandscapeImage ? "flex: 1;" : "",
 });
 const generatePDFHTML = async (context, pdfMode, pdfSize) => {
-    const { studio, lang = "en" } = context;
-    const { multiLingual } = studio;
-    const { width: imageWidth, height: imageHeight } = MulmoScriptMethods.getCanvasSize(studio.script);
+    const { studio, multiLingual, lang = "en" } = context;
+    const { width: imageWidth, height: imageHeight } = MulmoPresentationStyleMethods.getCanvasSize(context.presentationStyle);
     const isLandscapeImage = imageWidth > imageHeight;
     const imagePaths = studio.beats.map((beat) => beat.imageFile);
     const texts = studio.script.beats.map((beat, index) => localizedText(beat, multiLingual?.[index], lang));

package/lib/actions/translate.js

@@ -4,7 +4,7 @@ import * as agents from "@graphai/vanilla";
 import { openAIAgent } from "@graphai/openai_agent";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
 import { recursiveSplitJa, replacementsJa, replacePairsJa } from "../utils/string.js";
-import { getOutputStudioFilePath, mkdir, writingMessage } from "../utils/file.js";
+import { getOutputMultilingualFilePath, mkdir, writingMessage } from "../utils/file.js";
 import { translateSystemPrompt, translatePrompts } from "../utils/prompt.js";
 import { MulmoStudioContextMethods } from "../methods/mulmo_studio_context.js";
 const vanillaAgents = agents.default ?? agents;
@@ -14,7 +14,7 @@ const translateGraph = {
         context: {},
         defaultLang: {},
         outDirPath: {},
-        outputStudioFilePath: {},
+        outputMultilingualFilePath: {},
         lang: {
             agent: "stringUpdateTextAgent",
             inputs: {
@@ -27,7 +27,7 @@ const translateGraph = {
             isResult: true,
             agent: "mergeObjectAgent",
             inputs: {
-                items: [":context.studio", { multiLingual: ":beatsMap.mergeMultiLingualData" }],
+                items: [{ multiLingual: ":beatsMap.mergeMultiLingualData" }],
             },
         },
         beatsMap: {
@@ -52,7 +52,7 @@ const translateGraph = {
                         },
                         inputs: {
                             index: ":__mapIndex",
-                            rows: ":context.studio.multiLingual",
+                            rows: ":context.multiLingual",
                         },
                     },
                     preprocessMultiLingual: {
@@ -163,12 +163,12 @@ const translateGraph = {
                 },
             },
         },
-        writeOutout: {
+        writeOutput: {
             // console: { before: true },
             agent: "fileWriteAgent",
             inputs: {
-                file: ":outputStudioFilePath",
-                text: ":mergeStudioResult.toJSON()",
+                file: ":outputMultilingualFilePath",
+                text: ":mergeStudioResult.multiLingual.toJSON()",
             },
         },
     },
@@ -213,7 +213,7 @@ export const translate = async (context, callbacks) => {
         MulmoStudioContextMethods.setSessionState(context, "multiLingual", true);
         const { studio, fileDirs } = context;
         const { outDirPath } = fileDirs;
-        const outputStudioFilePath = getOutputStudioFilePath(outDirPath, studio.filename);
+        const outputMultilingualFilePath = getOutputMultilingualFilePath(outDirPath, studio.filename);
         mkdir(outDirPath);
         assert(!!process.env.OPENAI_API_KEY, "The OPENAI_API_KEY environment variable is missing or empty");
         const graph = new GraphAI(translateGraph, { ...vanillaAgents, fileWriteAgent, openAIAgent }, { agentFilters });
@@ -221,16 +221,16 @@ export const translate = async (context, callbacks) => {
         graph.injectValue("defaultLang", defaultLang);
         graph.injectValue("targetLangs", targetLangs);
         graph.injectValue("outDirPath", outDirPath);
-        graph.injectValue("outputStudioFilePath", outputStudioFilePath);
+        graph.injectValue("outputMultilingualFilePath", outputMultilingualFilePath);
         if (callbacks) {
             callbacks.forEach((callback) => {
                 graph.registerCallback(callback);
             });
         }
         const results = await graph.run();
-        writingMessage(outputStudioFilePath);
+        writingMessage(outputMultilingualFilePath);
         if (results.mergeStudioResult) {
-            context.studio = results.mergeStudioResult;
+            context.multiLingual = results.mergeStudioResult.multiLingual;
         }
     }
     finally {

package/lib/agents/add_bgm_agent.js

@@ -1,11 +1,11 @@
 import { GraphAILogger } from "graphai";
 import { FfmpegContextAddInput, FfmpegContextInit, FfmpegContextGenerateOutput, ffmpegGetMediaDuration } from "../utils/ffmpeg_utils.js";
 const addBGMAgent = async ({ namedInputs, params, }) => {
-    const { voiceFile, outputFile, script } = namedInputs;
+    const { voiceFile, outputFile, context } = namedInputs;
     const { musicFile } = params;
     const speechDuration = await ffmpegGetMediaDuration(voiceFile);
-    const introPadding = script.audioParams.introPadding;
-    const outroPadding = script.audioParams.outroPadding;
+    const introPadding = context.presentationStyle.audioParams.introPadding;
+    const outroPadding = context.presentationStyle.audioParams.outroPadding;
     const totalDuration = speechDuration + introPadding + outroPadding;
     GraphAILogger.log("totalDucation:", speechDuration, totalDuration);
     const ffmpegContext = FfmpegContextInit();

package/lib/agents/combine_audio_files_agent.js

@@ -1,6 +1,35 @@
-import { GraphAILogger } from "graphai";
+import { assert } from "graphai";
 import { silent60secPath } from "../utils/file.js";
 import { FfmpegContextInit, FfmpegContextGenerateOutput, FfmpegContextInputFormattedAudio, ffmpegGetMediaDuration } from "../utils/ffmpeg_utils.js";
+const getMovieDulation = async (beat) => {
+    if (beat.image?.type === "movie" && (beat.image.source.kind === "url" || beat.image.source.kind === "path")) {
+        const pathOrUrl = beat.image.source.kind === "url" ? beat.image.source.url : beat.image.source.path;
+        return await ffmpegGetMediaDuration(pathOrUrl);
+    }
+    return 0;
+};
+const getPadding = (context, beat, index) => {
+    if (beat.audioParams?.padding !== undefined) {
+        return beat.audioParams.padding;
+    }
+    if (index === context.studio.beats.length - 1) {
+        return 0;
+    }
+    const isClosingGap = index === context.studio.beats.length - 2;
+    return isClosingGap ? context.presentationStyle.audioParams.closingPadding : context.presentationStyle.audioParams.padding;
+};
+const getTotalPadding = (padding, movieDuration, audioDuration, duration, canSpillover = false) => {
+    if (movieDuration > 0) {
+        return padding + (movieDuration - audioDuration);
+    }
+    else if (duration && duration > audioDuration) {
+        return padding + (duration - audioDuration);
+    }
+    else if (canSpillover && duration && audioDuration > duration) {
+        return duration - audioDuration; // negative value to indicate that there is a spill over.
+    }
+    return padding;
+};
 const combineAudioFilesAgent = async ({ namedInputs, }) => {
     const { context, combinedFileName } = namedInputs;
     const ffmpegContext = FfmpegContextInit();
@@ -8,64 +37,81 @@ const combineAudioFilesAgent = async ({ namedInputs, }) => {
     // We cannot reuse longSilentId. We need to explicitly split it for each beat.
     const silentIds = context.studio.beats.map((_, index) => `[ls_${index}]`);
     ffmpegContext.filterComplex.push(`${longSilentId}asplit=${silentIds.length}${silentIds.join("")}`);
-    const inputIds = (await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
+    // First, get the audio durations of all beats, taking advantage of multi-threading capability of ffmpeg.
+    const mediaDurations = await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
         const beat = context.studio.script.beats[index];
-        const isClosingGap = index === context.studio.beats.length - 2;
-        const movieDuration = await (() => {
-            if (beat.image?.type === "movie" && (beat.image.source.kind === "url" || beat.image.source.kind === "path")) {
-                const pathOrUrl = beat.image.source.kind === "url" ? beat.image.source.url : beat.image.source.path;
-                return ffmpegGetMediaDuration(pathOrUrl);
-            }
-            return 0;
-        })();
+        const movieDuration = await getMovieDulation(beat);
+        const audioDuration = studioBeat.audioFile ? await ffmpegGetMediaDuration(studioBeat.audioFile) : 0;
+        return {
+            movieDuration,
+            audioDuration,
+        };
+    }));
+    const inputIds = [];
+    const beatDurations = [];
+    context.studio.beats.reduce((spillover, studioBeat, index) => {
+        const beat = context.studio.script.beats[index];
+        const { audioDuration, movieDuration } = mediaDurations[index];
+        const paddingId = `[padding_${index}]`;
+        const canSpillover = index < context.studio.beats.length - 1 && mediaDurations[index + 1].movieDuration + mediaDurations[index + 1].audioDuration === 0;
         if (studioBeat.audioFile) {
             const audioId = FfmpegContextInputFormattedAudio(ffmpegContext, studioBeat.audioFile);
-            const padding = (() => {
-                if (beat.audioParams?.padding !== undefined) {
-                    return beat.audioParams.padding;
-                }
-                if (index === context.studio.beats.length - 1) {
-                    return 0;
-                }
-                return isClosingGap ? context.studio.script.audioParams.closingPadding : context.studio.script.audioParams.padding;
-            })();
-            const audioDuration = await ffmpegGetMediaDuration(studioBeat.audioFile);
-            const totalPadding = await (async () => {
-                if (movieDuration > 0) {
-                    return padding + (movieDuration - audioDuration);
-                }
-                else if (beat.duration && beat.duration > audioDuration) {
-                    return padding + (beat.duration - audioDuration);
-                }
-                return padding;
-            })();
-            studioBeat.duration = audioDuration + totalPadding;
+            // padding is the amount of audio padding specified in the script.
+            const padding = getPadding(context, beat, index);
+            // totalPadding is the amount of audio padding to be added to the audio file.
+            const totalPadding = getTotalPadding(padding, movieDuration, audioDuration, beat.duration, canSpillover);
+            beatDurations.push(audioDuration + totalPadding);
             if (totalPadding > 0) {
                 const silentId = silentIds.pop();
-                ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${totalPadding}[padding_${index}]`);
-                return [audioId, `[padding_${index}]`];
+                ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${totalPadding}${paddingId}`);
+                inputIds.push(audioId, paddingId);
             }
             else {
-                return [audioId];
+                inputIds.push(audioId);
+                if (totalPadding < 0) {
+                    return -totalPadding;
+                }
             }
         }
         else {
             // NOTE: We come here when the text is empty and no audio property is specified.
-            studioBeat.duration = beat.duration ?? (movieDuration > 0 ? movieDuration : 1.0);
+            const beatDuration = (() => {
+                const duration = beat.duration ?? (movieDuration > 0 ? movieDuration : 1.0);
+                if (!canSpillover && duration < spillover) {
+                    return spillover; // We need to consume the spillover here.
+                }
+                return duration;
+            })();
+            beatDurations.push(beatDuration);
+            if (beatDuration <= spillover) {
+                return spillover - beatDuration;
+            }
             const silentId = silentIds.pop();
-            ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${studioBeat.duration}[silent_${index}]`);
-            return [`[silent_${index}]`];
+            ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${beatDuration - spillover}${paddingId}`);
+            inputIds.push(paddingId);
         }
-    }))).flat();
-    silentIds.forEach((silentId) => {
-        GraphAILogger.log(`Using extra silentId: ${silentId}`);
-        ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${0.01}[silent_extra]`);
-        inputIds.push("[silent_extra]");
+        return 0;
+    }, 0);
+    assert(beatDurations.length === context.studio.beats.length, "beatDurations.length !== studio.beats.length");
+    // We need to "consume" extra silentIds.
+    silentIds.forEach((silentId, index) => {
+        const extraId = `[silent_extra_${index}]`;
+        ffmpegContext.filterComplex.push(`${silentId}atrim=start=0:end=${0.01}${extraId}`);
+        inputIds.push(extraId);
     });
+    // Finally, combine all audio files.
     ffmpegContext.filterComplex.push(`${inputIds.join("")}concat=n=${inputIds.length}:v=0:a=1[aout]`);
     await FfmpegContextGenerateOutput(ffmpegContext, combinedFileName, ["-map", "[aout]"]);
+    const result = {
+        studio: {
+            ...context.studio,
+            beats: context.studio.beats.map((studioBeat, index) => ({ ...studioBeat, duration: beatDurations[index] })),
+        },
+    };
+    // context.studio = result.studio; // TODO: removing this breaks test/test_movie.ts
     return {
-        studio: context.studio,
+        ...context,
+        ...result,
     };
 };
 const combineAudioFilesAgentInfo = {

package/lib/agents/index.d.ts

@@ -2,6 +2,7 @@ import addBGMAgent from "./add_bgm_agent.js";
 import combineAudioFilesAgent from "./combine_audio_files_agent.js";
 import imageGoogleAgent from "./image_google_agent.js";
 import imageOpenaiAgent from "./image_openai_agent.js";
+import tavilySearchAgent from "./tavily_agent.js";
 import movieGoogleAgent from "./movie_google_agent.js";
 import mediaMockAgent from "./media_mock_agent.js";
 import ttsElevenlabsAgent from "./tts_elevenlabs_agent.js";
@@ -12,4 +13,4 @@ import { browserlessAgent } from "@graphai/browserless_agent";
 import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, movieGoogleAgent, mediaMockAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };
+export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, tavilySearchAgent, movieGoogleAgent, mediaMockAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };

package/lib/agents/index.js

@@ -2,6 +2,7 @@ import addBGMAgent from "./add_bgm_agent.js";
 import combineAudioFilesAgent from "./combine_audio_files_agent.js";
 import imageGoogleAgent from "./image_google_agent.js";
 import imageOpenaiAgent from "./image_openai_agent.js";
+import tavilySearchAgent from "./tavily_agent.js";
 import movieGoogleAgent from "./movie_google_agent.js";
 import mediaMockAgent from "./media_mock_agent.js";
 import ttsElevenlabsAgent from "./tts_elevenlabs_agent.js";
@@ -13,4 +14,4 @@ import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";
 // import * as vanilla from "@graphai/vanilla";
 import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, movieGoogleAgent, mediaMockAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };
+export { openAIAgent, fileWriteAgent, browserlessAgent, textInputAgent, addBGMAgent, combineAudioFilesAgent, imageGoogleAgent, imageOpenaiAgent, tavilySearchAgent, movieGoogleAgent, mediaMockAgent, ttsElevenlabsAgent, ttsNijivoiceAgent, ttsOpenaiAgent, validateSchemaAgent, };

package/lib/agents/tavily_agent.d.ts

@@ -0,0 +1,15 @@
+import { AgentFunction, AgentFunctionInfo, DefaultConfigData } from "graphai";
+import { type TavilySearchResponse } from "@tavily/core";
+type TavilySearchInputs = {
+    query: string;
+};
+type TavilySearchParams = {
+    apiKey?: string;
+    max_results?: number;
+    search_depth?: "basic" | "advanced";
+    include_answer?: boolean;
+    include_raw_content?: boolean | "markdown" | "text";
+};
+export declare const tavilySearchAgent: AgentFunction<TavilySearchParams, TavilySearchResponse, TavilySearchInputs, DefaultConfigData>;
+declare const tavilySearchAgentInfo: AgentFunctionInfo;
+export default tavilySearchAgentInfo;

package/lib/agents/tavily_agent.js

@@ -0,0 +1,130 @@
+import { assert } from "graphai";
+import { tavily } from "@tavily/core";
+const getTavilyApiKey = (params, config) => {
+    if (params?.apiKey) {
+        return params.apiKey;
+    }
+    if (config?.apiKey) {
+        return config.apiKey;
+    }
+    return typeof process !== "undefined" ? process?.env?.TAVILY_API_KEY : null;
+};
+export const tavilySearchAgent = async ({ namedInputs, params, config, }) => {
+    const { query } = namedInputs;
+    assert(!!query, "tavilySearchAgent: query is required! set inputs: { query: 'search terms' }");
+    try {
+        const apiKey = getTavilyApiKey(params, config);
+        assert(apiKey, "Tavily API key is required. Please set the TAVILY_API_KEY environment variable or provide it in params/config.");
+        const tvly = tavily({ apiKey });
+        // Convert params to SDK options format
+        const sdkOptions = {};
+        if (params?.max_results !== undefined)
+            sdkOptions.maxResults = params.max_results;
+        if (params?.search_depth !== undefined)
+            sdkOptions.searchDepth = params.search_depth;
+        if (params?.include_answer !== undefined)
+            sdkOptions.includeAnswer = params.include_answer;
+        if (params?.include_raw_content !== undefined)
+            sdkOptions.includeRawContent = params.include_raw_content;
+        const response = await tvly.search(query, sdkOptions);
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Tavily search failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const tavilySearchAgentInfo = {
+    name: "tavilySearchAgent",
+    agent: tavilySearchAgent,
+    mock: tavilySearchAgent,
+    params: {
+        type: "object",
+        properties: {
+            apiKey: {
+                type: "string",
+                description: "Tavily API key",
+            },
+            max_results: {
+                type: "number",
+                description: "Maximum number of search results to return (default: 5)",
+            },
+            search_depth: {
+                type: "string",
+                enum: ["basic", "advanced"],
+                description: "Search depth - basic for faster results, advanced for more comprehensive results",
+            },
+            include_answer: {
+                type: "boolean",
+                description: "Include a direct answer to the query when available",
+            },
+            include_raw_content: {
+                type: "string",
+                enum: ["boolean", "markdown", "text"],
+                description: "Include raw content from search results (boolean, markdown, text)",
+            },
+        },
+    },
+    inputs: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query string",
+            },
+        },
+        required: ["query"],
+    },
+    output: {
+        type: "object",
+        properties: {
+            query: { type: "string" },
+            answer: { type: ["string", "null"] },
+            results: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string" },
+                        url: { type: "string" },
+                        content: { type: "string" },
+                        rawContent: { type: ["string", "null"] },
+                        score: { type: "number" },
+                    },
+                },
+            },
+        },
+    },
+    samples: [
+        {
+            inputs: {
+                query: "latest AI developments 2024",
+            },
+            params: {
+                max_results: 3,
+                include_answer: true,
+            },
+            result: {
+                query: "latest AI developments 2024",
+                answer: "Recent AI developments in 2024 include...",
+                results: [
+                    {
+                        title: "Major AI Breakthroughs in 2024",
+                        url: "https://example.com/ai-2024",
+                        content: "The year 2024 has seen significant advances in artificial intelligence...",
+                        rawContent: null,
+                        score: 0.95,
+                    },
+                ],
+            },
+        },
+    ],
+    description: "Performs web search using Tavily API and returns relevant search results with optional AI-generated answers",
+    category: ["search", "web"],
+    author: "Receptron Team",
+    repository: "https://github.com/receptron/mulmocast-cli/tree/main/src/agents/tavily_agent.ts",
+    source: "https://github.com/receptron/mulmocast-cli/tree/main/src/agents/tavily_agent.ts",
+    package: "@receptron/mulmocast-cli",
+    license: "MIT",
+    environmentVariables: ["TAVILY_API_KEY"],
+};
+export default tavilySearchAgentInfo;

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

@@ -9,6 +9,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     f: boolean;
 } & {
     dryRun: boolean;
+} & {
+    p: string | undefined;
 } & {
     file: string | undefined;
 } & {

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

@@ -9,6 +9,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     f: boolean;
 } & {
     dryRun: boolean;
+} & {
+    p: string | undefined;
 } & {
     file: string | undefined;
 } & {

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

@@ -9,6 +9,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     f: boolean;
 } & {
     dryRun: boolean;
+} & {
+    p: string | undefined;
 } & {
     file: string | undefined;
 } & {

package/lib/cli/commands/movie/handler.js

@@ -6,10 +6,5 @@ export const handler = async (argv) => {
         process.exit(1);
     }
     await runTranslateIfNeeded(context, argv);
-    await audio(context);
-    await images(context);
-    if (context.caption) {
-        await captions(context);
-    }
-    await movie(context);
+    await audio(context).then(images).then(captions).then(movie);
 };

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

@@ -9,6 +9,8 @@ export declare const builder: (yargs: Argv) => Argv<{
     f: boolean;
 } & {
     dryRun: boolean;
+} & {
+    p: string | undefined;
 } & {
     file: string | undefined;
 } & {

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

@@ -9,6 +9,8 @@ export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{
     f: boolean;
 } & {
     dryRun: boolean;
+} & {
+    p: string | undefined;
 } & {
     file: string | undefined;
 }, "file"> & {

package/lib/cli/common.d.ts

@@ -9,6 +9,8 @@ export declare const commonOptions: (yargs: Argv) => Argv<{
     f: boolean;
 } & {
     dryRun: boolean;
+} & {
+    p: string | undefined;
 } & {
     file: string | undefined;
 }>;

package/lib/cli/common.js

@@ -30,6 +30,12 @@ export const commonOptions = (yargs) => {
         describe: "Dry run",
         type: "boolean",
         default: false,
+    })
+        .option("p", {
+        alias: "presentationStyle",
+        describe: "Presentation Style",
+        demandOption: false,
+        type: "string",
     })
         .positional("file", {
         describe: "Mulmo Script File",