mulmocast 0.0.3 → 0.0.4

package/lib/cli/cli.d.ts

@@ -14,3 +14,4 @@ export declare const getFileObject: (_args: {
     outputStudioFilePath: string;
     fileName: string;
 };
+export declare const main: () => Promise<void>;

package/lib/cli/cli.js

@@ -2,12 +2,11 @@
 import "dotenv/config";
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
 import { GraphAILogger } from "graphai";
 import { getArgs } from "./args.js";
 import { createOrUpdateStudioData } from "../utils/preprocess.js";
 import { outDirName, imageDirName, audioDirName } from "../utils/const.js";
-import { translate, audio, images, movie, pdf } from "../../src/actions/index.js";
+import { translate, audio, images, movie, pdf } from "../actions/index.js";
 import { getBaseDirPath, getFullPath, readMulmoScriptFile, fetchMulmoScriptFile, getOutputStudioFilePath } from "../utils/file.js";
 import { isHttp } from "../utils/utils.js";
 export const getFileObject = (_args) => {
@@ -39,7 +38,7 @@ const fetchScript = async (isHttpPath, mulmoFilePath, fileOrUrl) => {
     }
     return readMulmoScriptFile(mulmoFilePath, "ERROR: File does not exist " + mulmoFilePath).mulmoData;
 };
-const main = async () => {
+export const main = async () => {
     const args = getArgs();
     const files = getFileObject(args);
     const { mulmoFilePath, isHttpPath, fileOrUrl, fileName, outputStudioFilePath } = files;
@@ -89,7 +88,3 @@ const main = async () => {
         await pdf(context, pdf_mode, pdf_size);
     }
 };
-const __filename = fileURLToPath(import.meta.url);
-if (process.argv[1] === __filename) {
-    main();
-}

package/lib/cli/run.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cli/run.js

@@ -0,0 +1,2 @@
+import { main } from "./cli.js";
+main();

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mulmocast",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "",
   "type": "module",
-  "main": "lib/cli/cli.js",
+  "main": "lib/cli/run.js",
   "bin": {
-    "mulmo": "lib/cli/cli.js",
+    "mulmo": "lib/cli/run.js",
     "mulmo-tool": "lib/cli/tool-cli.js"
   },
   "files": [
@@ -23,18 +23,18 @@
     "test": "tests"
   },
   "scripts": {
-    "audio": "npx tsx ./src/cli/cli.ts audio",
-    "translate": "npx tsx ./src/cli/cli.ts translate",
-    "movie": "npx tsx ./src/cli/cli.ts movie",
-    "images": "npx tsx ./src/cli/cli.ts images",
-    "preprocess": "npx tsx ./src/cli/cli.ts preprocess",
+    "audio": "npx tsx ./src/cli/run.ts audio",
+    "translate": "npx tsx ./src/cli/run.ts translate",
+    "movie": "npx tsx ./src/cli/run.ts movie",
+    "images": "npx tsx ./src/cli/run.ts images",
+    "preprocess": "npx tsx ./src/cli/run.ts preprocess",
     "test": "rm -f scratchpad/test*.* && npx tsx ./src/audio.ts scripts/test/test.json && npx tsx ./src/images.ts scripts/test/test.json && npx tsx ./src/movie.ts scripts/test/test.json",
     "ci_test": "tsx --test ./test/*/test_*.ts",
     "lint": "eslint src test",
     "build": "tsc",
     "build_test": "tsc && git checkout -- lib/*",
     "prompt": "npx tsx ./src/tools/prompt.ts",
-    "cli": "npx tsx ./src/cli/cli.ts",
+    "cli": "npx tsx ./src/cli/run.ts",
     "scripting": "npx tsx ./src/cli/tool-cli.ts scripting",
     "dump_prompt": "npx tsx ./src/cli/tool-cli.ts prompt",
     "latest": "yarn upgrade-interactive  --latest",

package/lib/actions/pdf2.d.ts

@@ -1,2 +0,0 @@
-import { MulmoStudioContext, PDFMode, PDFSize } from "../types/index.js";
-export declare const pdf: (context: MulmoStudioContext, pdfMode: PDFMode, pdfSize: PDFSize) => Promise<void>;

package/lib/actions/pdf2.js

@@ -1,203 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { rgb, PDFDocument } from "pdf-lib";
-import { chunkArray, isHttp } from "../utils/utils.js";
-import { getOutputPdfFilePath, writingMessage } from "../utils/file.js";
-import { MulmoScriptMethods } from "../methods/index.js";
-const imagesPerPage = 4;
-const offset = 10;
-const handoutImageRatio = 0.5;
-const readImage = async (imagePath, pdfDoc) => {
-    const imageBytes = await (async () => {
-        if (isHttp(imagePath)) {
-            const res = await fetch(imagePath);
-            const arrayBuffer = await res.arrayBuffer();
-            return Buffer.from(arrayBuffer);
-        }
-        return fs.readFileSync(imagePath);
-    })();
-    const ext = path.extname(imagePath).toLowerCase();
-    return ext === ".jpg" || ext === ".jpeg" ? await pdfDoc.embedJpg(imageBytes) : await pdfDoc.embedPng(imageBytes);
-};
-const pdfSlide = async (pageWidth, pageHeight, imagePaths, pdfDoc) => {
-    const cellRatio = pageHeight / pageWidth;
-    for (const imagePath of imagePaths) {
-        const image = await readImage(imagePath, pdfDoc);
-        const { width: origWidth, height: origHeight } = image.scale(1);
-        const originalRatio = origHeight / origWidth;
-        const fitWidth = originalRatio / cellRatio < 1;
-        const { drawWidth, drawHeight } = drawSize(fitWidth, pageWidth, pageHeight, origWidth, origHeight);
-        const page = pdfDoc.addPage([pageWidth, pageHeight]);
-        page.drawImage(image, {
-            x: 0,
-            y: 0,
-            width: drawWidth,
-            height: drawHeight,
-        });
-    }
-};
-const pdfTalk = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc) => {
-    const imageRatio = 0.7;
-    const textMargin = 20;
-    const textY = textMargin + (pageHeight * (1 - imageRatio)) / 2;
-    const targetWidth = pageWidth - offset;
-    const targetHeight = pageHeight * imageRatio - offset;
-    const cellRatio = targetHeight / targetWidth;
-    for (const [index, imagePath] of imagePaths.entries()) {
-        const text = texts[index];
-        const image = await readImage(imagePath, pdfDoc);
-        const { width: origWidth, height: origHeight } = image.scale(1);
-        const originalRatio = origHeight / origWidth;
-        const fitWidth = originalRatio / cellRatio < 1;
-        const { drawWidth, drawHeight } = drawSize(fitWidth, targetWidth, targetHeight, origWidth, origHeight);
-        const x = (pageWidth - drawWidth) / 2;
-        const y = pageHeight - drawHeight - offset;
-        const page = pdfDoc.addPage([pageWidth, pageHeight]);
-        const pos = {
-            x,
-            y,
-            width: drawWidth,
-            height: drawHeight,
-        };
-        page.drawImage(image, pos);
-        page.drawRectangle({
-            ...pos,
-            borderColor: rgb(0, 0, 0),
-            borderWidth: 1,
-        });
-        page.drawText(text, {
-            x: textMargin,
-            y: textY,
-            size: 24,
-            color: rgb(0, 0, 0),
-            maxWidth: pageWidth - 2 * textMargin,
-        });
-    }
-};
-const drawSize = (fitWidth, expectWidth, expectHeight, origWidth, origHeight) => {
-    if (fitWidth) {
-        const drawWidth = expectWidth;
-        const scale = drawWidth / origWidth;
-        const drawHeight = origHeight * scale;
-        return {
-            drawWidth,
-            drawHeight,
-        };
-    }
-    const drawHeight = expectHeight;
-    const scale = drawHeight / origHeight;
-    const drawWidth = origWidth * scale;
-    return {
-        drawWidth,
-        drawHeight,
-    };
-};
-const pdfHandout = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, isLandscapeImage) => {
-    const cellRatio = (pageHeight / imagesPerPage - offset) / (pageWidth * handoutImageRatio - offset);
-    let i = 0;
-    for (const chunkPaths of chunkArray(imagePaths, imagesPerPage)) {
-        const page = pdfDoc.addPage([pageWidth, pageHeight]);
-        for (let i = 0; i < chunkPaths.length; i++) {
-            const imagePath = chunkPaths[i];
-            const image = await readImage(imagePath, pdfDoc);
-            const { width: origWidth, height: origHeight } = image.scale(1);
-            const originalRatio = origHeight / origWidth;
-            const fitWidth = originalRatio / cellRatio < 1;
-            // console.log({handoutImageRatio, cellRatio, ratio,  imageHeight, origHeight});
-            const pos = (() => {
-                if (isLandscapeImage) {
-                    const cellHeight = pageHeight / imagesPerPage - offset;
-                    const { drawWidth, drawHeight } = drawSize(fitWidth, (pageWidth - offset) * handoutImageRatio, cellHeight - offset, origWidth, origHeight);
-                    const x = offset;
-                    const y = pageHeight - (i + 1) * cellHeight + (cellHeight - drawHeight) * handoutImageRatio;
-                    return {
-                        x,
-                        y,
-                        width: drawWidth,
-                        height: drawHeight,
-                    };
-                }
-                else {
-                    const cellWidth = pageWidth / imagesPerPage;
-                    const { drawWidth, drawHeight } = drawSize(fitWidth, cellWidth - offset, (pageHeight - offset) * handoutImageRatio, origWidth, origHeight);
-                    const x = pageWidth - (imagesPerPage - i) * cellWidth + (cellWidth - drawWidth) * handoutImageRatio;
-                    const y = pageHeight - drawHeight - offset;
-                    return {
-                        x,
-                        y,
-                        width: drawWidth,
-                        height: drawHeight,
-                    };
-                }
-            })();
-            page.drawRectangle({
-                ...pos,
-                borderColor: rgb(0, 0, 0),
-                borderWidth: 1,
-            });
-            page.drawImage(image, pos);
-            const text = texts[i];
-            const textMargin = 20;
-            if (isLandscapeImage) {
-                const textX = pos.x + pos.width + textMargin; // 画像の右端より少し右
-                const textY = pos.y + pos.height - 12; // 画像の上に揃える or 必要に応じて調整
-                page.drawText(text, {
-                    x: textX,
-                    y: textY,
-                    size: 12,
-                    color: rgb(0, 0, 0),
-                    maxWidth: pageWidth - textX - textMargin,
-                });
-            }
-            else {
-                const textY = pos.y - textMargin - 12;
-                page.drawText(text, {
-                    x: pos.x,
-                    y: textY,
-                    size: 12,
-                    color: rgb(0, 0, 0),
-                    maxWidth: pos.width,
-                });
-            }
-            i++;
-        }
-    }
-};
-const outputSize = (pdfSize, isLandscapeImage, isRotate) => {
-    // console.log(pdfSize);
-    if (pdfSize === "a4") {
-        if (isLandscapeImage !== isRotate) {
-            return { width: 841.89, height: 595.28 };
-        }
-        return { width: 595.28, height: 841.89 };
-    }
-    // letter
-    if (isLandscapeImage !== isRotate) {
-        return { width: 792, height: 612 };
-    }
-    return { width: 612, height: 792 };
-};
-export const pdf = async (context, pdfMode, pdfSize) => {
-    const { studio, fileDirs } = context;
-    const { outDirPath } = fileDirs;
-    const { width: imageWidth, height: imageHeight } = MulmoScriptMethods.getCanvasSize(studio.script);
-    const isLandscapeImage = imageWidth > imageHeight;
-    const isRotate = pdfMode === "handout";
-    const { width: pageWidth, height: pageHeight } = outputSize(pdfSize, isLandscapeImage, isRotate);
-    const imagePaths = studio.beats.map((beat) => beat.imageFile);
-    const texts = studio.script.beats.map((beat) => beat.text);
-    const outputPdfPath = getOutputPdfFilePath(outDirPath, studio.filename, pdfMode);
-    const pdfDoc = await PDFDocument.create();
-    if (pdfMode === "handout") {
-        await pdfHandout(pageWidth, pageHeight, imagePaths, texts, pdfDoc, isLandscapeImage);
-    }
-    if (pdfMode === "slide") {
-        await pdfSlide(pageWidth, pageHeight, imagePaths, pdfDoc);
-    }
-    if (pdfMode === "talk") {
-        await pdfTalk(pageWidth, pageHeight, imagePaths, texts, pdfDoc);
-    }
-    const pdfBytes = await pdfDoc.save();
-    fs.writeFileSync(outputPdfPath, pdfBytes);
-    writingMessage(outputPdfPath);
-};

package/lib/agents/anthropic_agent.d.ts

@@ -1,23 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { AgentFunction, AgentFunctionInfo } from "graphai";
-import { GraphAILLMInputBase } from "@graphai/llm_utils";
-import type { GraphAIText, GraphAITool, GraphAIToolCalls, GraphAIMessage, GraphAIMessages } from "@graphai/agent_utils";
-type AnthropicInputs = {
-    verbose?: boolean;
-    model?: string;
-    temperature?: number;
-    max_tokens?: number;
-    tools?: any[];
-    tool_choice?: any;
-    messages?: Array<Anthropic.MessageParam>;
-} & GraphAILLMInputBase;
-type AnthropicConfig = {
-    apiKey?: string;
-    stream?: boolean;
-    forWeb?: boolean;
-};
-type AnthropicParams = AnthropicInputs & AnthropicConfig;
-type AnthropicResult = Partial<GraphAIText & GraphAITool & GraphAIToolCalls & GraphAIMessage<string | Anthropic.ContentBlockParam[]> & GraphAIMessages<string | Anthropic.ContentBlockParam[]>>;
-export declare const anthropicAgent: AgentFunction<AnthropicParams, AnthropicResult, AnthropicInputs, AnthropicConfig>;
-declare const anthropicAgentInfo: AgentFunctionInfo;
-export default anthropicAgentInfo;

package/lib/agents/anthropic_agent.js

@@ -1,162 +0,0 @@
-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/nested_agent.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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/tools/seed.d.ts

@@ -1,3 +0,0 @@
-import "dotenv/config";
-import { ScriptingParams } from "../types";
-export declare const createMulmoScriptWithInteractive: ({ outDirPath, filename, templateName, urls }: ScriptingParams) => Promise<void>;

package/lib/tools/seed.js

@@ -1,201 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMulmoScriptWithInteractive = void 0;
-require("dotenv/config");
-const graphai_1 = require("graphai");
-const input_agents_1 = require("@graphai/input_agents");
-const openai_agent_1 = require("@graphai/openai_agent");
-const vanilla = __importStar(require("@graphai/vanilla"));
-const vanilla_node_agents_1 = require("@graphai/vanilla_node_agents");
-const file_1 = require("../utils/file");
-const browserless_agent_1 = require("@graphai/browserless_agent");
-const agentHeader = "\x1b[34m● \x1b[0m\x1b[1mAgent\x1b[0m:\x1b[0m";
-const graphDataForScraping = {
-    version: 0.5,
-    nodes: {
-        urls: {
-            value: [],
-        },
-        fetchResults: {
-            agent: "mapAgent",
-            inputs: {
-                rows: ":urls",
-            },
-            params: {
-                compositeResult: true,
-            },
-            graph: {
-                nodes: {
-                    fetcher: {
-                        agent: "browserlessAgent",
-                        inputs: {
-                            url: ":row",
-                            text_content: true,
-                        },
-                    },
-                    copyAgent: {
-                        agent: "copyAgent",
-                        inputs: {
-                            text: '{ url: "${:row}", text: "${:fetcher.text}" }',
-                        },
-                        params: {
-                            namedKey: "text",
-                        },
-                        isResult: true,
-                    },
-                },
-            },
-        },
-        sourceText: {
-            agent: "arrayJoinAgent",
-            inputs: {
-                array: ":fetchResults.copyAgent",
-            },
-            params: {
-                separator: ",",
-            },
-            isResult: true,
-        },
-    },
-};
-const graphData = {
-    version: 0.5,
-    loop: {
-        while: ":continue",
-    },
-    nodes: {
-        fileName: {
-            update: ":fileName",
-        },
-        outdir: {
-            update: ":outdir",
-        },
-        messages: {
-            value: [],
-            update: ":llm.messages",
-        },
-        userInput: {
-            agent: "textInputAgent",
-            params: {
-                message: "You:",
-                required: true,
-            },
-        },
-        llm: {
-            agent: "openAIAgent",
-            params: {
-                model: "gpt-4o",
-            },
-            inputs: {
-                messages: ":messages",
-                prompt: ":userInput.text",
-            },
-        },
-        json: {
-            agent: "copyAgent",
-            inputs: {
-                json: ":llm.text.codeBlock().jsonParse()",
-                text: ":llm.text.codeBlock()",
-            },
-        },
-        writeJSON: {
-            if: ":json.json",
-            agent: "fileWriteAgent",
-            inputs: {
-                file: "${:outdir}/${:fileName}-${@now}.json",
-                text: ":json.text",
-            },
-        },
-        writeLog: {
-            agent: "consoleAgent",
-            inputs: {
-                text: "\n\x1b[32m🎉 Script file generated successfully! Type /bye to exit.\x1b[0m\nwriting: ${:writeJSON.path}",
-                waiting: ":writeJSON",
-            },
-        },
-        shouldResponse: {
-            agent: "compareAgent",
-            inputs: {
-                array: [[":json.json", "==", undefined], "&&", [":userInput.text", "!=", "/bye"]],
-            },
-        },
-        agentResponse: {
-            if: ":shouldResponse.result",
-            agent: "consoleAgent",
-            inputs: {
-                text: "\n" + agentHeader + " ${:llm.text}\n",
-            },
-        },
-        checkInput: {
-            agent: "compareAgent",
-            inputs: { array: [":userInput.text", "!=", "/bye"] },
-        },
-        continue: {
-            value: true,
-            update: ":checkInput.result",
-        },
-    },
-};
-const interactiveClarificationPrompt = `If there are any unclear points, be sure to ask the user questions and clarify them before generating the script.`;
-const scrapeWebContent = async (urls) => {
-    console.log(`${agentHeader} Scraping ${urls.length} URLs...\n`);
-    const graph = new graphai_1.GraphAI(graphDataForScraping, { ...vanilla, openAIAgent: openai_agent_1.openAIAgent, textInputAgent: input_agents_1.textInputAgent, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent, browserlessAgent: browserless_agent_1.browserlessAgent });
-    graph.injectValue("urls", urls);
-    const result = (await graph.run());
-    if (!result?.sourceText?.text) {
-        return "";
-    }
-    const prefixPrompt = "Here is the web content that can be used as reference material for the script:";
-    return `\n\n${prefixPrompt}\n${result?.sourceText.text}`;
-};
-const createMulmoScriptWithInteractive = async ({ outDirPath, filename, templateName, urls }) => {
-    (0, file_1.mkdir)(outDirPath);
-    // if urls is not empty, scrape web content and reference it in the prompt
-    const webContentPrompt = urls.length > 0 ? await scrapeWebContent(urls) : "";
-    const graph = new graphai_1.GraphAI(graphData, { ...vanilla, openAIAgent: openai_agent_1.openAIAgent, textInputAgent: input_agents_1.textInputAgent, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent });
-    const prompt = (0, file_1.readTemplatePrompt)(templateName);
-    graph.injectValue("messages", [
-        {
-            role: "system",
-            content: `${prompt}\n\n${interactiveClarificationPrompt}${webContentPrompt}`,
-        },
-    ]);
-    graph.injectValue("outdir", outDirPath);
-    graph.injectValue("fileName", filename);
-    console.log(`${agentHeader} Hi! What topic would you like me to generate about?\n`);
-    await graph.run();
-};
-exports.createMulmoScriptWithInteractive = createMulmoScriptWithInteractive;

package/lib/tools/seed_from_url.d.ts

@@ -1,3 +0,0 @@
-import "dotenv/config";
-import { ScriptingParams } from "../types";
-export declare const createMulmoScriptFromUrl: ({ urls, templateName, outDirPath, filename }: ScriptingParams) => Promise<void>;

package/lib/tools/seed_from_url.js

@@ -1,178 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMulmoScriptFromUrl = void 0;
-require("dotenv/config");
-const graphai_1 = require("graphai");
-const openai_agent_1 = require("@graphai/openai_agent");
-const vanilla = __importStar(require("@graphai/vanilla"));
-const vanilla_node_agents_1 = require("@graphai/vanilla_node_agents");
-const browserless_agent_1 = require("@graphai/browserless_agent");
-const validate_mulmo_script_agent_1 = __importDefault(require("../agents/validate_mulmo_script_agent"));
-const file_1 = require("../utils/file");
-const schema_1 = require("../types/schema");
-const graphData = {
-    version: 0.5,
-    // Execute sequentially because the free version of browserless API doesn't support concurrent execution.
-    concurrency: 1,
-    nodes: {
-        urls: {
-            value: [],
-        },
-        prompt: {
-            value: "",
-        },
-        outdir: {
-            value: "",
-        },
-        fileName: {
-            value: "",
-        },
-        // get the text content of the urls
-        fetchResults: {
-            agent: "mapAgent",
-            inputs: {
-                rows: ":urls",
-            },
-            params: {
-                compositeResult: true,
-            },
-            graph: {
-                nodes: {
-                    fetcher: {
-                        agent: "browserlessAgent",
-                        inputs: {
-                            url: ":row",
-                            text_content: true,
-                        },
-                    },
-                    copyAgent: {
-                        agent: "copyAgent",
-                        inputs: {
-                            text: '{ url: "${:row}", text: "${:fetcher.text}" }',
-                        },
-                        params: {
-                            namedKey: "text",
-                        },
-                        isResult: true,
-                    },
-                },
-            },
-        },
-        // join the text content
-        sourceText: {
-            agent: "arrayJoinAgent",
-            inputs: {
-                array: ":fetchResults.copyAgent",
-            },
-            params: {
-                separator: ",",
-            },
-        },
-        // generate the mulmo script
-        mulmoScript: {
-            agent: "nestedAgent",
-            inputs: {
-                sourceText: ":sourceText",
-                prompt: ":prompt",
-            },
-            graph: {
-                loop: {
-                    // If the script is not valid and the counter is less than 3, continue the loop
-                    while: ":continue",
-                },
-                nodes: {
-                    counter: {
-                        value: 0,
-                        update: ":counter.add(1)",
-                    },
-                    openAIAgent: {
-                        agent: "openAIAgent",
-                        inputs: {
-                            model: "gpt-4o",
-                            system: ":prompt",
-                            prompt: "Please create a script using the information from the following URLs as reference: ${:sourceText.text}",
-                        },
-                    },
-                    validateMulmoScriptAgent: {
-                        agent: "validateMulmoScriptAgent",
-                        inputs: {
-                            text: ":openAIAgent.text.codeBlock()",
-                        },
-                        isResult: true,
-                    },
-                    continue: {
-                        agent: ({ isValid, counter }) => {
-                            return !isValid && counter < 3;
-                        },
-                        inputs: {
-                            isValid: ":validateMulmoScriptAgent.isValid",
-                            counter: ":counter",
-                        },
-                    },
-                },
-            },
-        },
-        writeJSON: {
-            if: ":mulmoScript.validateMulmoScriptAgent.isValid",
-            agent: "fileWriteAgent",
-            inputs: {
-                file: "${:outdir}/${:fileName}-${@now}.json",
-                text: ":mulmoScript.validateMulmoScriptAgent.data.toJSON()",
-            },
-            isResult: true,
-        },
-    },
-};
-const createMulmoScriptFromUrl = async ({ urls, templateName, outDirPath, filename }) => {
-    (0, file_1.mkdir)(outDirPath);
-    const parsedUrls = schema_1.urlsSchema.parse(urls);
-    const graph = new graphai_1.GraphAI(graphData, {
-        ...vanilla,
-        openAIAgent: openai_agent_1.openAIAgent,
-        browserlessAgent: browserless_agent_1.browserlessAgent,
-        validateMulmoScriptAgent: validate_mulmo_script_agent_1.default,
-        fileWriteAgent: vanilla_node_agents_1.fileWriteAgent,
-    });
-    graph.injectValue("urls", parsedUrls);
-    graph.injectValue("prompt", (0, file_1.readTemplatePrompt)(templateName));
-    graph.injectValue("outdir", outDirPath);
-    graph.injectValue("fileName", filename);
-    await graph.run();
-};
-exports.createMulmoScriptFromUrl = createMulmoScriptFromUrl;

package/lib/tools/seed_from_url2.d.ts

@@ -1,3 +0,0 @@
-import "dotenv/config";
-import { ScriptingParams } from "../types";
-export declare const createMulmoScriptFromUrl: ({ urls, templateName, outDirPath, filename, cacheDirPath }: ScriptingParams) => Promise<void>;

package/lib/tools/seed_from_url2.js

@@ -1,154 +0,0 @@
-import "dotenv/config";
-import { GraphAI } from "graphai";
-import { openAIAgent } from "@graphai/openai_agent";
-import * as vanilla from "@graphai/vanilla";
-import { fileWriteAgent } from "@graphai/vanilla_node_agents";
-import { browserlessAgent } from "@graphai/browserless_agent";
-import validateMulmoScriptAgent from "../agents/validate_mulmo_script_agent";
-import { readTemplatePrompt, mkdir, writingMessage } from "../utils/file";
-import { browserlessCacheGenerator } from "../utils/filters";
-import { urlsSchema } from "../types/schema";
-import { cliLoadingPlugin } from "../utils/plugins";
-const graphData = {
-    version: 0.5,
-    // Execute sequentially because the free version of browserless API doesn't support concurrent execution.
-    concurrency: 1,
-    nodes: {
-        urls: {
-            value: [],
-        },
-        prompt: {
-            value: "",
-        },
-        outdir: {
-            value: "",
-        },
-        fileName: {
-            value: "",
-        },
-        fetchGraph: {
-            value: {
-                nodes: {
-                    fetcher: {
-                        agent: "browserlessAgent",
-                        inputs: {
-                            url: ":row",
-                            text_content: true,
-                        },
-                    },
-                    copyAgent: {
-                        agent: "copyAgent",
-                        inputs: {
-                            text: '{ url: "${:row}", text: "${:fetcher.text}" }',
-                        },
-                        params: {
-                            namedKey: "text",
-                        },
-                        isResult: true,
-                    },
-                },
-            },
-        },
-        // get the text content of the urls
-        fetchResults: {
-            agent: "mapAgent",
-            inputs: {
-                rows: ":urls",
-            },
-            params: {
-                compositeResult: true,
-            },
-            graph: ":fetchGraph",
-        },
-        // join the text content
-        sourceText: {
-            agent: "arrayJoinAgent",
-            inputs: {
-                array: ":fetchResults.copyAgent",
-            },
-            params: {
-                separator: ",",
-            },
-        },
-        // generate the mulmo script
-        mulmoScript: {
-            agent: "nestedAgent",
-            inputs: {
-                sourceText: ":sourceText",
-                prompt: ":prompt",
-            },
-            graph: {
-                loop: {
-                    // If the script is not valid and the counter is less than 3, continue the loop
-                    while: ":continue",
-                },
-                nodes: {
-                    counter: {
-                        value: 0,
-                        update: ":counter.add(1)",
-                    },
-                    openAIAgent: {
-                        agent: "openAIAgent",
-                        inputs: {
-                            model: "gpt-4o",
-                            system: ":prompt",
-                            prompt: "Please create a script using the information from the following URLs as reference: ${:sourceText.text}",
-                        },
-                    },
-                    validateMulmoScriptAgent: {
-                        agent: "validateMulmoScriptAgent",
-                        inputs: {
-                            text: ":openAIAgent.text.codeBlock()",
-                        },
-                        isResult: true,
-                    },
-                    continue: {
-                        agent: ({ isValid, counter }) => {
-                            return !isValid && counter < 3;
-                        },
-                        inputs: {
-                            isValid: ":validateMulmoScriptAgent.isValid",
-                            counter: ":counter",
-                        },
-                    },
-                },
-            },
-        },
-        writeJSON: {
-            if: ":mulmoScript.validateMulmoScriptAgent.isValid",
-            agent: "fileWriteAgent",
-            inputs: {
-                file: "${:outdir}/${:fileName}-${@now}.json",
-                text: ":mulmoScript.validateMulmoScriptAgent.data.toJSON()",
-            },
-            isResult: true,
-        },
-    },
-};
-export const createMulmoScriptFromUrl = async ({ urls, templateName, outDirPath, filename, cacheDirPath }) => {
-    mkdir(outDirPath);
-    mkdir(cacheDirPath);
-    const parsedUrls = urlsSchema.parse(urls);
-    const browserlessCache = browserlessCacheGenerator(cacheDirPath);
-    const agentFilters = [
-        {
-            name: "browserlessCache",
-            agent: browserlessCache,
-            nodeIds: ["fetcher"],
-        },
-    ];
-    const graph = new GraphAI(graphData, {
-        ...vanilla,
-        openAIAgent,
-        browserlessAgent,
-        validateMulmoScriptAgent,
-        fileWriteAgent,
-    }, { agentFilters });
-    graph.injectValue("urls", parsedUrls);
-    graph.injectValue("prompt", readTemplatePrompt(templateName));
-    graph.injectValue("outdir", outDirPath);
-    graph.injectValue("fileName", filename);
-    graph.registerCallback(cliLoadingPlugin({ nodeId: "mulmoScript", message: "Generating script..." }));
-    const result = await graph.run();
-    writingMessage(result?.writeJSON?.path ?? "");
-};

package/lib/utils/image_preprocess.d.ts

@@ -1,14 +0,0 @@
-import { MulmoStudioBeat, MulmoStudioContext, MulmoCanvasDimension } from "../types/index.js";
-type ImageProcessorParams = {
-    beat: MulmoStudioBeat;
-    context: MulmoStudioContext;
-    imagePath: string;
-    textSlideStyle: string;
-    canvasSize: MulmoCanvasDimension;
-};
-export declare const processTextSlide: (params: ImageProcessorParams) => Promise<void>;
-export declare const processMarkdown: (params: ImageProcessorParams) => Promise<void>;
-export declare const processImage: (params: ImageProcessorParams) => string | undefined;
-export declare const processChart: (params: ImageProcessorParams) => Promise<void>;
-export declare const processMermaid: (params: ImageProcessorParams) => Promise<void>;
-export {};

package/lib/utils/image_preprocess.js

@@ -1,52 +0,0 @@
-import { MulmoStudioContextMethods } from "../methods/index.js";
-import { getHTMLFile } from "./file.js";
-import { renderMarkdownToImage, renderHTMLToImage, interpolate } from "./markdown.js";
-export const processTextSlide = async (params) => {
-    const { beat, imagePath, textSlideStyle, canvasSize } = params;
-    if (!beat.image || beat.image.type !== "textSlide")
-        return;
-    const slide = beat.image.slide;
-    const markdown = `# ${slide.title}\n` + slide.bullets.map((text) => `- ${text}`).join("\n");
-    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
-};
-export const processMarkdown = async (params) => {
-    const { beat, imagePath, textSlideStyle, canvasSize } = params;
-    if (!beat.image || beat.image.type !== "markdown")
-        return;
-    const markdown = Array.isArray(beat.image.markdown) ? beat.image.markdown.join("\n") : beat.image.markdown;
-    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
-};
-export const processImage = (params) => {
-    const { beat, context } = params;
-    if (!beat.image || beat.image.type !== "image")
-        return;
-    if (beat.image.source.kind === "url") {
-        return beat.image.source.url;
-    }
-    else if (beat.image.source.kind === "path") {
-        return MulmoStudioContextMethods.resolveAssetPath(context, beat.image.source.path);
-    }
-};
-export const processChart = async (params) => {
-    const { beat, imagePath, canvasSize } = params;
-    if (!beat.image || beat.image.type !== "chart")
-        return;
-    const template = getHTMLFile("chart");
-    const htmlData = interpolate(template, {
-        title: beat.image.title,
-        width: Math.round(canvasSize.width * 0.625).toString(),
-        chart_data: JSON.stringify(beat.image.chartData),
-    });
-    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
-};
-export const processMermaid = async (params) => {
-    const { beat, imagePath, canvasSize } = params;
-    if (!beat.image || beat.image.type !== "mermaid")
-        return;
-    const template = getHTMLFile("mermaid");
-    const htmlData = interpolate(template, {
-        title: beat.image.title,
-        diagram_code: beat.image.code,
-    });
-    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
-};

package/lib/utils/text_hash.d.ts

@@ -1 +0,0 @@
-export declare const text2hash: (input: string) => string;

package/lib/utils/text_hash.js

@@ -1,4 +0,0 @@
-import * as crypto from "crypto";
-export const text2hash = (input) => {
-    return crypto.createHash("sha256").update(input).digest("hex");
-};