mulmocast 2.0.5 → 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

@@ -1,22 +1,112 @@
 import { readFileSync } from "fs";
 import { GraphAILogger, sleep } from "graphai";
-import { apiKeyMissingError, agentGenerationError, agentInvalidResponseError, imageAction, movieFileTarget, videoDurationTarget, hasCause, } from "../utils/error_cause.js";
 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";
+const pollUntilDone = async (ai, operation) => {
+    const response = { operation };
+    while (!response.operation.done) {
+        await sleep(5000);
+        response.operation = await ai.operations.getVideosOperation(response);
+    }
+    return response;
+};
+const getVideoFromResponse = (response, iteration) => {
+    const iterationInfo = iteration !== undefined ? ` in iteration ${iteration}` : "";
+    if (!response.operation.response?.generatedVideos) {
+        throw new Error(`No video${iterationInfo}: ${JSON.stringify(response.operation, null, 2)}`, {
+            cause: agentInvalidResponseError("movieGenAIAgent", imageAction, movieFileTarget),
+        });
     }
-    else if (canvasSize.width < canvasSize.height) {
-        return "9:16";
+    const video = response.operation.response.generatedVideos[0].video;
+    if (!video) {
+        throw new Error(`No video${iterationInfo}`, {
+            cause: agentInvalidResponseError("movieGenAIAgent", imageAction, movieFileTarget),
+        });
     }
-    else {
-        return "1:1";
+    return video;
+};
+const loadImageAsBase64 = (imagePath) => {
+    const buffer = readFileSync(imagePath);
+    return {
+        imageBytes: buffer.toString("base64"),
+        mimeType: "image/png",
+    };
+};
+const downloadVideo = async (ai, video, movieFile) => {
+    await ai.files.download({
+        file: video,
+        downloadPath: movieFile,
+    });
+    await sleep(5000); // HACK: Without this, the file is not ready yet.
+    return { saved: movieFile };
+};
+const createVeo31Payload = (model, prompt, aspectRatio, source) => ({
+    model,
+    prompt,
+    config: {
+        aspectRatio,
+        resolution: "720p",
+        numberOfVideos: 1,
+    },
+    ...source,
+});
+const generateExtendedVideo = async (ai, model, prompt, aspectRatio, imagePath, requestedDuration, movieFile) => {
+    const initialDuration = 8;
+    const maxExtensionDuration = 8;
+    const extensionsNeeded = Math.ceil((requestedDuration - initialDuration) / maxExtensionDuration);
+    GraphAILogger.info(`Veo 3.1 video extension: ${extensionsNeeded} extensions needed for ${requestedDuration}s target`);
+    const generateIteration = async (iteration, accumulatedDuration, previousVideo) => {
+        const isInitial = iteration === 0;
+        const remainingDuration = requestedDuration - accumulatedDuration;
+        const extensionDuration = isInitial ? initialDuration : (getModelDuration("google", model, remainingDuration) ?? maxExtensionDuration);
+        const getSource = () => {
+            if (isInitial)
+                return imagePath ? { image: loadImageAsBase64(imagePath) } : undefined;
+            return previousVideo?.uri ? { video: { uri: previousVideo.uri } } : undefined;
+        };
+        const payload = createVeo31Payload(model, prompt, aspectRatio, getSource());
+        GraphAILogger.info(isInitial ? "Generating initial 8s video..." : `Extending video: iteration ${iteration}/${extensionsNeeded} (+${extensionDuration}s)...`);
+        const operation = await ai.models.generateVideos(payload);
+        const response = await pollUntilDone(ai, operation);
+        const video = getVideoFromResponse(response, iteration);
+        const totalDuration = accumulatedDuration + extensionDuration;
+        GraphAILogger.info(`Video ${isInitial ? "generated" : "extended"}: ~${totalDuration}s total`);
+        return { video, duration: totalDuration };
+    };
+    const result = await Array.from({ length: extensionsNeeded + 1 }).reduce(async (prev, _, index) => {
+        const { video, duration } = await prev;
+        return generateIteration(index, duration, video);
+    }, Promise.resolve({ video: undefined, duration: 0 }));
+    if (!result.video) {
+        throw new Error("Failed to generate extended video", {
+            cause: agentInvalidResponseError("movieGenAIAgent", imageAction, movieFileTarget),
+        });
     }
+    return downloadVideo(ai, result.video, movieFile);
+};
+const generateStandardVideo = async (ai, model, prompt, aspectRatio, imagePath, duration, movieFile) => {
+    const isVeo3 = model === "veo-3.0-generate-001" || model === "veo-3.1-generate-preview";
+    const payload = {
+        model,
+        prompt,
+        config: {
+            durationSeconds: isVeo3 ? undefined : duration,
+            aspectRatio,
+            personGeneration: imagePath ? undefined : PersonGeneration.ALLOW_ALL,
+        },
+        image: imagePath ? loadImageAsBase64(imagePath) : undefined,
+    };
+    const operation = await ai.models.generateVideos(payload);
+    const response = await pollUntilDone(ai, operation);
+    const video = getVideoFromResponse(response);
+    return downloadVideo(ai, video, movieFile);
 };
 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) {
@@ -33,54 +123,12 @@ export const movieGenAIAgent = async ({ namedInputs, params, config, }) => {
             });
         }
         const ai = new GoogleGenAI({ apiKey });
-        const payload = {
-            model,
-            prompt,
-            config: {
-                durationSeconds: duration,
-                aspectRatio,
-                personGeneration: undefined,
-            },
-            image: undefined,
-        };
-        if (model === "veo-3.0-generate-001" || model === "veo-3.1-generate-preview") {
-            payload.config.durationSeconds = undefined;
-        }
-        if (imagePath) {
-            const buffer = readFileSync(imagePath);
-            const imageBytes = buffer.toString("base64");
-            payload.image = {
-                imageBytes,
-                mimeType: "image/png",
-            };
-        }
-        else {
-            payload.config.personGeneration = PersonGeneration.ALLOW_ALL;
-        }
-        const operation = await ai.models.generateVideos(payload);
-        const response = { operation };
-        // Poll the operation status until the video is ready.
-        while (!response.operation.done) {
-            await sleep(5000);
-            response.operation = await ai.operations.getVideosOperation(response);
+        // Veo 3.1: Video extension mode for videos longer than 8s
+        if (model === "veo-3.1-generate-preview" && requestedDuration > 8 && params.canvasSize) {
+            return generateExtendedVideo(ai, model, prompt, aspectRatio, imagePath, requestedDuration, movieFile);
         }
-        if (!response.operation.response?.generatedVideos) {
-            throw new Error(`No video: ${JSON.stringify(response.operation, null, 2)}`, {
-                cause: agentInvalidResponseError("movieGenAIAgent", imageAction, movieFileTarget),
-            });
-        }
-        const video = response.operation.response.generatedVideos[0].video;
-        if (!video) {
-            throw new Error(`No video: ${JSON.stringify(response.operation, null, 2)}`, {
-                cause: agentInvalidResponseError("movieGenAIAgent", imageAction, movieFileTarget),
-            });
-        }
-        await ai.files.download({
-            file: video,
-            downloadPath: movieFile,
-        });
-        await sleep(5000); // HACK: Without this, the file is not ready yet.
-        return { saved: movieFile };
+        // Standard mode
+        return generateStandardVideo(ai, model, prompt, aspectRatio, imagePath, duration, movieFile);
     }
     catch (error) {
         GraphAILogger.info("Failed to generate movie:", error.message);

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 {};