mulmocast 0.0.2 → 0.0.3

package/lib/agents/anthropic_agent.js

@@ -0,0 +1,162 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { getMergeValue } from "@graphai/llm_utils";
+const convToolCall = (tool_call) => {
+    const { id, name, input } = tool_call;
+    return { id, name, arguments: input };
+};
+// https://docs.anthropic.com/ja/api/messages
+const convertOpenAIChatCompletion = (response, messages) => {
+    // SDK bug https://github.com/anthropics/anthropic-sdk-typescript/issues/432
+    const text = response.content[0].text;
+    const functionResponses = response.content.filter((content) => content.type === "tool_use") ?? [];
+    const tool_calls = functionResponses.map(convToolCall);
+    const tool = tool_calls[0] ? tool_calls[0] : undefined;
+    const message = { role: response.role, content: text };
+    messages.push(message);
+    return { ...response, choices: [{ message }], text, tool, tool_calls, message, messages };
+};
+export const anthropicAgent = async ({ params, namedInputs, filterParams, config, }) => {
+    const { verbose, system, temperature, tools, tool_choice, max_tokens, prompt, messages } = { ...params, ...namedInputs };
+    const { apiKey, stream, forWeb, model } = {
+        ...params,
+        ...(config || {}),
+    };
+    console.log({ stream });
+    const userPrompt = getMergeValue(namedInputs, params, "mergeablePrompts", prompt);
+    const systemPrompt = getMergeValue(namedInputs, params, "mergeableSystem", system);
+    const messagesCopy = messages ? messages.map((m) => m) : [];
+    if (userPrompt) {
+        messagesCopy.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+    if (verbose) {
+        console.log(messagesCopy);
+    }
+    const anthropic_tools = tools && tools.length > 0
+        ? tools.map((tool) => {
+            const { function: func } = tool;
+            const { name, description, parameters } = func;
+            return {
+                name,
+                description,
+                input_schema: parameters,
+            };
+        })
+        : undefined;
+    const anthropic = new Anthropic({ apiKey, dangerouslyAllowBrowser: !!forWeb });
+    const chatParams = {
+        model: model ?? "claude-3-5-sonnet-latest",
+        messages: messagesCopy,
+        tools: anthropic_tools,
+        tool_choice,
+        system: systemPrompt,
+        temperature: temperature ?? 0.7,
+        max_tokens: max_tokens ?? 1024,
+    };
+    if (!stream) {
+        const messageResponse = await anthropic.messages.create(chatParams);
+        return convertOpenAIChatCompletion(messageResponse, messagesCopy);
+    }
+    try {
+        console.log("###");
+        const chatStream = await anthropic.messages.create({
+            ...chatParams,
+            stream: true,
+        });
+        console.log("###2");
+        const contents = [];
+        const partials = [];
+        let streamResponse = null;
+        console.log("###3");
+        for await (const messageStreamEvent of chatStream) {
+            console.log("AA");
+            if (messageStreamEvent.type === "message_start") {
+                streamResponse = messageStreamEvent.message;
+            }
+            if (messageStreamEvent.type === "content_block_start") {
+                if (streamResponse) {
+                    streamResponse.content.push(messageStreamEvent.content_block);
+                }
+                partials.push("");
+            }
+            if (messageStreamEvent.type === "content_block_delta") {
+                const { index, delta } = messageStreamEvent;
+                if (delta.type === "input_json_delta") {
+                    partials[index] = partials[index] + delta.partial_json;
+                }
+                if (delta.type === "text_delta") {
+                    partials[index] = partials[index] + delta.text;
+                }
+            }
+            if (messageStreamEvent.type === "content_block_delta" && messageStreamEvent.delta.type === "text_delta") {
+                const token = messageStreamEvent.delta.text;
+                contents.push(token);
+                if (filterParams && filterParams.streamTokenCallback && token) {
+                    filterParams.streamTokenCallback(token);
+                }
+            }
+        }
+        if (streamResponse === null) {
+            throw new Error("Anthoropic no response");
+        }
+        partials.forEach((partial, index) => {
+            if (streamResponse.content[index].type === "text") {
+                streamResponse.content[index].text = partial;
+            }
+            if (streamResponse.content[index].type === "tool_use") {
+                streamResponse.content[index].input = JSON.parse(partial);
+            }
+        });
+        return convertOpenAIChatCompletion(streamResponse, messagesCopy);
+        /*
+      
+      const content = contents.join("");
+      const message = { role: "assistant" as const, content: content };
+      messagesCopy.push(message);
+      return { choices: [{ message }], text: content, message, messages: messagesCopy };
+      */
+    }
+    catch (e) {
+        console.log(e);
+        throw new Error("ant Error");
+    }
+};
+const anthropicAgentInfo = {
+    name: "anthropicAgent",
+    agent: anthropicAgent,
+    mock: anthropicAgent,
+    inputs: {
+        type: "object",
+        properties: {
+            model: { type: "string" },
+            system: { type: "string" },
+            max_tokens: { type: "number" },
+            temperature: { type: "number" },
+            prompt: {
+                type: "string",
+                description: "query string",
+            },
+            messages: {
+                anyOf: [{ type: "string" }, { type: "integer" }, { type: "object" }, { type: "array" }],
+                description: "chat messages",
+            },
+        },
+    },
+    output: {
+        type: "object",
+    },
+    samples: [],
+    description: "Anthropic Agent",
+    category: ["llm"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    source: "https://github.com/receptron/graphai/blob/main/llm_agents/anthropic_agent/src/anthropic_agent.ts",
+    package: "@graphai/anthropic_agent",
+    license: "MIT",
+    stream: true,
+    environmentVariables: ["ANTHROPIC_API_KEY"],
+    npms: ["@anthropic-ai/sdk"],
+};
+export default anthropicAgentInfo;

package/lib/agents/combine_audio_files_agent.js

@@ -1,11 +1,10 @@
 import { GraphAILogger } from "graphai";
 import ffmpeg from "fluent-ffmpeg";
-import { silentPath, silentLastPath, getAudioSegmentFilePath } from "../utils/file.js";
-import { MulmoStudioContextMethods } from "../methods/index.js";
+import { silentPath, silentLastPath } from "../utils/file.js";
 const combineAudioFilesAgent = async ({ namedInputs }) => {
     const { context, combinedFileName, audioDirPath } = namedInputs;
     const command = ffmpeg();
-    const getDuration = (filePath, isLast) => {
+    const getDuration = (filePath, isLastGap) => {
         return new Promise((resolve, reject) => {
             ffmpeg.ffprobe(filePath, (err, metadata) => {
                 if (err) {
@@ -13,30 +12,22 @@ const combineAudioFilesAgent = async ({ namedInputs }) => {
                     reject(err);
                 }
                 else {
-                    resolve(metadata.format.duration + (isLast ? 0.8 : 0.3));
+                    // TODO: Remove hard-coded 0.8 and 0.3
+                    resolve(metadata.format.duration + (isLastGap ? 0.8 : 0.3));
                 }
             });
         });
     };
-    const resolveAudioFilePath = (context, mulmoBeat, audioDirPath) => {
-        if (mulmoBeat.audio?.type === "audio") {
-            const { source } = mulmoBeat.audio;
-            if (source.kind === "path") {
-                return MulmoStudioContextMethods.resolveAssetPath(context, source.path);
-            }
-            if (source.kind === "url") {
-                return source.url;
-            }
+    await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
+        const isLastGap = index === context.studio.beats.length - 2;
+        if (studioBeat.audioFile) {
+            command.input(studioBeat.audioFile);
+            command.input(isLastGap ? silentLastPath : silentPath);
+            studioBeat.duration = await getDuration(studioBeat.audioFile, isLastGap);
+        }
+        else {
+            GraphAILogger.error("Missing studioBeat.audioFile:", index);
         }
-        return getAudioSegmentFilePath(audioDirPath, context.studio.filename, mulmoBeat.audioFile ?? "");
-    };
-    await Promise.all(context.studio.beats.map(async (mulmoBeat, index) => {
-        const filePath = resolveAudioFilePath(context, mulmoBeat, audioDirPath);
-        const isLast = index === context.studio.beats.length - 2;
-        command.input(filePath);
-        command.input(isLast ? silentLastPath : silentPath);
-        // Measure and log the timestamp of each section
-        context.studio.beats[index]["duration"] = await getDuration(filePath, isLast);
     }));
     await new Promise((resolve, reject) => {
         command

package/lib/agents/nested_agent.d.ts

@@ -0,0 +1,9 @@
+import type { AgentFunction, AgentFunctionInfo, AgentFunctionContext, GraphData, ResultData, DefaultResultData } from "graphai";
+import type { GraphAISupressError, GraphAIOnError } from "@graphai/agent_utils";
+type NestedAgentGeneratorOption = {
+    resultNodeId: string;
+};
+export declare const nestedAgentGenerator: (graphData: GraphData, options?: NestedAgentGeneratorOption) => (context: AgentFunctionContext) => Promise<ResultData<DefaultResultData> | GraphAIOnError>;
+export declare const nestedAgent: AgentFunction<Partial<GraphAISupressError> & NestedAgentGeneratorOption>;
+declare const nestedAgentInfo: AgentFunctionInfo;
+export default nestedAgentInfo;

package/lib/agents/nested_agent.js

@@ -0,0 +1,138 @@
+import { GraphAI, assert, graphDataLatestVersion } from "graphai";
+export const nestedAgentGenerator = (graphData, options) => {
+    return async (context) => {
+        const { namedInputs, log, debugInfo, params, forNestedGraph } = context;
+        assert(!!forNestedGraph, "Please update graphai to 0.5.19 or higher");
+        const { agents, graphOptions, onLogCallback, callbacks } = forNestedGraph;
+        const { taskManager } = graphOptions;
+        const supressError = params.supressError ?? false;
+        if (taskManager) {
+            const status = taskManager.getStatus(false);
+            assert(status.concurrency > status.running, `nestedAgent: Concurrency is too low: ${status.concurrency}`);
+        }
+        assert(!!graphData, "nestedAgent: graph is required");
+        const { nodes } = graphData;
+        const newNodes = Object.keys(nodes).reduce((tmp, key) => {
+            const node = nodes[key];
+            if ("agent" in node) {
+                tmp[key] = node;
+            }
+            else {
+                const { value, update, isResult, console } = node;
+                tmp[key] = { value, update, isResult, console };
+            }
+            return tmp;
+        }, {});
+        const nestedGraphData = { ...graphData, nodes: newNodes, version: graphDataLatestVersion }; // deep enough copy
+        const nodeIds = Object.keys(namedInputs);
+        if (nodeIds.length > 0) {
+            nodeIds.forEach((nodeId) => {
+                if (nestedGraphData.nodes[nodeId] === undefined) {
+                    // If the input node does not exist, automatically create a static node
+                    nestedGraphData.nodes[nodeId] = { value: namedInputs[nodeId] };
+                }
+                else {
+                    // Otherwise, inject the proper data here (instead of calling injectTo method later)
+                    if (namedInputs[nodeId] !== undefined) {
+                        nestedGraphData.nodes[nodeId]["value"] = namedInputs[nodeId];
+                    }
+                }
+            });
+        }
+        try {
+            if (nestedGraphData.version === undefined && debugInfo.version) {
+                nestedGraphData.version = debugInfo.version;
+            }
+            const graphAI = new GraphAI(nestedGraphData, agents || {}, graphOptions);
+            // for backward compatibility. Remove 'if' later
+            if (onLogCallback) {
+                graphAI.onLogCallback = onLogCallback;
+            }
+            if (callbacks) {
+                graphAI.callbacks = callbacks;
+            }
+            debugInfo.subGraphs.set(graphAI.graphId, graphAI);
+            const results = await graphAI.run(false);
+            debugInfo.subGraphs.delete(graphAI.graphId);
+            log?.push(...graphAI.transactionLogs());
+            console.log("FFF");
+            if (options && options.resultNodeId) {
+                return results[options.resultNodeId];
+            }
+            return results;
+        }
+        catch (error) {
+            console.log("FFF2");
+            if (error instanceof Error && supressError) {
+                console.log("FFF3");
+                return {
+                    onError: {
+                        message: error.message,
+                        error,
+                    },
+                };
+            }
+            console.log("FFF4", error);
+            throw error;
+        }
+    };
+};
+export const nestedAgent = async (context) => {
+    const { forNestedGraph, params } = context;
+    const { graphData } = forNestedGraph ?? { graphData: { nodes: {} } };
+    assert(!!graphData, "No GraphData");
+    return await nestedAgentGenerator(graphData, params)(context);
+};
+const nestedAgentInfo = {
+    name: "nestedAgent",
+    agent: nestedAgent,
+    mock: nestedAgent,
+    samples: [
+        {
+            inputs: {
+                message: "hello",
+            },
+            params: {},
+            result: {
+                test: ["hello"],
+            },
+            graph: {
+                nodes: {
+                    test: {
+                        agent: "copyAgent",
+                        params: { namedKey: "messages" },
+                        inputs: { messages: [":message"] },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+        {
+            inputs: {
+                message: "hello",
+            },
+            params: {
+                resultNodeId: "test",
+            },
+            result: ["hello"],
+            graph: {
+                nodes: {
+                    test: {
+                        agent: "copyAgent",
+                        params: { namedKey: "messages" },
+                        inputs: { messages: [":message"] },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+    ],
+    description: "nested Agent",
+    category: ["graph"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    source: "https://github.com/receptron/graphai/blob/main/agents/vanilla_agents/src/graph_agents/nested_agent.ts",
+    package: "@graphai/vanilla",
+    license: "MIT",
+};
+export default nestedAgentInfo;

package/lib/cli/args.d.ts

@@ -1,4 +1,4 @@
-export declare const args: {
+export declare const getArgs: () => {
     [x: string]: unknown;
     v: boolean;
     o: string | undefined;
@@ -6,6 +6,8 @@ export declare const args: {
     a: string | undefined;
     i: string | undefined;
     f: boolean;
+    pdf_mode: string;
+    pdf_size: string;
     _: (string | number)[];
     $0: string;
 };

package/lib/cli/args.js

@@ -1,40 +1,55 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { commonOptions } from "./common.js";
-export const args = commonOptions(yargs(hideBin(process.argv)))
-    .scriptName("mulmo")
-    .option("a", {
-    alias: "audiodir",
-    description: "audio dir",
-    demandOption: false,
-    type: "string",
-})
-    .option("i", {
-    alias: "imagedir",
-    description: "image dir",
-    demandOption: false,
-    type: "string",
-})
-    .option("f", {
-    alias: "force",
-    description: "force generate",
-    demandOption: false,
-    default: false,
-    type: "boolean",
-})
-    .command("$0 <action> <file>", "Run mulmocast", (yargs) => {
-    return yargs
-        .positional("action", {
-        describe: "action to perform",
-        choices: ["translate", "audio", "images", "movie", "preprocess"],
+import { pdf_modes, pdf_sizes } from "../utils/const.js";
+export const getArgs = () => {
+    return commonOptions(yargs(hideBin(process.argv)))
+        .scriptName("mulmo")
+        .option("a", {
+        alias: "audiodir",
+        description: "audio dir",
+        demandOption: false,
         type: "string",
     })
-        .positional("file", {
-        describe: "Mulmo Script File",
+        .option("i", {
+        alias: "imagedir",
+        description: "image dir",
+        demandOption: false,
         type: "string",
-    });
-})
-    .strict()
-    .help()
-    .alias("help", "h")
-    .parseSync();
+    })
+        .option("f", {
+        alias: "force",
+        description: "force generate",
+        demandOption: false,
+        default: false,
+        type: "boolean",
+    })
+        .option("pdf_mode", {
+        description: "pdf mode",
+        demandOption: false,
+        choices: pdf_modes,
+        type: "string",
+        default: "slide",
+    })
+        .option("pdf_size", {
+        choices: pdf_sizes,
+        default: "letter",
+        describe: "PDF paper size (default: letter for US standard)",
+    })
+        .command("$0 <action> <file>", "Run mulmocast", (yargs) => {
+        return yargs
+            .positional("action", {
+            describe: "action to perform",
+            choices: ["translate", "audio", "images", "movie", "pdf", "preprocess"],
+            type: "string",
+        })
+            .positional("file", {
+            describe: "Mulmo Script File",
+            type: "string",
+        });
+    })
+        .strict()
+        .help()
+        .alias("help", "h")
+        .parseSync();
+};

package/lib/cli/cli.d.ts

@@ -1,2 +1,16 @@
 #!/usr/bin/env node
 import "dotenv/config";
+export declare const getFileObject: (_args: {
+    [x: string]: unknown;
+}) => {
+    baseDirPath: string;
+    mulmoFilePath: string;
+    mulmoFileDirPath: string;
+    outDirPath: string;
+    imageDirPath: string;
+    audioDirPath: string;
+    isHttpPath: boolean;
+    fileOrUrl: string;
+    outputStudioFilePath: string;
+    fileName: string;
+};

package/lib/cli/cli.js

@@ -2,35 +2,47 @@
 import "dotenv/config";
 import fs from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
 import { GraphAILogger } from "graphai";
-import { args } from "./args.js";
+import { getArgs } from "./args.js";
 import { createOrUpdateStudioData } from "../utils/preprocess.js";
 import { outDirName, imageDirName, audioDirName } from "../utils/const.js";
-import { MulmoScriptMethods } from "../methods/index.js";
-import { translate } from "../actions/translate.js";
-import { images } from "../actions/images.js";
-import { audio } from "../actions/audio.js";
-import { movie } from "../actions/movie.js";
-import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile } from "../utils/file.js";
-import { mulmoScriptSchema } from "../types/schema.js";
-const isHttp = (fileOrUrl) => {
-    return /^https?:\/\//.test(fileOrUrl);
-};
-const getFileObject = () => {
-    const { basedir, file, outdir, imagedir, audiodir } = args;
+import { translate, audio, images, movie, pdf } from "../../src/actions/index.js";
+import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath } from "../utils/file.js";
+import { isHttp } from "../utils/utils.js";
+export const getFileObject = (_args) => {
+    const { basedir, file, outdir, imagedir, audiodir } = _args;
     const baseDirPath = getBaseDirPath(basedir);
     const fileOrUrl = file ?? "";
+    const fileName = path.parse(fileOrUrl).name;
     const isHttpPath = isHttp(fileOrUrl);
     const mulmoFilePath = isHttpPath ? "" : getFullPath(baseDirPath, fileOrUrl);
     const mulmoFileDirPath = path.dirname(isHttpPath ? baseDirPath : mulmoFilePath);
     const outDirPath = getFullPath(baseDirPath, outdir ?? outDirName);
     const imageDirPath = getFullPath(outDirPath, imagedir ?? imageDirName);
     const audioDirPath = getFullPath(outDirPath, audiodir ?? audioDirName);
-    return { baseDirPath, mulmoFilePath, mulmoFileDirPath, outDirPath, imageDirPath, audioDirPath, isHttpPath, fileOrUrl };
+    const outputStudioFilePath = getOutputStudioFilePath(outDirPath, fileName);
+    return { baseDirPath, mulmoFilePath, mulmoFileDirPath, outDirPath, imageDirPath, audioDirPath, isHttpPath, fileOrUrl, outputStudioFilePath, fileName };
+};
+const fetchScript = async (isHttpPath, mulmoFilePath, fileOrUrl) => {
+    if (isHttpPath) {
+        const res = await fetchMulmoScriptFile(fileOrUrl);
+        if (!res.result || !res.script) {
+            GraphAILogger.info(`ERROR: HTTP error! ${res.status} ${fileOrUrl}`);
+            process.exit(1);
+        }
+        return res.script;
+    }
+    if (!fs.existsSync(mulmoFilePath)) {
+        GraphAILogger.info(`ERROR: File not exists ${mulmoFilePath}`);
+        process.exit(1);
+    }
+    return readMulmoScriptFile(mulmoFilePath, "ERROR: File does not exist " + mulmoFilePath).mulmoData;
 };
 const main = async () => {
-    const files = getFileObject();
-    const { mulmoFilePath, isHttpPath, fileOrUrl } = files;
+    const args = getArgs();
+    const files = getFileObject(args);
+    const { mulmoFilePath, isHttpPath, fileOrUrl, fileName, outputStudioFilePath } = files;
     if (args.v) {
         GraphAILogger.info(files);
     }
@@ -39,37 +51,20 @@ const main = async () => {
         GraphAILogger.setLevelEnabled("log", false);
         GraphAILogger.setLevelEnabled("warn", false);
     }
-    const { action, force } = args;
-    const readData = await (async () => {
-        if (isHttpPath) {
-            const res = await fetchMulmoScriptFile(fileOrUrl);
-            if (!res.result || !res.script) {
-                GraphAILogger.info(`ERROR: HTTP error! ${res.status} ${fileOrUrl}`);
-                process.exit(1);
-            }
-            return {
-                mulmoData: res.script,
-                fileName: path.parse(fileOrUrl).name,
-            };
+    const { action, force, pdf_mode, pdf_size } = args;
+    const mulmoScript = await fetchScript(isHttpPath, mulmoFilePath, fileOrUrl);
+    // Create or update MulmoStudio file with MulmoScript
+    const currentStudio = readMulmoScriptFile(outputStudioFilePath);
+    const studio = (() => {
+        try {
+            // validate mulmoStudioSchema. skip if __test_invalid__ is true
+            return createOrUpdateStudioData(mulmoScript, currentStudio?.mulmoData, fileName);
         }
-        if (!fs.existsSync(mulmoFilePath)) {
-            GraphAILogger.info("ERROR: File not exists " + mulmoFilePath);
+        catch (error) {
+            GraphAILogger.info(`Error: invalid MulmoScript Schema: ${isHttpPath ? fileOrUrl : mulmoFilePath} \n ${error}`);
             process.exit(1);
         }
-        return readMulmoScriptFile(mulmoFilePath, "ERROR: File does not exist " + mulmoFilePath);
     })();
-    const { mulmoData: mulmoScript, fileName } = readData;
-    // validate mulmoStudioSchema. skip if __test_invalid__ is true
-    try {
-        if (!mulmoScript?.__test_invalid__) {
-            mulmoScriptSchema.parse(mulmoScript);
-        }
-    }
-    catch (error) {
-        GraphAILogger.info(`Error: invalid MulmoScript Schema: ${isHttpPath ? fileOrUrl : mulmoFilePath} \n ${error}`);
-        process.exit(1);
-    }
-    const studio = createOrUpdateStudioData(mulmoScript, fileName, files);
     const context = {
         studio,
         fileDirs: files,
@@ -79,15 +74,22 @@ const main = async () => {
         await translate(context);
     }
     if (action === "audio") {
-        await audio(context, MulmoScriptMethods.getSpeechProvider(studio.script) === "nijivoice" ? 1 : 8);
+        await audio(context);
     }
     if (action === "images") {
         await images(context);
     }
     if (action === "movie") {
-        await audio(context, MulmoScriptMethods.getSpeechProvider(studio.script) === "nijivoice" ? 1 : 8);
+        await audio(context);
         await images(context);
         await movie(context);
     }
+    if (action === "pdf") {
+        await images(context);
+        await pdf(context, pdf_mode, pdf_size);
+    }
 };
-main();
+const __filename = fileURLToPath(import.meta.url);
+if (process.argv[1] === __filename) {
+    main();
+}

package/lib/cli/tool-args.d.ts

@@ -8,6 +8,8 @@ export declare const args: {
     t: string | undefined;
     c: string | undefined;
     s: string;
+    llm_agent: string | undefined;
+    llm_model: string | undefined;
     _: (string | number)[];
     $0: string;
 };

package/lib/cli/tool-args.js

@@ -1,9 +1,8 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { commonOptions } from "./common.js";
-import { GraphAILogger } from "graphai";
 import { getAvailableTemplates } from "../utils/file.js";
-GraphAILogger.setLevelEnabled("error", false);
+import { llmAgents } from "../utils/utils.js";
 const availableTemplateNames = getAvailableTemplates().map((template) => template.filename);
 export const args = commonOptions(yargs(hideBin(process.argv)))
     .scriptName("mulmo-tool")
@@ -40,6 +39,17 @@ export const args = commonOptions(yargs(hideBin(process.argv)))
     demandOption: false,
     default: "script",
     type: "string",
+})
+    .option("llm_agent", {
+    description: "llm agent",
+    demandOption: false,
+    choices: llmAgents,
+    type: "string",
+})
+    .option("llm_model", {
+    description: "llm model",
+    demandOption: false,
+    type: "string",
 })
     .command("$0 <action>", "Run mulmocast tool", (yargs) => {
     return yargs.positional("action", {