mulmocast 2.0.6 → 2.0.7

package/lib/agents/image_genai_agent.js

@@ -1,18 +1,11 @@
 import fs from "fs";
 import { GraphAILogger } from "graphai";
 import { provider2ImageAgent } from "../utils/provider2agent.js";
-import { apiKeyMissingError, agentGenerationError, agentInvalidResponseError, imageAction, imageFileTarget, hasCause } from "../utils/error_cause.js";
+import { apiKeyMissingError, agentIncorrectAPIKeyError, agentGenerationError, agentInvalidResponseError, imageAction, imageFileTarget, hasCause, getGenAIErrorReason, resultify, } from "../utils/error_cause.js";
+import { getAspectRatio } from "../utils/utils.js";
+import { ASPECT_RATIOS } from "../utils/const.js";
 import { GoogleGenAI, PersonGeneration } from "@google/genai";
 import { blankImagePath, blankSquareImagePath, blankVerticalImagePath } from "../utils/file.js";
-const getAspectRatio = (canvasSize) => {
-    if (canvasSize.width > canvasSize.height) {
-        return "16:9";
-    }
-    else if (canvasSize.width < canvasSize.height) {
-        return "9:16";
-    }
-    return "1:1";
-};
 export const ratio2BlankPath = (aspectRatio) => {
     if (aspectRatio === "9:16") {
         return blankVerticalImagePath();
@@ -61,9 +54,24 @@ const geminiFlashResult = (response) => {
         cause: agentInvalidResponseError("imageGenAIAgent", imageAction, imageFileTarget),
     });
 };
+const errorProcess = (error) => {
+    GraphAILogger.info("Failed to generate image:", error);
+    if (hasCause(error) && error.cause) {
+        throw error;
+    }
+    const reasonDetail = getGenAIErrorReason(error);
+    if (reasonDetail && reasonDetail.reason && reasonDetail.reason === "API_KEY_INVALID") {
+        throw new Error("Failed to generate image: 400 Incorrect API key provided with gemini", {
+            cause: agentIncorrectAPIKeyError("imageGenAIAgent", imageAction, imageFileTarget),
+        });
+    }
+    throw new Error("Failed to generate image with Google GenAI", {
+        cause: agentGenerationError("imageGenAIAgent", imageAction, imageFileTarget),
+    });
+};
 export const imageGenAIAgent = async ({ namedInputs, params, config, }) => {
     const { prompt, referenceImages } = namedInputs;
-    const aspectRatio = getAspectRatio(params.canvasSize);
+    const aspectRatio = getAspectRatio(params.canvasSize, ASPECT_RATIOS);
     const model = params.model ?? provider2ImageAgent["google"].defaultModel;
     const apiKey = config?.apiKey;
     if (!apiKey) {
@@ -71,61 +79,60 @@ export const imageGenAIAgent = async ({ namedInputs, params, config, }) => {
             cause: apiKeyMissingError("imageGenAIAgent", imageAction, "GEMINI_API_KEY"),
         });
     }
