mulmocast 0.0.15 → 0.0.17

package/lib/cli/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { MulmoScript, MulmoStudioContext } from "../types/type.js";
+import type { MulmoScript, MulmoStudioContext, MulmoPresentationStyle, MulmoStudioMultiLingual } from "../types/type.js";
 import type { CliArgs } from "../types/cli_types.js";
 export declare const setGraphAILogger: (verbose: boolean | undefined, logValues?: Record<string, unknown>) => void;
 export interface FileObject {
@@ -11,6 +11,8 @@ export interface FileObject {
     isHttpPath: boolean;
     fileOrUrl: string;
     outputStudioFilePath: string;
+    outputMultilingualFilePath: string;
+    presentationStylePath: string | undefined;
     fileName: string;
 }
 export declare const getFileObject: (args: {
@@ -18,9 +20,12 @@ export declare const getFileObject: (args: {
     outdir?: string;
     imagedir?: string;
     audiodir?: string;
+    presentationStyle?: string;
     file: string;
 }) => FileObject;
 export declare const fetchScript: (isHttpPath: boolean, mulmoFilePath: string, fileOrUrl: string) => Promise<MulmoScript | null>;
+export declare const getMultiLingual: (multilingualFilePath: string, beatsLength: number) => MulmoStudioMultiLingual;
+export declare const getPresentationStyle: (presentationStylePath: string | undefined) => MulmoPresentationStyle | null;
 type InitOptions = {
     b?: string;
     o?: string;
@@ -29,6 +34,7 @@ type InitOptions = {
     file?: string;
     l?: string;
     c?: string;
+    p?: string;
 };
 export declare const initializeContext: (argv: CliArgs<InitOptions>) => Promise<MulmoStudioContext | null>;
 export declare const runTranslateIfNeeded: (context: MulmoStudioContext, argv: {

package/lib/cli/helpers.js

@@ -2,11 +2,12 @@ import { GraphAILogger } from "graphai";
 import fs from "fs";
 import path from "path";
 import clipboardy from "clipboardy";
-import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath, resolveDirPath, mkdir } from "../utils/file.js";
+import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath, resolveDirPath, mkdir, getOutputMultilingualFilePath, } from "../utils/file.js";
 import { isHttp } from "../utils/utils.js";
 import { createOrUpdateStudioData } from "../utils/preprocess.js";
 import { outDirName, imageDirName, audioDirName } from "../utils/const.js";
 import { translate } from "../actions/translate.js";
+import { mulmoPresentationStyleSchema, mulmoStudioMultiLingualSchema } from "../types/schema.js";
 export const setGraphAILogger = (verbose, logValues) => {
     if (verbose) {
         if (logValues) {
@@ -22,7 +23,7 @@ export const setGraphAILogger = (verbose, logValues) => {
     }
 };
 export const getFileObject = (args) => {
-    const { basedir, outdir, imagedir, audiodir, file } = args;
+    const { basedir, outdir, imagedir, audiodir, file, presentationStyle } = args;
     const baseDirPath = getBaseDirPath(basedir);
     const outDirPath = getFullPath(baseDirPath, outdir ?? outDirName);
     const { fileOrUrl, fileName } = (() => {
@@ -47,6 +48,8 @@ export const getFileObject = (args) => {
     const imageDirPath = getFullPath(outDirPath, imagedir ?? imageDirName);
     const audioDirPath = getFullPath(outDirPath, audiodir ?? audioDirName);
     const outputStudioFilePath = getOutputStudioFilePath(outDirPath, fileName);
+    const outputMultilingualFilePath = getOutputMultilingualFilePath(outDirPath, fileName);
+    const presentationStylePath = presentationStyle ? getFullPath(baseDirPath, presentationStyle) : undefined;
     return {
         baseDirPath,
         mulmoFilePath,
@@ -57,6 +60,8 @@ export const getFileObject = (args) => {
         isHttpPath,
         fileOrUrl,
         outputStudioFilePath,
+        outputMultilingualFilePath,
+        presentationStylePath,
         fileName,
     };
 };
@@ -75,15 +80,33 @@ export const fetchScript = async (isHttpPath, mulmoFilePath, fileOrUrl) => {
     }
     return readMulmoScriptFile(mulmoFilePath, "ERROR: File does not exist " + mulmoFilePath)?.mulmoData ?? null;
 };
+export const getMultiLingual = (multilingualFilePath, beatsLength) => {
+    if (fs.existsSync(multilingualFilePath)) {
+        const jsonData = readMulmoScriptFile(multilingualFilePath, "ERROR: File does not exist " + multilingualFilePath)?.mulmoData ?? null;
+        return mulmoStudioMultiLingualSchema.parse(jsonData);
+    }
+    return [...Array(beatsLength)].map(() => ({ multiLingualTexts: {} }));
+};
+export const getPresentationStyle = (presentationStylePath) => {
+    if (presentationStylePath) {
+        if (!fs.existsSync(presentationStylePath)) {
+            throw new Error(`ERROR: File not exists ${presentationStylePath}`);
+        }
+        const jsonData = readMulmoScriptFile(presentationStylePath, "ERROR: File does not exist " + presentationStylePath)?.mulmoData ?? null;
+        return mulmoPresentationStyleSchema.parse(jsonData);
+    }
+    return null;
+};
 export const initializeContext = async (argv) => {
     const files = getFileObject({
         basedir: argv.b,
         outdir: argv.o,
         imagedir: argv.i,
         audiodir: argv.a,
+        presentationStyle: argv.p,
         file: argv.file ?? "",
     });
-    const { fileName, isHttpPath, fileOrUrl, mulmoFilePath, outputStudioFilePath } = files;
+    const { fileName, isHttpPath, fileOrUrl, mulmoFilePath, outputStudioFilePath, presentationStylePath, outputMultilingualFilePath } = files;
     setGraphAILogger(argv.v, {
         files,
     });
@@ -91,6 +114,8 @@ export const initializeContext = async (argv) => {
     if (!mulmoScript) {
         return null;
     }
+    const presentationStyle = getPresentationStyle(presentationStylePath);
+    const multiLingual = getMultiLingual(outputMultilingualFilePath, mulmoScript.beats.length);
     // Create or update MulmoStudio file with MulmoScript
     const currentStudio = readMulmoScriptFile(outputStudioFilePath);
     try {
@@ -120,6 +145,8 @@ export const initializeContext = async (argv) => {
                     caption: {},
                 },
             },
+            presentationStyle: presentationStyle ?? studio.script,
+            multiLingual,
         };
     }
     catch (error) {

package/lib/methods/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./mulmo_script.js";
+export * from "./mulmo_presentation_style.js";
 export * from "./mulmo_script_template.js";
 export * from "./mulmo_studio_context.js";
 export * from "./mulmo_media_source.js";

package/lib/methods/index.js

@@ -1,4 +1,4 @@
-export * from "./mulmo_script.js";
+export * from "./mulmo_presentation_style.js";
 export * from "./mulmo_script_template.js";
 export * from "./mulmo_studio_context.js";
 export * from "./mulmo_media_source.js";

package/lib/methods/mulmo_presentation_style.d.ts

@@ -0,0 +1,14 @@
+import "dotenv/config";
+import { MulmoCanvasDimension, MulmoBeat, SpeechOptions, Text2SpeechProvider, Text2ImageAgentInfo, BeatMediaType, MulmoPresentationStyle, SpeakerData } from "../types/index.js";
+export declare const MulmoPresentationStyleMethods: {
+    getCanvasSize(presentationStyle: MulmoPresentationStyle): MulmoCanvasDimension;
+    getSpeechProvider(presentationStyle: MulmoPresentationStyle): Text2SpeechProvider;
+    getAllSpeechProviders(presentationStyle: MulmoPresentationStyle): Set<Text2SpeechProvider>;
+    getTextSlideStyle(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): string;
+    getSpeechOptions(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): SpeechOptions | undefined;
+    getSpeaker(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): SpeakerData;
+    getProvider(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): Text2SpeechProvider;
+    getVoiceId(presentationStyle: MulmoPresentationStyle, beat: MulmoBeat): string;
+    getImageAgentInfo(presentationStyle: MulmoPresentationStyle, dryRun?: boolean): Text2ImageAgentInfo;
+    getImageType(_: MulmoPresentationStyle, beat: MulmoBeat): BeatMediaType;
+};

package/lib/methods/mulmo_presentation_style.js

@@ -0,0 +1,70 @@
+import "dotenv/config";
+import { text2ImageProviderSchema, text2SpeechProviderSchema, mulmoCanvasDimensionSchema } from "../types/schema.js";
+const defaultTextSlideStyles = [
+    '*,*::before,*::after{box-sizing:border-box}body,h1,h2,h3,h4,p,figure,blockquote,dl,dd{margin:0}ul[role="list"],ol[role="list"]{list-style:none}html:focus-within{scroll-behavior:smooth}body{min-height:100vh;text-rendering:optimizeSpeed;line-height:1.5}a:not([class]){text-decoration-skip-ink:auto}img,picture{max-width:100%;display:block}input,button,textarea,select{font:inherit}@media(prefers-reduced-motion:reduce){html:focus-within{scroll-behavior:auto}*,*::before,*::after{animation-duration:.01ms !important;animation-iteration-count:1 !important;transition-duration:.01ms !important;scroll-behavior:auto !important}}',
+    "body { margin: 60px; margin-top: 40px; color:#333; font-size: 30px; font-family: Arial, sans-serif; box-sizing: border-box; height: 100vh }",
+    "h1 { font-size: 56px; margin-bottom: 20px; text-align: center }",
+    "h2 { font-size: 48px; text-align: center }",
+    "h3 { font-size: 36px }",
+    "ul { margin-left: 40px } ",
+    "pre { background: #eeeecc; font-size: 16px; padding:4px }",
+    "p { margin-left: 40px }",
+    "table { font-size: 36px; margin: auto; border: 1px solid gray; border-collapse: collapse }",
+    "th { border-bottom: 1px solid gray }",
+    "td, th { padding: 8px }",
+    "tr:nth-child(even) { background-color: #eee }",
+];
+export const MulmoPresentationStyleMethods = {
+    getCanvasSize(presentationStyle) {
+        return mulmoCanvasDimensionSchema.parse(presentationStyle.canvasSize);
+    },
+    getSpeechProvider(presentationStyle) {
+        return text2SpeechProviderSchema.parse(presentationStyle.speechParams?.provider);
+    },
+    getAllSpeechProviders(presentationStyle) {
+        const providers = new Set();
+        const defaultProvider = this.getSpeechProvider(presentationStyle);
+        Object.values(presentationStyle.speechParams.speakers).forEach((speaker) => {
+            const provider = speaker.provider ?? defaultProvider;
+            providers.add(provider);
+        });
+        return providers;
+    },
+    getTextSlideStyle(presentationStyle, beat) {
+        const styles = presentationStyle.textSlideParams?.cssStyles ?? [];
+        // NOTES: Taking advantage of CSS override rule (you can redefine it to override)
+        const extraStyles = beat.textSlideParams?.cssStyles ?? [];
+        // This code allows us to support both string and array of strings for cssStyles
+        return [...defaultTextSlideStyles, ...[styles], ...[extraStyles]].flat().join("\n");
+    },
+    getSpeechOptions(presentationStyle, beat) {
+        return { ...presentationStyle.speechParams.speakers[beat.speaker].speechOptions, ...beat.speechOptions };
+    },
+    getSpeaker(presentationStyle, beat) {
+        return presentationStyle.speechParams.speakers[beat.speaker];
+    },
+    getProvider(presentationStyle, beat) {
+        const speaker = MulmoPresentationStyleMethods.getSpeaker(presentationStyle, beat);
+        return speaker.provider ?? presentationStyle.speechParams.provider;
+    },
+    getVoiceId(presentationStyle, beat) {
+        const speaker = MulmoPresentationStyleMethods.getSpeaker(presentationStyle, beat);
+        return speaker.voiceId;
+    },
+    getImageAgentInfo(presentationStyle, dryRun = false) {
+        // Notice that we copy imageParams from presentationStyle and update
+        // provider and model appropriately.
+        const provider = text2ImageProviderSchema.parse(presentationStyle.imageParams?.provider);
+        const defaultImageParams = {
+            model: provider === "openai" ? process.env.DEFAULT_OPENAI_IMAGE_MODEL : undefined,
+        };
+        return {
+            provider,
+            agent: dryRun ? "mediaMockAgent" : provider === "google" ? "imageGoogleAgent" : "imageOpenaiAgent",
+            imageParams: { ...defaultImageParams, ...presentationStyle.imageParams },
+        };
+    },
+    getImageType(_, beat) {
+        return beat.image?.type == "movie" ? "movie" : "image";
+    },
+};

package/lib/methods/mulmo_studio_context.d.ts

@@ -1,8 +1,25 @@
 import { MulmoStudioContext } from "../types/index.js";
 type SessionType = "audio" | "image" | "video" | "multiLingual" | "caption" | "pdf";
 type BeatSessionType = "audio" | "image" | "multiLingual" | "caption" | "movie";
+type SessionProgressEvent = {
+    kind: "session";
+    sessionType: SessionType;
+    inSession: boolean;
+} | {
+    kind: "beat";
+    sessionType: BeatSessionType;
+    index: number;
+    inSession: boolean;
+};
+type SessionProgressCallback = (change: SessionProgressEvent) => void;
+export declare const addSessionProgressCallback: (cb: SessionProgressCallback) => void;
+export declare const removeSessionProgressCallback: (cb: SessionProgressCallback) => void;
 export declare const MulmoStudioContextMethods: {
     resolveAssetPath(context: MulmoStudioContext, relativePath: string): string;
+    getAudioDirPath(context: MulmoStudioContext): string;
+    getImageDirPath(context: MulmoStudioContext): string;
+    getImageProjectDirPath(context: MulmoStudioContext): string;
+    getOutDirPath(context: MulmoStudioContext): string;
     setSessionState(context: MulmoStudioContext, sessionType: SessionType, value: boolean): void;
     setBeatSessionState(context: MulmoStudioContext, sessionType: BeatSessionType, index: number, value: boolean): void;
 };

package/lib/methods/mulmo_studio_context.js

@@ -1,17 +1,45 @@
 import path from "path";
 import { GraphAILogger } from "graphai";
+const sessionProgressCallbacks = new Set();
+export const addSessionProgressCallback = (cb) => {
+    sessionProgressCallbacks.add(cb);
+};
+export const removeSessionProgressCallback = (cb) => {
+    sessionProgressCallbacks.delete(cb);
+};
 const notifyStateChange = (context, sessionType) => {
-    const prefix = context.sessionState.inSession[sessionType] ? "<" : " >";
+    const inSession = context.sessionState.inSession[sessionType] ?? false;
+    const prefix = inSession ? "<" : " >";
     GraphAILogger.info(`${prefix} ${sessionType}`);
+    for (const callback of sessionProgressCallbacks) {
+        callback({ kind: "session", sessionType, inSession });
+    }
 };
 const notifyBeatStateChange = (context, sessionType, index) => {
-    const prefix = context.sessionState.inBeatSession[sessionType][index] ? "{" : " }";
+    const inSession = context.sessionState.inBeatSession[sessionType][index] ?? false;
+    const prefix = inSession ? "{" : " }";
     GraphAILogger.info(`${prefix} ${sessionType} ${index}`);
+    for (const callback of sessionProgressCallbacks) {
+        callback({ kind: "beat", sessionType, index, inSession });
+    }
 };
 export const MulmoStudioContextMethods = {
     resolveAssetPath(context, relativePath) {
         return path.resolve(context.fileDirs.mulmoFileDirPath, relativePath);
     },
+    getAudioDirPath(context) {
+        return context.fileDirs.audioDirPath;
+    },
+    getImageDirPath(context) {
+        return context.fileDirs.imageDirPath;
+    },
+    getImageProjectDirPath(context) {
+        const imageDirPath = MulmoStudioContextMethods.getImageDirPath(context);
+        return `${imageDirPath}/${context.studio.filename}`;
+    },
+    getOutDirPath(context) {
+        return context.fileDirs.outDirPath;
+    },
     setSessionState(context, sessionType, value) {
         context.sessionState.inSession[sessionType] = value;
         notifyStateChange(context, sessionType);

package/lib/tools/deep_research.d.ts

@@ -0,0 +1,2 @@
+import "dotenv/config";
+export declare const deepResearch: () => Promise<void>;

package/lib/tools/deep_research.js

@@ -0,0 +1,265 @@
+import "dotenv/config";
+import { GraphAILogger, GraphAI } from "graphai";
+import { textInputAgent } from "@graphai/input_agents";
+import { consoleStreamDataAgentFilter } from "@graphai/stream_agent_filter/node";
+import { openAIAgent } from "@graphai/openai_agent";
+import * as agents from "@graphai/vanilla";
+import tavilySearchAgent from "../agents/tavily_agent.js";
+import { cliLoadingPlugin } from "../utils/plugins.js";
+import { searchQueryPrompt, reflectionPrompt, finalAnswerPrompt } from "../utils/prompt.js";
+const vanillaAgents = agents.default ?? agents;
+const agentHeader = "\x1b[34m● \x1b[0m\x1b[1mAgent\x1b[0m:\x1b[0m";
+const graphData = {
+    version: 0.5,
+    nodes: {
+        maxRetries: {
+            value: 0,
+        },
+        userInput: {
+            agent: "textInputAgent",
+            params: {
+                message: "You:",
+                required: true,
+            },
+        },
+        startMessage: {
+            agent: "consoleAgent",
+            inputs: {
+                text: `\n${agentHeader} It takes a few minutes to gather resources, analyze data, and create a report.`,
+                userInput: ":userInput.text",
+            },
+        },
+        deepResearch: {
+            agent: "nestedAgent",
+            inputs: {
+                userInput: ":userInput.text",
+                maxRetries: ":maxRetries",
+                startMessage: ":startMessage",
+            },
+            graph: {
+                loop: {
+                    while: ":continue",
+                },
+                nodes: {
+                    searchResults: {
+                        value: [],
+                        update: ":reducer.array",
+                    },
+                    followUpQueries: {
+                        value: [],
+                        update: ":reflectionAgent.follow_up_queries",
+                    },
+                    counter: {
+                        value: 0,
+                        update: ":counter.add(1)",
+                    },
+                    searchQueryAgent: {
+                        agent: "openAIAgent",
+                        inputs: {
+                            model: "gpt-4o-mini",
+                            system: "You are a professional research assistant. Based on the user's inquiry, return the search query to be used for the search engine.",
+                            prompt: searchQueryPrompt("${:userInput}", "${:followUpQueries.join(,)}"),
+                        },
+                        params: {
+                            tool_choice: "auto",
+                            tools: [
+                                {
+                                    type: "function",
+                                    function: {
+                                        name: "search_query",
+                                        description: "Return the search queries to be used for the search engine.",
+                                        parameters: {
+                                            type: "object",
+                                            properties: {
+                                                queries: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "string",
+                                                        description: "A search query to be used for the search engine.",
+                                                    },
+                                                    description: "An array of search queries to be used for the search engine.",
+                                                },
+                                                research_topic: {
+                                                    type: "string",
+                                                    description: "The topic of the research. This is used to filter the search results.",
+                                                },
+                                                analysis_plan: {
+                                                    type: "string",
+                                                    description: "A detailed plan for analyzing the research topic, including main areas to investigate, key factors, and specific aspects that need deeper investigation",
+                                                },
+                                            },
+                                            required: ["queries", "research_topic", "analysis_plan"],
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                        output: {
+                            queries: ".tool.arguments.queries",
+                            research_topic: ".tool.arguments.research_topic",
+                            analysis_plan: ".tool.arguments.analysis_plan",
+                        },
+                    },
+                    logSearchQuery: {
+                        agent: "consoleAgent",
+                        inputs: {
+                            text: "\n" + agentHeader + " ${:searchQueryAgent.analysis_plan}",
+                        },
+                    },
+                    mapSearchAgent: {
+                        agent: "mapAgent",
+                        inputs: {
+                            rows: ":searchQueryAgent.queries",
+                        },
+                        params: {
+                            compositeResult: true,
+                        },
+                        graph: {
+                            nodes: {
+                                tavilySearchAgent: {
+                                    agent: "tavilySearchAgent",
+                                    inputs: {
+                                        query: ":row",
+                                    },
+                                    params: {
+                                        max_results: 3,
+                                    },
+                                },
+                                result: {
+                                    agent: "copyAgent",
+                                    inputs: {
+                                        results: ":tavilySearchAgent.results",
+                                    },
+                                    params: {
+                                        namedKey: "results",
+                                    },
+                                    isResult: true,
+                                },
+                                logSearchStatus: {
+                                    agent: ({ result }) => {
+                                        GraphAILogger.info(result.map((r) => `- [${r.title}](${r.url})`).join("\n"));
+                                    },
+                                    inputs: {
+                                        result: ":result",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    extractResults: {
+                        agent: "copyAgent",
+                        inputs: {
+                            results: ":mapSearchAgent.result.flat()",
+                        },
+                        params: {
+                            namedKey: "results",
+                        },
+                    },
+                    reflectionAgent: {
+                        agent: "openAIAgent",
+                        inputs: {
+                            model: "gpt-4o-mini",
+                            system: "You are a professional research assistant. Based on the user's inquiry and the search results, return the sufficiency of information, knowledge gaps, and follow-up queries as a function call.",
+                            prompt: reflectionPrompt("${:searchQueryAgent.research_topic}", "${:reducer.array.toJSON()}"),
+                        },
+                        params: {
+                            tool_choice: "auto",
+                            tools: [
+                                {
+                                    type: "function",
+                                    function: {
+                                        name: "research_sufficiency",
+                                        description: "Return whether the information is sufficient, any knowledge gaps, and follow-up queries for the user's inquiry.",
+                                        parameters: {
+                                            type: "object",
+                                            properties: {
+                                                is_sufficient: {
+                                                    type: "boolean",
+                                                    description: "Whether the information is sufficient",
+                                                },
+                                                knowledge_gap: {
+                                                    type: "string",
+                                                    description: "Summary of missing knowledge or information",
+                                                },
+                                                follow_up_queries: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "string",
+                                                        description: "Additional questions to investigate (up to 3 maximum)",
+                                                    },
+                                                },
+                                            },
+                                            required: ["is_sufficient", "knowledge_gap", "follow_up_queries"],
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                        output: {
+                            is_sufficient: ".tool.arguments.is_sufficient",
+                            knowledge_gap: ".tool.arguments.knowledge_gap",
+                            follow_up_queries: ".tool.arguments.follow_up_queries",
+                        },
+                    },
+                    reducer: {
+                        agent: "pushAgent",
+                        inputs: {
+                            array: ":searchResults",
+                            items: ":extractResults",
+                        },
+                    },
+                    continue: {
+                        agent: ({ is_sufficient, knowledge_gap, counter, maxRetries, }) => {
+                            if (is_sufficient || counter >= maxRetries - 1) {
+                                GraphAILogger.info(`\n${agentHeader} All necessary information has been gathered. Preparing comprehensive report.`);
+                                return false;
+                            }
+                            GraphAILogger.info(`\n${agentHeader} ${knowledge_gap}`);
+                            return true;
+                        },
+                        inputs: {
+                            is_sufficient: ":reflectionAgent.is_sufficient",
+                            knowledge_gap: ":reflectionAgent.knowledge_gap",
+                            counter: ":counter",
+                            maxRetries: ":maxRetries",
+                        },
+                    },
+                    finalAnswer: {
+                        agent: "openAIAgent",
+                        unless: ":continue",
+                        inputs: {
+                            model: "gpt-4o-mini",
+                            system: "You are a professional research assistant. Based on the user's inquiry and the search results, return the final answer.",
+                            prompt: finalAnswerPrompt("${:userInput}", "${:searchResults.toJSON()}", "${:searchQueryAgent.research_topic}"),
+                        },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+        writeResult: {
+            agent: "consoleAgent",
+            inputs: {
+                text: "\n------Answer------\n\n${:deepResearch.finalAnswer.text}\n",
+            },
+        },
+    },
+};
+export const deepResearch = async () => {
+    const agentFilters = [
+        {
+            name: "consoleStreamDataAgentFilter",
+            agent: consoleStreamDataAgentFilter,
+            nodeIds: ["chatAgent"],
+        },
+    ];
+    const graph = new GraphAI(graphData, { ...vanillaAgents, openAIAgent, textInputAgent, tavilySearchAgent }, { agentFilters });
+    graph.injectValue("maxRetries", 3);
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "searchQueryAgent", message: "Generating search queries..." }));
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "reflectionAgent", message: "Analyzing search results..." }));
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "tavilySearchAgent", message: "Searching..." }));
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "finalAnswer", message: "Generating final answer..." }));
+    GraphAILogger.info(`${agentHeader} What would you like to know?\n`);
+    await graph.run();
+};
+deepResearch();

package/lib/types/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./type.js";
 export * from "./schema.js";
-export * from "./cli_types.js";

package/lib/types/index.js

@@ -1,3 +1,2 @@
 export * from "./type.js";
 export * from "./schema.js";
-export * from "./cli_types.js";