mulmocast 0.0.5 → 0.0.6

package/lib/tools/story_to_script.js

@@ -0,0 +1,201 @@
+import path from "path";
+import { getTemplateFilePath, writingMessage } from "../utils/file.js";
+import { mulmoScriptSchema, mulmoScriptTemplateSchema } from "../types/schema.js";
+import { GraphAI, GraphAILogger } from "graphai";
+import { openAIAgent } from "@graphai/openai_agent";
+import { anthropicAgent } from "@graphai/anthropic_agent";
+import { geminiAgent } from "@graphai/gemini_agent";
+import { groqAgent } from "@graphai/groq_agent";
+import * as agents from "@graphai/vanilla";
+import { graphDataScriptGeneratePrompt, sceneToBeatsPrompt, storyToScriptInfoPrompt } from "../utils/prompt.js";
+import { fileWriteAgent } from "@graphai/vanilla_node_agents";
+import validateSchemaAgent from "../agents/validate_schema_agent.js";
+import { llmPair } from "../utils/utils.js";
+const { default: __, ...vanillaAgents } = agents;
+const createValidatedScriptGraphData = ({ systemPrompt, prompt, schema, llmAgent, llmModel, maxTokens, }) => {
+    return {
+        loop: {
+            while: ":continue",
+        },
+        nodes: {
+            counter: {
+                value: 0,
+                update: ":counter.add(1)",
+            },
+            llm: {
+                agent: llmAgent,
+                inputs: {
+                    model: llmModel,
+                    system: systemPrompt,
+                    prompt: prompt,
+                    max_tokens: maxTokens,
+                },
+            },
+            validateSchema: {
+                agent: "validateSchemaAgent",
+                inputs: {
+                    text: ":llm.text.codeBlock()",
+                    schema: schema,
+                },
+                isResult: true,
+            },
+            continue: {
+                agent: ({ isValid, counter }) => {
+                    if (counter >= 3) {
+                        GraphAILogger.info("Failed to generate a valid script. Please try again.");
+                        process.exit(1);
+                    }
+                    return !isValid;
+                },
+                inputs: {
+                    counter: ":counter",
+                    isValid: ":validateSchema.isValid",
+                },
+            },
+        },
+    };
+};
+const graphData = {
+    version: 0.5,
+    nodes: {
+        scenes: {
+            value: [],
+        },
+        beatsPrompt: {
+            value: "",
+        },
+        scriptInfoPrompt: {
+            value: "",
+        },
+        outdir: {
+            value: "",
+        },
+        fileName: {
+            value: "",
+        },
+        llmAgent: {
+            value: "",
+        },
+        llmModel: {
+            value: "",
+        },
+        maxTokens: {
+            value: 0,
+        },
+        script: {
+            agent: "mapAgent",
+            inputs: {
+                rows: ":scenes",
+                prompt: ":beatsPrompt",
+                llmAgent: ":llmAgent",
+                llmModel: ":llmModel",
+                maxTokens: ":maxTokens",
+            },
+            params: {
+                compositeResult: true,
+            },
+            graph: {
+                nodes: {
+                    script: {
+                        agent: "nestedAgent",
+                        inputs: {
+                            prompt: ":prompt",
+                            row: ":row",
+                            llmAgent: ":llmAgent",
+                            llmModel: ":llmModel",
+                            maxTokens: ":maxTokens",
+                        },
+                        graph: createValidatedScriptGraphData({
+                            systemPrompt: ":prompt",
+                            prompt: graphDataScriptGeneratePrompt("${:row}"),
+                            schema: mulmoScriptSchema.shape.beats,
+                            llmAgent: ":llmAgent",
+                            llmModel: ":llmModel",
+                            maxTokens: ":maxTokens",
+                        }),
+                    },
+                    json: {
+                        agent: "copyAgent",
+                        inputs: {
+                            json: ":script.validateSchema.data",
+                        },
+                        params: {
+                            namedKey: "json",
+                        },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+        beats: {
+            agent: "arrayFlatAgent",
+            inputs: {
+                array: ":script.json",
+            },
+            isResult: true,
+        },
+        scriptInfo: {
+            agent: "nestedAgent",
+            inputs: {
+                prompt: ":scriptInfoPrompt",
+                llmAgent: ":llmAgent",
+                llmModel: ":llmModel",
+                maxTokens: ":maxTokens",
+            },
+            graph: createValidatedScriptGraphData({
+                systemPrompt: "",
+                prompt: ":prompt",
+                schema: mulmoScriptSchema.omit({ beats: true }),
+                llmAgent: ":llmAgent",
+                llmModel: ":llmModel",
+                maxTokens: ":maxTokens",
+            }),
+        },
+        mergedScript: {
+            agent: "mergeObjectAgent",
+            inputs: {
+                items: [":scriptInfo.validateSchema.data", { beats: ":beats.array" }],
+            },
+        },
+        writeJSON: {
+            agent: "fileWriteAgent",
+            inputs: {
+                file: "${:outdir}/${:fileName}-${@now}.json",
+                text: ":mergedScript.toJSON()",
+            },
+            isResult: true,
+        },
+    },
+};
+const generateBeatsPrompt = async (template, beatsPerScene, story) => {
+    const allScenes = story.scenes.map((scene) => scene.description).join("\n");
+    const sampleBeats = template.script?.beats ?? [];
+    return sceneToBeatsPrompt({ sampleBeats, beatsPerScene, allScenes });
+};
+const generateScriptInfoPrompt = async (template, story) => {
+    if (!template.script) {
+        // TODO: use default schema
+        throw new Error("script is not provided");
+    }
+    const { beats: __, ...sampleScriptWithoutBeats } = template.script;
+    return storyToScriptInfoPrompt(sampleScriptWithoutBeats, story);
+};
+export const storyToScript = async ({ story, beatsPerScene, templateName, outdir, fileName, llmAgent, llmModel, }) => {
+    const templatePath = getTemplateFilePath(templateName);
+    const rowTemplate = await import(path.resolve(templatePath), { assert: { type: "json" } }).then((mod) => mod.default);
+    const template = mulmoScriptTemplateSchema.parse(rowTemplate);
+    const { agent, model, max_tokens } = llmPair(llmAgent, llmModel);
+    const beatsPrompt = await generateBeatsPrompt(template, beatsPerScene, story);
+    const scriptInfoPrompt = await generateScriptInfoPrompt(template, story);
+    const graph = new GraphAI(graphData, { ...vanillaAgents, openAIAgent, anthropicAgent, geminiAgent, groqAgent, fileWriteAgent, validateSchemaAgent });
+    graph.injectValue("beatsPrompt", beatsPrompt);
+    graph.injectValue("scriptInfoPrompt", scriptInfoPrompt);
+    graph.injectValue("scenes", story.scenes);
+    graph.injectValue("outdir", outdir);
+    graph.injectValue("fileName", fileName);
+    graph.injectValue("llmAgent", agent);
+    graph.injectValue("llmModel", model);
+    graph.injectValue("maxTokens", max_tokens);
+    const result = await graph.run();
+    writingMessage(result?.writeJSON?.path ?? "");
+};

package/lib/types/cli_types.d.ts

@@ -0,0 +1,14 @@
+import { Arguments } from "yargs";
+export type ToolGlobalOptions = {
+    v?: boolean;
+};
+export type ToolCliArgs<T = object> = Arguments<T & ToolGlobalOptions>;
+export type GlobalOptions = {
+    v?: boolean;
+    o?: string;
+    b?: string;
+    l?: string;
+    f?: boolean;
+    file?: string;
+};
+export type CliArgs<T = object> = Arguments<T & GlobalOptions>;

package/lib/types/cli_types.js

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