mulmocast 0.0.2 → 0.0.3

package/lib/actions/movie.js

@@ -2,56 +2,115 @@ import ffmpeg from "fluent-ffmpeg";
 import { GraphAILogger } from "graphai";
 import { MulmoScriptMethods } from "../methods/index.js";
 import { getAudioArtifactFilePath, getOutputVideoFilePath, writingMessage } from "../utils/file.js";
+const isMac = process.platform === "darwin";
+const videoCodec = isMac ? "h264_videotoolbox" : "libx264";
+export const getVideoPart = (inputIndex, mediaType, duration, canvasInfo) => {
+    const videoId = `v${inputIndex}`;
+    return {
+        videoId,
+        videoPart: `[${inputIndex}:v]` +
+            [
+                mediaType === "image" ? "loop=loop=-1:size=1:start=0" : "",
+                `trim=duration=${duration}`,
+                "fps=30",
+                "setpts=PTS-STARTPTS",
+                `scale=${canvasInfo.width}:${canvasInfo.height}`,
+                "setsar=1",
+                "format=yuv420p",
+            ]
+                .filter((a) => a)
+                .join(",") +
+            `[${videoId}]`,
+    };
+};
+export const getAudioPart = (inputIndex, duration, delay) => {
+    const audioId = `a${inputIndex}`;
+    return {
+        audioId,
+        audioPart: `[${inputIndex}:a]` +
+            `atrim=duration=${duration},` + // Trim to beat duration
+            `adelay=${delay}|${delay},` +
+            `aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo` +
+            `[${audioId}]`,
+    };
+};
+const getOutputOption = (audioId) => {
+    return [
+        "-preset veryfast", // Faster encoding
+        "-map [v]", // Map the video stream
+        `-map ${audioId}`, // Map the audio stream
+        `-c:v ${videoCodec}`, // Set video codec
+        "-threads 8",
+        "-filter_threads 8",
+        "-b:v 5M", // bitrate (only for videotoolbox)
+        "-bufsize",
+        "10M", // Add buffer size for better quality
+        "-maxrate",
+        "7M", // Maximum bitrate
+        "-r 30", // Set frame rate
+        "-pix_fmt yuv420p", // Set pixel format for better compatibility
+    ];
+};
 const createVideo = (audioArtifactFilePath, outputVideoPath, studio) => {
     return new Promise((resolve, reject) => {
         const start = performance.now();
-        let command = ffmpeg();
+        const ffmpegContext = {
+            command: ffmpeg(),
+            inputCount: 0,
+        };
+        function addInput(input) {
+            ffmpegContext.command = ffmpegContext.command.input(input);
+            ffmpegContext.inputCount++;
+            return ffmpegContext.inputCount - 1; // returned the index of the input
+        }
         if (studio.beats.some((beat) => !beat.imageFile)) {
             GraphAILogger.info("beat.imageFile is not set. Please run `yarn run images ${file}` ");
             return;
         }
-        // Add each image input
-        studio.beats.forEach((beat) => {
-            command = command.input(beat.imageFile); // HACK
-        });
-        const imageCount = studio.beats.length;
         const canvasInfo = MulmoScriptMethods.getCanvasSize(studio.script);
+        const padding = MulmoScriptMethods.getPadding(studio.script) / 1000;
+        // Add each image input
         const filterComplexParts = [];
-        studio.beats.forEach((beat, index) => {
-            // Resize background image to match canvas dimensions
-            const duration = beat.duration + (index === 0 ? MulmoScriptMethods.getPadding(studio.script) / 1000 : 0);
-            const parts = `[${index}:v]loop=loop=-1:size=1:start=0,` +
-                `trim=duration=${duration},` +
-                `fps=30,` +
-                `setpts=PTS-STARTPTS,` +
-                `scale=${canvasInfo.width}:${canvasInfo.height},` +
-                `setsar=1,format=yuv420p` +
-                `[v${index}]`;
-            // console.log(parts);
-            filterComplexParts.push(parts);
-        });
+        const filterComplexVideoIds = [];
+        const filterComplexAudioIds = [];
+        studio.beats.reduce((timestamp, beat, index) => {
+            if (!beat.imageFile || !beat.duration) {
+                throw new Error(`beat.imageFile is not set: index=${index}`);
+            }
+            const inputIndex = addInput(beat.imageFile);
+            const mediaType = MulmoScriptMethods.getImageType(studio.script, studio.script.beats[index]);
+            const headOrTail = index === 0 || index === studio.beats.length - 1;
+            const duration = beat.duration + (headOrTail ? padding : 0);
+            const { videoId, videoPart } = getVideoPart(inputIndex, mediaType, duration, canvasInfo);
+            filterComplexVideoIds.push(videoId);
+            filterComplexParts.push(videoPart);
+            if (mediaType === "movie") {
+                const { audioId, audioPart } = getAudioPart(inputIndex, duration, timestamp * 1000);
+                filterComplexAudioIds.push(audioId);
+                filterComplexParts.push(audioPart);
+            }
+            return timestamp + duration;
+        }, 0);
+        // console.log("*** images", images.audioIds);
         // Concatenate the trimmed images
-        const concatInput = studio.beats.map((_, index) => `[v${index}]`).join("");
-        filterComplexParts.push(`${concatInput}concat=n=${imageCount}:v=1:a=0[v]`);
+        filterComplexParts.push(`${filterComplexVideoIds.map((id) => `[${id}]`).join("")}concat=n=${studio.beats.length}:v=1:a=0[v]`);
+        const audioIndex = addInput(audioArtifactFilePath); // Add audio input
+        const artifactAudioId = `${audioIndex}:a`;
+        const ffmpegContextAudioId = (() => {
+            if (filterComplexAudioIds.length > 0) {
+                const mainAudioId = "mainaudio";
+                const compositeAudioId = "composite";
+                const audioIds = filterComplexAudioIds.map((id) => `[${id}]`).join("");
+                filterComplexParts.push(`[${artifactAudioId}]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo[${mainAudioId}]`);
+                filterComplexParts.push(`[${mainAudioId}]${audioIds}amix=inputs=${filterComplexAudioIds.length + 1}:duration=first:dropout_transition=2[${compositeAudioId}]`);
+                return `[${compositeAudioId}]`; // notice that we need to use [mainaudio] instead of mainaudio
+            }
+            return artifactAudioId;
+        })();
         // Apply the filter complex for concatenation and map audio input
-        command
+        ffmpegContext.command
             .complexFilter(filterComplexParts)
-            .input(audioArtifactFilePath) // Add audio input
-            .outputOptions([
-            "-preset veryfast", // Faster encoding
-            "-map [v]", // Map the video stream
-            `-map ${imageCount /* + captionCount*/}:a`, // Map the audio stream (audio is the next input after all images)
-            "-c:v h264_videotoolbox", // Set video codec
-            "-threads 8",
-            "-filter_threads 8",
-            "-b:v 5M", // bitrate (only for videotoolbox)
-            "-bufsize",
-            "10M", // Add buffer size for better quality
-            "-maxrate",
-            "7M", // Maximum bitrate
-            "-r 30", // Set frame rate
-            "-pix_fmt yuv420p", // Set pixel format for better compatibility
-        ])
+            .outputOptions(getOutputOption(ffmpegContextAudioId))
             .on("start", (__cmdLine) => {
             GraphAILogger.log("Started FFmpeg ..."); // with command:', cmdLine);
         })

package/lib/actions/pdf.d.ts

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

package/lib/actions/pdf.js

@@ -0,0 +1,211 @@
+import fs from "fs";
+import path from "path";
+import { rgb, PDFDocument } from "pdf-lib";
+import fontkit from "@pdf-lib/fontkit";
+import { chunkArray, isHttp } from "../utils/utils.js";
+import { getOutputPdfFilePath, writingMessage } from "../utils/file.js";
+import { MulmoScriptMethods } from "../methods/index.js";
+import { fontSize, textMargin, drawSize, wrapText } from "../utils/pdf.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, font) => {
+    const imageRatio = 0.7;
+    const textMargin = 8;
+    const textY = pageHeight * (1 - imageRatio) - textMargin;
+    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,
+        });
+        const lines = wrapText(text, font, fontSize, pageWidth - textMargin * 2);
+        for (const [index, line] of lines.entries()) {
+            page.drawText(line, {
+                x: textMargin,
+                y: textY - fontSize - (fontSize + 2) * index,
+                size: fontSize,
+                color: rgb(0, 0, 0),
+                maxWidth: pageWidth - 2 * textMargin,
+                font,
+            });
+        }
+    }
+};
+const pdfHandout = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font, isLandscapeImage) => {
+    const cellRatio = (pageHeight / imagesPerPage - offset) / (pageWidth * handoutImageRatio - offset);
+    let index = 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;
+            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);
+            if (isLandscapeImage) {
+                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
+                for (const [index, line] of lines.entries()) {
+                    page.drawText(line, {
+                        ...pos,
+                        x: pos.x + pos.width + textMargin,
+                        y: pos.y + pos.height - fontSize - (fontSize + 2) * index,
+                        size: fontSize,
+                        font,
+                    });
+                }
+                /*
+                page.drawRectangle({
+                  ...pos,
+                  x: pos.x +  pos.width ,
+                  borderColor: rgb(0, 0, 0),
+                  borderWidth: 1,
+                  });
+                */
+            }
+            else {
+                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
+                for (const [index, line] of lines.entries()) {
+                    page.drawText(line, {
+                        ...pos,
+                        x: pos.x,
+                        y: textMargin + pos.height - fontSize - (fontSize + textMargin) * index - 2 * textMargin,
+                        size: fontSize,
+                        font,
+                    });
+                }
+                /*
+                page.drawRectangle({
+                  ...pos,
+                  x: pos.x,
+                  y: textMargin,
+                  height: pos.height - 2 * textMargin,
+                  borderColor: rgb(0, 0, 0),
+                  borderWidth: 1,
+                });
+                */
+            }
+            index = index + 1;
+        }
+    }
+};
+const outputSize = (pdfSize, isLandscapeImage, isRotate) => {
+    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();
+    pdfDoc.registerFontkit(fontkit);
+    const fontBytes = fs.readFileSync("assets/font/NotoSansJP-Regular.ttf");
+    const customFont = await pdfDoc.embedFont(fontBytes);
+    if (pdfMode === "handout") {
+        await pdfHandout(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont, isLandscapeImage);
+    }
+    if (pdfMode === "slide") {
+        await pdfSlide(pageWidth, pageHeight, imagePaths, pdfDoc);
+    }
+    if (pdfMode === "talk") {
+        await pdfTalk(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont);
+    }
+    const pdfBytes = await pdfDoc.save();
+    fs.writeFileSync(outputPdfPath, pdfBytes);
+    writingMessage(outputPdfPath);
+};