-    try {
-        const ai = new GoogleGenAI({ apiKey });
-        if (model === "gemini-2.5-flash-image") {
-            const contents = getGeminiContents(prompt, referenceImages, aspectRatio);
-            const response = await ai.models.generateContent({ model, contents });
-            return geminiFlashResult(response);
-        }
-        else if (model === "gemini-3-pro-image-preview") {
+    const ai = new GoogleGenAI({ apiKey });
+    if (model === "gemini-2.5-flash-image" || model === "gemini-3-pro-image-preview") {
+        const contentParams = (() => {
+            if (model === "gemini-2.5-flash-image") {
+                const contents = getGeminiContents(prompt, referenceImages, aspectRatio);
+                return { model, contents };
+            }
+            // gemini-3-pro-image-preview
             const contents = getGeminiContents(prompt, referenceImages);
-            const response = await ai.models.generateContent({
+            const PRO_ASPECT_RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
+            return {
                 model,
                 contents,
                 config: {
                     imageConfig: {
-                        // '1:1', '2:3', '3:2', '3:4', '4:3', '4:5', '5:4', '9:16', '16:9', or '21:9'.
-                        aspectRatio,
+                        aspectRatio: getAspectRatio(params.canvasSize, PRO_ASPECT_RATIOS),
                     },
                 },
-            });
-            return geminiFlashResult(response);
-        }
-        else {
-            const response = await ai.models.generateImages({
-                model,
-                prompt,
-                config: {
-                    numberOfImages: 1, // default is 4!
-                    aspectRatio,
-                    personGeneration: PersonGeneration.ALLOW_ALL,
-                    // safetyFilterLevel: SafetyFilterLevel.BLOCK_ONLY_HIGH,
-                },
-            });
-            if (!response.generatedImages || response.generatedImages.length === 0) {
-                throw new Error("ERROR: generateImage returned no generated images", {
-                    cause: agentInvalidResponseError("imageGenAIAgent", imageAction, imageFileTarget),
-                });
-            }
-            const image = response.generatedImages[0].image;
-            if (image && image.imageBytes) {
-                return { buffer: Buffer.from(image.imageBytes, "base64") };
-            }
-            throw new Error("ERROR: generateImage returned no image bytes", {
-                cause: agentInvalidResponseError("imageGenAIAgent", imageAction, imageFileTarget),
-            });
+            };
+        })();
+        const res = await resultify(() => ai.models.generateContent(contentParams));
+        if (res.ok) {
+            return geminiFlashResult(res.value);
         }
+        return errorProcess(res.error);
     }
-    catch (error) {
-        GraphAILogger.info("Failed to generate image:", error);
-        if (hasCause(error) && error.cause) {
-            throw error;
-        }
-        throw new Error("Failed to generate image with Google GenAI", {
-            cause: agentGenerationError("imageGenAIAgent", imageAction, imageFileTarget),
+    // other case,
+    const generateParams = {
+        model,
+        prompt,
+        config: {
+            numberOfImages: 1, // default is 4!
+            aspectRatio,
+            personGeneration: PersonGeneration.ALLOW_ALL,
+            // safetyFilterLevel: SafetyFilterLevel.BLOCK_ONLY_HIGH,
+        },
+    };
+    const res = await resultify(() => ai.models.generateImages(generateParams));
+    if (!res.ok) {
+        return errorProcess(res.error);
+    }
+    const response = res.value;
+    if (!response.generatedImages || response.generatedImages.length === 0) {
+        throw new Error("ERROR: generateImage returned no generated images", {
+            cause: agentInvalidResponseError("imageGenAIAgent", imageAction, imageFileTarget),
         });
     }
+    const image = response.generatedImages[0].image;
+    if (image && image.imageBytes) {
+        return { buffer: Buffer.from(image.imageBytes, "base64") };
+    }
+    throw new Error("ERROR: generateImage returned no image bytes", {
+        cause: agentInvalidResponseError("imageGenAIAgent", imageAction, imageFileTarget),
+    });
 };
 const imageGenAIAgentInfo = {
     name: "imageGenAIAgent",
@@ -136,7 +143,6 @@ const imageGenAIAgentInfo = {
     category: ["image"],
     author: "Receptron Team",
     repository: "https://github.com/receptron/mulmocast-cli/",
-    // source: "https://github.com/receptron/mulmocast-cli/blob/main/src/agents/image_google_agent.ts",
     license: "MIT",
     environmentVariables: [],
 };

package/lib/agents/image_replicate_agent.js

@@ -2,7 +2,7 @@ import { readFileSync } from "fs";
 import { GraphAILogger } from "graphai";
 import Replicate from "replicate";
 import { getAspectRatio } from "./movie_replicate_agent.js";
-import { apiKeyMissingError, agentGenerationError, agentInvalidResponseError, imageAction, imageFileTarget, hasCause } from "../utils/error_cause.js";
+import { apiKeyMissingError, agentIncorrectAPIKeyError, agentGenerationError, agentInvalidResponseError, imageAction, imageFileTarget, hasCause, } from "../utils/error_cause.js";
 import { provider2ImageAgent } from "../utils/provider2agent.js";
 export const imageReplicateAgent = async ({ namedInputs, params, config, }) => {
     const { prompt, referenceImages } = namedInputs;
@@ -51,6 +51,14 @@ export const imageReplicateAgent = async ({ namedInputs, params, config, }) => {
         if (hasCause(error) && error.cause) {
             throw error;
         }
+        if (typeof error === "object" && error !== null && "response" in error) {
+            const errorWithResponse = error;
+            if (errorWithResponse.response?.status === 401) {
+                throw new Error("Failed to generate image: 401 Incorrect API key provided with replicate", {
+                    cause: agentIncorrectAPIKeyError("imageGenAIAgent", imageAction, imageFileTarget),
+                });
+            }
+        }
         throw new Error("Failed to generate image with Replicate", {
             cause: agentGenerationError("imageReplicateAgent", imageAction, imageFileTarget),
         });

package/lib/agents/movie_genai_agent.d.ts

@@ -1,9 +1,5 @@
 import type { AgentFunction, AgentFunctionInfo } from "graphai";
 import type { AgentBufferResult, GenAIImageAgentConfig, GoogleMovieAgentParams, MovieAgentInputs } from "../types/agent.js";
-export declare const getAspectRatio: (canvasSize: {
-    width: number;
-    height: number;
-}) => string;
 export declare const movieGenAIAgent: AgentFunction<GoogleMovieAgentParams, AgentBufferResult, MovieAgentInputs, GenAIImageAgentConfig>;
 declare const movieGenAIAgentInfo: AgentFunctionInfo;
 export default movieGenAIAgentInfo;

package/lib/agents/movie_genai_agent.js

@@ -2,18 +2,9 @@ import { readFileSync } from "fs";
 import { GraphAILogger, sleep } from "graphai";
 import { GoogleGenAI, PersonGeneration } from "@google/genai";
 import { apiKeyMissingError, agentGenerationError, agentInvalidResponseError, imageAction, movieFileTarget, videoDurationTarget, hasCause, } from "../utils/error_cause.js";
+import { getAspectRatio } from "../utils/utils.js";
+import { ASPECT_RATIOS } from "../utils/const.js";
 import { getModelDuration, provider2MovieAgent } from "../utils/provider2agent.js";
-export const getAspectRatio = (canvasSize) => {
-    if (canvasSize.width > canvasSize.height) {
-        return "16:9";
-    }
-    else if (canvasSize.width < canvasSize.height) {
-        return "9:16";
-    }
-    else {
-        return "1:1";
-    }
-};
 const pollUntilDone = async (ai, operation) => {
     const response = { operation };
     while (!response.operation.done) {
@@ -115,7 +106,7 @@ const generateStandardVideo = async (ai, model, prompt, aspectRatio, imagePath,
 };
 export const movieGenAIAgent = async ({ namedInputs, params, config, }) => {
     const { prompt, imagePath, movieFile } = namedInputs;
-    const aspectRatio = getAspectRatio(params.canvasSize);
+    const aspectRatio = getAspectRatio(params.canvasSize, ASPECT_RATIOS);
     const model = params.model ?? provider2MovieAgent.google.defaultModel;
     const apiKey = config?.apiKey;
     if (!apiKey) {

package/lib/agents/test.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/lib/agents/test.js

@@ -0,0 +1,12 @@
+import "dotenv/config";
+import { ttsKotodamaAgent } from "./tts_kotodama_agent.js";
+const kotodamaApiKey = process.env.KOTODAMA_API_KEY ?? "";
+const main = async () => {
+    const result = await ttsKotodamaAgent({
+        namedInputs: { text: "こんにちは" },
+        params: { voice: "Atla", decoration: "neutral", suppressError: false },
+        config: { apiKey: kotodamaApiKey },
+    });
+    console.log("Result:", result);
+};
+main();

package/lib/agents/tts_elevenlabs_agent.js

@@ -1,6 +1,6 @@
 import { GraphAILogger } from "graphai";
 import { provider2TTSAgent } from "../utils/provider2agent.js";
-import { apiKeyMissingError, agentGenerationError, audioAction, audioFileTarget } from "../utils/error_cause.js";
+import { apiKeyMissingError, agentIncorrectAPIKeyError, agentGenerationError, audioAction, audioFileTarget } from "../utils/error_cause.js";
 export const ttsElevenlabsAgent = async ({ namedInputs, params, config, }) => {
     const { text } = namedInputs;
     const { voice, model, stability, similarityBoost, suppressError } = params;
@@ -15,45 +15,55 @@ export const ttsElevenlabsAgent = async ({ namedInputs, params, config, }) => {
             cause: agentGenerationError("ttsElevenlabsAgent", audioAction, audioFileTarget),
         });
     }
-    try {
-        const requestBody = {
-            text,
-            model_id: model ?? provider2TTSAgent.elevenlabs.defaultModel,
-            voice_settings: {
-                stability: stability ?? 0.5,
-                similarity_boost: similarityBoost ?? 0.75,
-            },
-        };
-        GraphAILogger.log("ElevenLabs TTS options", requestBody);
-        const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voice}`, {
-            method: "POST",
-            headers: {
-                Accept: "audio/mpeg",
-                "Content-Type": "application/json",
-                "xi-api-key": apiKey,
-            },
-            body: JSON.stringify(requestBody),
-        });
-        if (!response.ok) {
-            throw new Error(`Eleven Labs API error: ${response.status} ${response.statusText}`, {
+    const requestBody = {
+        text,
+        model_id: model ?? provider2TTSAgent.elevenlabs.defaultModel,
+        voice_settings: {
+            stability: stability ?? 0.5,
+            similarity_boost: similarityBoost ?? 0.75,
+        },
+    };
+    GraphAILogger.log("ElevenLabs TTS options", requestBody);
+    const response = await (async () => {
+        try {
+            return await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voice}`, {
+                method: "POST",
+                headers: {
+                    Accept: "audio/mpeg",
+                    "Content-Type": "application/json",
+                    "xi-api-key": apiKey,
+                },
+                body: JSON.stringify(requestBody),
+            });
+        }
+        catch (e) {
+            if (suppressError) {
+                return {
+                    error: e,
+                };
+            }
+            GraphAILogger.info(e);
+            throw new Error("TTS Eleven Labs Error", {
                 cause: agentGenerationError("ttsElevenlabsAgent", audioAction, audioFileTarget),
             });
         }
-        const arrayBuffer = await response.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        return { buffer };
+    })();
+    if ("error" in response) {
+        return response;
     }
-    catch (e) {
-        if (suppressError) {
-            return {
-                error: e,
-            };
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("Failed to generate audio: 401 Incorrect API key provided with ElevenLabs", {
+                cause: agentIncorrectAPIKeyError("ttsElevenlabsAgent", audioAction, audioFileTarget),
+            });
         }
-        GraphAILogger.info(e);
-        throw new Error("TTS Eleven Labs Error", {
+        throw new Error(`Eleven Labs API error: ${response.status} ${response.statusText}`, {
             cause: agentGenerationError("ttsElevenlabsAgent", audioAction, audioFileTarget),
         });
     }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    return { buffer };
 };
 const ttsElevenlabsAgentInfo = {
     name: "ttsElevenlabsAgent",

package/lib/agents/tts_gemini_agent.js

@@ -1,7 +1,7 @@
 import { GraphAILogger } from "graphai";
 import { GoogleGenAI } from "@google/genai";
 import { provider2TTSAgent } from "../utils/provider2agent.js";
-import { apiKeyMissingError, agentGenerationError, audioAction, audioFileTarget } from "../utils/error_cause.js";
+import { agentIncorrectAPIKeyError, apiKeyMissingError, agentGenerationError, audioAction, audioFileTarget, getGenAIErrorReason, } from "../utils/error_cause.js";
 import { pcmToMp3 } from "../utils/ffmpeg_utils.js";
 export const ttsGeminiAgent = async ({ namedInputs, params, config, }) => {
     const { text } = namedInputs;
@@ -29,7 +29,7 @@ export const ttsGeminiAgent = async ({ namedInputs, params, config, }) => {
         const inlineData = response.candidates?.[0]?.content?.parts?.[0]?.inlineData;
         const pcmBase64 = inlineData?.data;
         const mimeType = inlineData?.mimeType;
-        if (!pcmBase64)
+        if (!pcmBase64 || typeof pcmBase64 !== "string")
             throw new Error("No audio data returned");
         // Extract sample rate from mimeType (e.g., "audio/L16;codec=pcm;rate=24000")
         const rateMatch = mimeType?.match(/rate=(\d+)/);
@@ -44,6 +44,12 @@ export const ttsGeminiAgent = async ({ namedInputs, params, config, }) => {
             };
         }
         GraphAILogger.info(e);
+        const reasonDetail = getGenAIErrorReason(e);
+        if (reasonDetail && reasonDetail.reason && reasonDetail.reason === "API_KEY_INVALID") {
+            throw new Error("Failed to generate tts: 400 Incorrect API key provided with gemini", {
+                cause: agentIncorrectAPIKeyError("ttsGeminiAgent", audioAction, audioFileTarget),
+            });
+        }
         throw new Error("TTS Gemini Error", {
             cause: agentGenerationError("ttsGeminiAgent", audioAction, audioFileTarget),
         });

package/lib/agents/tts_kotodama_agent.d.ts

@@ -0,0 +1,5 @@
+import type { AgentFunction, AgentFunctionInfo } from "graphai";
+import type { KotodamaTTSAgentParams, AgentBufferResult, AgentTextInputs, AgentErrorResult, AgentConfig } from "../types/agent.js";
+export declare const ttsKotodamaAgent: AgentFunction<KotodamaTTSAgentParams, AgentBufferResult | AgentErrorResult, AgentTextInputs, AgentConfig>;
+declare const ttsKotodamaAgentInfo: AgentFunctionInfo;
+export default ttsKotodamaAgentInfo;

package/lib/agents/tts_kotodama_agent.js

@@ -0,0 +1,76 @@
+import { GraphAILogger } from "graphai";
+import { provider2TTSAgent } from "../utils/provider2agent.js";
+import { apiKeyMissingError, agentIncorrectAPIKeyError, agentGenerationError, audioAction, audioFileTarget } from "../utils/error_cause.js";
+export const ttsKotodamaAgent = async ({ namedInputs, params, config, }) => {
+    const { text } = namedInputs;
+    const { voice, decoration, suppressError } = params;
+    const { apiKey } = config ?? {};
+    if (!apiKey) {
+        throw new Error("Kotodama API key is required (KOTODAMA_API_KEY)", {
+            cause: apiKeyMissingError("ttsKotodamaAgent", audioAction, "KOTODAMA_API_KEY"),
+        });
+    }
+    const url = "https://tts3.spiral-ai-app.com/api/tts_generate";
+    const body = {
+        text,
+        speaker_id: voice ?? provider2TTSAgent.kotodama.defaultVoice,
+        decoration_id: decoration ?? provider2TTSAgent.kotodama.defaultDecoration,
+        audio_format: "mp3",
+    };
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-API-Key": apiKey,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error("Failed to generate audio: 401 Incorrect API key provided with Kotodama", {
+                    cause: agentIncorrectAPIKeyError("ttsKotodamaAgent", audioAction, audioFileTarget),
+                });
+            }
+            throw new Error(`Kotodama API error: ${response.status} ${response.statusText}`, {
+                cause: agentGenerationError("ttsKotodamaAgent", audioAction, audioFileTarget),
+            });
+        }
+        // Response is JSON with base64-encoded audio in "audios" array
+        const json = await response.json();
+        if (!json.audios || !json.audios[0]) {
+            throw new Error("TTS Kotodama Error: No audio data in response", {
+                cause: agentGenerationError("ttsKotodamaAgent", audioAction, audioFileTarget),
+            });
+        }
+        const buffer = Buffer.from(json.audios[0], "base64");
+        return { buffer };
+    }
+    catch (error) {
+        if (suppressError) {
+            return {
+                error,
+            };
+        }
+        GraphAILogger.error(error);
+        if (error && typeof error === "object" && "cause" in error) {
+            throw error;
+        }
+        throw new Error("TTS Kotodama Error", {
+            cause: agentGenerationError("ttsKotodamaAgent", audioAction, audioFileTarget),
+        });
+    }
+};
+const ttsKotodamaAgentInfo = {
+    name: "ttsKotodamaAgent",
+    agent: ttsKotodamaAgent,
+    mock: ttsKotodamaAgent,
+    samples: [],
+    description: "Kotodama TTS agent (SpiralAI)",
+    category: ["tts"],
+    author: "Receptron Team",
+    repository: "https://github.com/receptron/mulmocast-cli",
+    license: "MIT",
+    environmentVariables: ["KOTODAMA_API_KEY"],
+};
+export default ttsKotodamaAgentInfo;

package/lib/agents/tts_openai_agent.js

@@ -34,7 +34,7 @@ export const ttsOpenaiAgent = async ({ namedInputs, params, config, }) => {
         }
         GraphAILogger.error(error);
         if (error instanceof AuthenticationError) {
-            throw new Error("Failed to generate image: 401 Incorrect API key provided with OpenAI", {
+            throw new Error("Failed to generate audio: 401 Incorrect API key provided with OpenAI", {
                 cause: agentIncorrectAPIKeyError("ttsOpenaiAgent", audioAction, audioFileTarget),
             });
         }

package/lib/agents/utils.d.ts

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

package/lib/agents/utils.js

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

package/lib/utils/const.d.ts

@@ -11,3 +11,4 @@ export declare const storyToScriptGenerateMode: {
     oneStep: string;
 };
 export declare const bundleTargetLang: string[];
+export declare const ASPECT_RATIOS: string[];

package/lib/utils/const.js

@@ -11,3 +11,4 @@ export const storyToScriptGenerateMode = {
     oneStep: "one_step",
 };
 export const bundleTargetLang = ["ja", "en"];
+export const ASPECT_RATIOS = ["1:1", "9:16", "16:9"];

package/lib/utils/error_cause.d.ts

@@ -197,3 +197,13 @@ export declare const translateApiKeyMissingError: () => {
 export declare const hasCause: (err: unknown) => err is Error & {
     cause: unknown;
 };
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare function resultify<T>(fn: () => Promise<T>): Promise<Result<T>>;
+export declare const getGenAIErrorReason: (error: Error) => any;
+export {};

package/lib/utils/error_cause.js

@@ -226,3 +226,25 @@ export const translateApiKeyMissingError = () => {
 export const hasCause = (err) => {
     return err instanceof Error && "cause" in err;
 };
+export async function resultify(fn) {
+    try {
+        return { ok: true, value: await fn() };
+    }
+    catch (error) {
+        return { ok: false, error: error };
+    }
+}
+export const getGenAIErrorReason = (error) => {
+    try {
+        if (error instanceof Error && error.message && error.message[0] === "{") {
+            const reasonDetail = JSON.parse(error.message).error.details.find((detail) => detail.reason);
+            if (reasonDetail) {
+                return reasonDetail;
+            }
+        }
+    }
+    catch (__error) {
+        // nothing.
+    }
+    return undefined;
+};

package/lib/utils/utils.d.ts

@@ -35,4 +35,8 @@ export declare const multiLingualObjectToArray: (multiLingual: MulmoStudioMultiL
     }>;
     cacheKey?: string | undefined;
 }[];
+export declare const getAspectRatio: (canvasSize: {
+    width: number;
+    height: number;
+}, ASPECT_RATIOS: string[]) => string;
 export {};

package/lib/utils/utils.js

@@ -47,9 +47,8 @@ export const settings2GraphAIConfig = (settings, env) => {
             apiKey: getKey("LLM", "OPENAI_API_KEY"),
             baseURL: getKey("LLM", "OPENAI_BASE_URL"),
         },
-        ttsOpenaiAgent: {
-            apiKey: getKey("TTS", "OPENAI_API_KEY"),
-            baseURL: getKey("TTS", "OPENAI_BASE_URL"),
+        anthropicAgent: {
+            apiKey: getKey("LLM", "ANTHROPIC_API_TOKEN"),
         },
         imageOpenaiAgent: {
             apiKey: getKey("IMAGE", "OPENAI_API_KEY"),
@@ -61,18 +60,22 @@ export const settings2GraphAIConfig = (settings, env) => {
         imageGenAIAgent: {
             apiKey: getKey("IMAGE", "GEMINI_API_KEY"),
         },
-        anthropicAgent: {
-            apiKey: getKey("LLM", "ANTHROPIC_API_TOKEN"),
-        },
         movieReplicateAgent: {
             apiKey: getKey("MOVIE", "REPLICATE_API_TOKEN"),
         },
         movieGenAIAgent: {
             apiKey: getKey("MOVIE", "GEMINI_API_KEY"),
         },
+        ttsOpenaiAgent: {
+            apiKey: getKey("TTS", "OPENAI_API_KEY"),
+            baseURL: getKey("TTS", "OPENAI_BASE_URL"),
+        },
         ttsNijivoiceAgent: {
             apiKey: getKey("TTS", "NIJIVOICE_API_KEY"),
         },
+        ttsGoogleAgent: {
+            apiKey: getKey("TTS", "GEMINI_API_KEY"),
+        },
         ttsGeminiAgent: {
             apiKey: getKey("TTS", "GEMINI_API_KEY"),
         },
@@ -126,3 +129,12 @@ export const multiLingualObjectToArray = (multiLingual, beats) => {
         return { multiLingualTexts: {} };
     });
 };
+export const getAspectRatio = (canvasSize, ASPECT_RATIOS) => {
+    const target = canvasSize.width / canvasSize.height;
+    return ASPECT_RATIOS.reduce((best, ratio) => {
+        const [w, h] = ratio.split(":").map(Number);
+        const r = w / h;
+        const diff = Math.abs(target - r);
+        return diff < best.diff ? { ratio, diff } : best;
+    }, { ratio: ASPECT_RATIOS[0], diff: Infinity }).ratio;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "",
   "type": "module",
   "main": "lib/index.node.js",
@@ -75,12 +75,12 @@
   "dependencies": {
     "@google-cloud/text-to-speech": "^6.4.0",
     "@google/genai": "^1.30.0",
-    "@graphai/anthropic_agent": "^2.0.11",
+    "@graphai/anthropic_agent": "^2.0.12",
     "@graphai/browserless_agent": "^2.0.1",
     "@graphai/gemini_agent": "^2.0.1",
     "@graphai/groq_agent": "^2.0.2",
     "@graphai/input_agents": "^1.0.2",
-    "@graphai/openai_agent": "^2.0.7",
+    "@graphai/openai_agent": "^2.0.8",
     "@graphai/stream_agent_filter": "^2.0.2",
     "@graphai/vanilla": "^2.0.12",
     "@graphai/vanilla_node_agents": "^2.0.4",
@@ -114,7 +114,7 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-sonarjs": "^3.0.5",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.1",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.0"