package/lib/actions/pdf2.d.ts

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

@@ -0,0 +1,203 @@
+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/actions/translate.js

@@ -32,7 +32,8 @@ const translateGraph = {
             agent: "mapAgent",
             inputs: {
                 targetLangs: ":targetLangs",
-                rows: ":studio.beats",
+                studio: ":studio",
+                rows: ":studio.script.beats",
                 lang: ":lang",
             },
             params: {
@@ -42,12 +43,23 @@ const translateGraph = {
             graph: {
                 version: 0.5,
                 nodes: {
+                    studioBeat: {
+                        agent: (namedInputs) => {
+                            return namedInputs.rows[namedInputs.index];
+                        },
+                        inputs: {
+                            index: ":__mapIndex",
+                            rows: ":studio.beats",
+                        },
+                    },
                     preprocessBeats: {
                         agent: "mapAgent",
                         inputs: {
                             beat: ":beat",
+                            studioBeat: ":studioBeat",
                             rows: ":targetLangs",
                             lang: ":lang.text",
+                            studio: ":studio",
                         },
                         params: {
                             compositeResult: true,
@@ -60,6 +72,7 @@ const translateGraph = {
                                     inputs: {
                                         targetLang: ":targetLang",
                                         beat: ":beat",
+                                        studioBeat: ":studioBeat",
                                         lang: ":lang",
                                         system: "Please translate the given text into the language specified in language (in locale format, like en, ja, fr, ch).",
                                         prompt: ["## Original Language", ":lang", "", "## Language", ":targetLang", "", "## Target", ":beat.text"],
@@ -138,7 +151,7 @@ const translateGraph = {
                         isResult: true,
                         agent: "mergeObjectAgent",
                         inputs: {
-                            items: [":beat", { multiLingualTexts: ":mergeLocalizedText" }],
+                            items: [":studioBeat", { multiLingualTexts: ":mergeLocalizedText" }],
                         },
                     },
                 },
@@ -156,14 +169,14 @@ const translateGraph = {
 };
 const localizedTextCacheAgentFilter = async (context, next) => {
     const { namedInputs } = context;
-    const { targetLang, beat, lang } = namedInputs;
+    const { targetLang, beat, lang, studioBeat } = namedInputs;
     // The original text is unchanged and the target language text is present
-    if (beat.multiLingualTexts &&
-        beat.multiLingualTexts[lang] &&
-        beat.multiLingualTexts[lang].text === beat.text &&
-        beat.multiLingualTexts[targetLang] &&
-        beat.multiLingualTexts[targetLang].text) {
-        return { text: beat.multiLingualTexts[targetLang].text };
+    if (studioBeat.multiLingualTexts &&
+        studioBeat.multiLingualTexts[lang] &&
+        studioBeat.multiLingualTexts[lang].text === beat.text &&
+        studioBeat.multiLingualTexts[targetLang] &&
+        studioBeat.multiLingualTexts[targetLang].text) {
+        return { text: studioBeat.multiLingualTexts[targetLang].text };
     }
     // same language
     if (targetLang === lang) {

package/lib/agents/anthropic_agent.d.ts

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