mulmocast 0.0.1 → 0.0.3

package/lib/actions/translate.js

@@ -1,46 +1,11 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.translate = void 0;
-require("dotenv/config");
-const graphai_1 = require("graphai");
-const agents = __importStar(require("@graphai/vanilla"));
-const openai_agent_1 = require("@graphai/openai_agent");
-const vanilla_node_agents_1 = require("@graphai/vanilla_node_agents");
-const string_1 = require("../utils/string");
-const file_1 = require("../utils/file");
+import "dotenv/config";
+import { GraphAI, assert } from "graphai";
+import * as agents from "@graphai/vanilla";
+import { openAIAgent } from "@graphai/openai_agent";
+import { fileWriteAgent } from "@graphai/vanilla_node_agents";
+import { recursiveSplitJa, replacementsJa, replacePairsJa } from "../utils/string.js";
+import { getOutputStudioFilePath, mkdir, writingMessage } from "../utils/file.js";
+const { default: __, ...vanillaAgents } = agents;
 const translateGraph = {
     version: 0.5,
     nodes: {
@@ -67,7 +32,8 @@ const translateGraph = {
             agent: "mapAgent",
             inputs: {
                 targetLangs: ":targetLangs",
-                rows: ":studio.beats",
+                studio: ":studio",
+                rows: ":studio.script.beats",
                 lang: ":lang",
             },
             params: {
@@ -77,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,
@@ -95,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"],
@@ -118,7 +96,7 @@ const translateGraph = {
                                         if (targetLang === "ja") {
                                             return {
                                                 ...localizedText,
-                                                texts: (0, string_1.recursiveSplitJa)(localizedText.text),
+                                                texts: recursiveSplitJa(localizedText.text),
                                             };
                                         }
                                         // not split
@@ -143,7 +121,7 @@ const translateGraph = {
                                         if (targetLang === "ja") {
                                             return {
                                                 ...localizedText,
-                                                ttsTexts: localizedText?.texts?.map((text) => (0, string_1.replacePairsJa)(text, string_1.replacementsJa)),
+                                                ttsTexts: localizedText?.texts?.map((text) => replacePairsJa(text, replacementsJa)),
                                             };
                                         }
                                         return {
@@ -173,7 +151,7 @@ const translateGraph = {
                         isResult: true,
                         agent: "mergeObjectAgent",
                         inputs: {
-                            items: [":beat", { multiLingualTexts: ":mergeLocalizedText" }],
+                            items: [":studioBeat", { multiLingualTexts: ":mergeLocalizedText" }],
                         },
                     },
                 },
@@ -191,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) {
@@ -215,22 +193,21 @@ const agentFilters = [
 ];
 const defaultLang = "en";
 const targetLangs = ["ja", "en"];
-const translate = async (context) => {
+export const translate = async (context) => {
     const { studio, fileDirs } = context;
     const { outDirPath } = fileDirs;
-    const outputStudioFilePath = (0, file_1.getOutputStudioFilePath)(outDirPath, studio.filename);
-    (0, file_1.mkdir)(outDirPath);
-    (0, graphai_1.assert)(!!process.env.OPENAI_API_KEY, "The OPENAI_API_KEY environment variable is missing or empty");
-    const graph = new graphai_1.GraphAI(translateGraph, { ...agents, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent, openAIAgent: openai_agent_1.openAIAgent }, { agentFilters });
+    const outputStudioFilePath = getOutputStudioFilePath(outDirPath, studio.filename);
+    mkdir(outDirPath);
+    assert(!!process.env.OPENAI_API_KEY, "The OPENAI_API_KEY environment variable is missing or empty");
+    const graph = new GraphAI(translateGraph, { ...vanillaAgents, fileWriteAgent, openAIAgent }, { agentFilters });
     graph.injectValue("studio", studio);
     graph.injectValue("defaultLang", defaultLang);
     graph.injectValue("targetLangs", targetLangs);
     graph.injectValue("outDirPath", outDirPath);
     graph.injectValue("outputStudioFilePath", outputStudioFilePath);
     await graph.run();
-    (0, file_1.writingMessage)(outputStudioFilePath);
+    writingMessage(outputStudioFilePath);
     // const results = await graph.run();
     // const mulmoDataResult = results.mergeResult;
     // console.log(JSON.stringify(mulmoDataResult, null, 2));
 };
-exports.translate = translate;

package/lib/agents/add_bgm_agent.d.ts

@@ -1,3 +1,3 @@
-import { AgentFunctionInfo } from "graphai";
+import type { AgentFunctionInfo } from "graphai";
 declare const addBGMAgentInfo: AgentFunctionInfo;
 export default addBGMAgentInfo;

package/lib/agents/add_bgm_agent.js

@@ -1,24 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
-const methods_1 = require("../methods");
+import { GraphAILogger } from "graphai";
+import ffmpeg from "fluent-ffmpeg";
+import { MulmoScriptMethods } from "../methods/index.js";
 const addBGMAgent = async ({ namedInputs, params, }) => {
     const { voiceFile, outputFile, script } = namedInputs;
     const { musicFile } = params;
     const promise = new Promise((resolve, reject) => {
-        fluent_ffmpeg_1.default.ffprobe(voiceFile, (err, metadata) => {
+        ffmpeg.ffprobe(voiceFile, (err, metadata) => {
             if (err) {
-                console.error("Error getting metadata: " + err.message);
+                GraphAILogger.info("Error getting metadata: " + err.message);
                 reject(err);
             }
             const speechDuration = metadata.format.duration;
-            const padding = methods_1.MulmoScriptMethods.getPadding(script);
+            const padding = MulmoScriptMethods.getPadding(script);
             const totalDuration = (padding * 2) / 1000 + Math.round(speechDuration ?? 0);
-            console.log("totalDucation:", speechDuration, totalDuration);
-            const command = (0, fluent_ffmpeg_1.default)();
+            GraphAILogger.log("totalDucation:", speechDuration, totalDuration);
+            const command = ffmpeg();
             command
                 .input(musicFile)
                 .input(voiceFile)
@@ -35,7 +31,7 @@ const addBGMAgent = async ({ namedInputs, params, }) => {
                 `[trimmed]afade=t=out:st=${totalDuration - padding / 1000}:d=${padding}`,
             ])
                 .on("error", (err) => {
-                console.error("Error: " + err.message);
+                GraphAILogger.info("Error: " + err.message);
                 reject(err);
             })
                 .on("end", () => {
@@ -58,4 +54,4 @@ const addBGMAgentInfo = {
     repository: "https://github.com/snakajima/ai-podcaster",
     license: "MIT",
 };
-exports.default = addBGMAgentInfo;
+export default addBGMAgentInfo;

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;

package/lib/agents/anthropic_agent.js

@@ -0,0 +1,162 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { getMergeValue } from "@graphai/llm_utils";
+const convToolCall = (tool_call) => {
+    const { id, name, input } = tool_call;
+    return { id, name, arguments: input };
+};
+// https://docs.anthropic.com/ja/api/messages
+const convertOpenAIChatCompletion = (response, messages) => {
+    // SDK bug https://github.com/anthropics/anthropic-sdk-typescript/issues/432
+    const text = response.content[0].text;
+    const functionResponses = response.content.filter((content) => content.type === "tool_use") ?? [];
+    const tool_calls = functionResponses.map(convToolCall);
+    const tool = tool_calls[0] ? tool_calls[0] : undefined;
+    const message = { role: response.role, content: text };
+    messages.push(message);
+    return { ...response, choices: [{ message }], text, tool, tool_calls, message, messages };
+};
+export const anthropicAgent = async ({ params, namedInputs, filterParams, config, }) => {
+    const { verbose, system, temperature, tools, tool_choice, max_tokens, prompt, messages } = { ...params, ...namedInputs };
+    const { apiKey, stream, forWeb, model } = {
+        ...params,
+        ...(config || {}),
+    };
+    console.log({ stream });
+    const userPrompt = getMergeValue(namedInputs, params, "mergeablePrompts", prompt);
+    const systemPrompt = getMergeValue(namedInputs, params, "mergeableSystem", system);
+    const messagesCopy = messages ? messages.map((m) => m) : [];
+    if (userPrompt) {
+        messagesCopy.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+    if (verbose) {
+        console.log(messagesCopy);
+    }
+    const anthropic_tools = tools && tools.length > 0
+        ? tools.map((tool) => {
+            const { function: func } = tool;
+            const { name, description, parameters } = func;
+            return {
+                name,
+                description,
+                input_schema: parameters,
+            };
+        })
+        : undefined;
+    const anthropic = new Anthropic({ apiKey, dangerouslyAllowBrowser: !!forWeb });
+    const chatParams = {
+        model: model ?? "claude-3-5-sonnet-latest",
+        messages: messagesCopy,
+        tools: anthropic_tools,
+        tool_choice,
+        system: systemPrompt,
+        temperature: temperature ?? 0.7,
+        max_tokens: max_tokens ?? 1024,
+    };
+    if (!stream) {
+        const messageResponse = await anthropic.messages.create(chatParams);
+        return convertOpenAIChatCompletion(messageResponse, messagesCopy);
+    }
+    try {
+        console.log("###");
+        const chatStream = await anthropic.messages.create({
+            ...chatParams,
+            stream: true,
+        });
+        console.log("###2");
+        const contents = [];
+        const partials = [];
+        let streamResponse = null;
+        console.log("###3");
+        for await (const messageStreamEvent of chatStream) {
+            console.log("AA");
+            if (messageStreamEvent.type === "message_start") {
+                streamResponse = messageStreamEvent.message;
+            }
+            if (messageStreamEvent.type === "content_block_start") {
+                if (streamResponse) {
+                    streamResponse.content.push(messageStreamEvent.content_block);
+                }
+                partials.push("");
+            }
+            if (messageStreamEvent.type === "content_block_delta") {
+                const { index, delta } = messageStreamEvent;
+                if (delta.type === "input_json_delta") {
+                    partials[index] = partials[index] + delta.partial_json;
+                }
+                if (delta.type === "text_delta") {
+                    partials[index] = partials[index] + delta.text;
+                }
+            }
+            if (messageStreamEvent.type === "content_block_delta" && messageStreamEvent.delta.type === "text_delta") {
+                const token = messageStreamEvent.delta.text;
+                contents.push(token);
+                if (filterParams && filterParams.streamTokenCallback && token) {
+                    filterParams.streamTokenCallback(token);
+                }
+            }
+        }
+        if (streamResponse === null) {
+            throw new Error("Anthoropic no response");
+        }
+        partials.forEach((partial, index) => {
+            if (streamResponse.content[index].type === "text") {
+                streamResponse.content[index].text = partial;
+            }
+            if (streamResponse.content[index].type === "tool_use") {
+                streamResponse.content[index].input = JSON.parse(partial);
+            }
+        });
+        return convertOpenAIChatCompletion(streamResponse, messagesCopy);
+        /*
+      
+      const content = contents.join("");
+      const message = { role: "assistant" as const, content: content };
+      messagesCopy.push(message);
+      return { choices: [{ message }], text: content, message, messages: messagesCopy };
+      */
+    }
+    catch (e) {
+        console.log(e);
+        throw new Error("ant Error");
+    }
+};
+const anthropicAgentInfo = {
+    name: "anthropicAgent",
+    agent: anthropicAgent,
+    mock: anthropicAgent,
+    inputs: {
+        type: "object",
+        properties: {
+            model: { type: "string" },
+            system: { type: "string" },
+            max_tokens: { type: "number" },
+            temperature: { type: "number" },
+            prompt: {
+                type: "string",
+                description: "query string",
+            },
+            messages: {
+                anyOf: [{ type: "string" }, { type: "integer" }, { type: "object" }, { type: "array" }],
+                description: "chat messages",
+            },
+        },
+    },
+    output: {
+        type: "object",
+    },
+    samples: [],
+    description: "Anthropic Agent",
+    category: ["llm"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    source: "https://github.com/receptron/graphai/blob/main/llm_agents/anthropic_agent/src/anthropic_agent.ts",
+    package: "@graphai/anthropic_agent",
+    license: "MIT",
+    stream: true,
+    environmentVariables: ["ANTHROPIC_API_KEY"],
+    npms: ["@anthropic-ai/sdk"],
+};
+export default anthropicAgentInfo;

package/lib/agents/combine_audio_files_agent.d.ts

@@ -1,3 +1,3 @@
-import { AgentFunctionInfo } from "graphai";
+import type { AgentFunctionInfo } from "graphai";
 declare const combineAudioFilesAgentInfo: AgentFunctionInfo;
 export default combineAudioFilesAgentInfo;

package/lib/agents/combine_audio_files_agent.js

@@ -1,44 +1,45 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
-const file_1 = require("../utils/file");
-const methods_1 = require("../methods");
+import { GraphAILogger } from "graphai";
+import ffmpeg from "fluent-ffmpeg";
+import { silentPath, silentLastPath } from "../utils/file.js";
 const combineAudioFilesAgent = async ({ namedInputs }) => {
-    const { context, combinedFileName, scratchpadDirPath } = namedInputs;
-    const command = (0, fluent_ffmpeg_1.default)();
-    context.studio.beats.forEach((mulmoBeat, index) => {
-        const audioPath = mulmoBeat.audio?.type === "audio" &&
-            ((mulmoBeat.audio?.source.kind === "path" && methods_1.MulmoStudioContextMethods.resolveAssetPath(context, mulmoBeat.audio.source.path)) ||
-                (mulmoBeat.audio?.source.kind === "url" && mulmoBeat.audio.source.url));
-        const filePath = audioPath || (0, file_1.getScratchpadFilePath)(scratchpadDirPath, mulmoBeat.audioFile ?? "");
-        const isLast = index === context.studio.beats.length - 2;
-        command.input(filePath);
-        command.input(isLast ? file_1.silentLastPath : file_1.silentPath);
-        // Measure and log the timestamp of each section
-        fluent_ffmpeg_1.default.ffprobe(filePath, (err, metadata) => {
-            if (err) {
-                console.error("Error while getting metadata:", err);
-            }
-            else {
-                context.studio.beats[index]["duration"] = metadata.format.duration + (isLast ? 0.8 : 0.3);
-            }
+    const { context, combinedFileName, audioDirPath } = namedInputs;
+    const command = ffmpeg();
+    const getDuration = (filePath, isLastGap) => {
+        return new Promise((resolve, reject) => {
+            ffmpeg.ffprobe(filePath, (err, metadata) => {
+                if (err) {
+                    GraphAILogger.info("Error while getting metadata:", err);
+                    reject(err);
+                }
+                else {
+                    // TODO: Remove hard-coded 0.8 and 0.3
+                    resolve(metadata.format.duration + (isLastGap ? 0.8 : 0.3));
+                }
+            });
         });
-    });
-    const promise = new Promise((resolve, reject) => {
+    };
+    await Promise.all(context.studio.beats.map(async (studioBeat, index) => {
+        const isLastGap = index === context.studio.beats.length - 2;
+        if (studioBeat.audioFile) {
+            command.input(studioBeat.audioFile);
+            command.input(isLastGap ? silentLastPath : silentPath);
+            studioBeat.duration = await getDuration(studioBeat.audioFile, isLastGap);
+        }
+        else {
+            GraphAILogger.error("Missing studioBeat.audioFile:", index);
+        }
+    }));
+    await new Promise((resolve, reject) => {
         command
             .on("end", () => {
             resolve(0);
         })
             .on("error", (err) => {
-            console.error("Error while combining MP3 files:", err);
+            GraphAILogger.info("Error while combining MP3 files:", err);
             reject(err);
         })
-            .mergeToFile(combinedFileName, scratchpadDirPath);
+            .mergeToFile(combinedFileName, audioDirPath);
     });
-    await promise;
     return {
         studio: context.studio,
     };
@@ -54,4 +55,4 @@ const combineAudioFilesAgentInfo = {
     repository: "https://github.com/snakajima/ai-podcaster",
     license: "MIT",
 };
-exports.default = combineAudioFilesAgentInfo;
+export default combineAudioFilesAgentInfo;

package/lib/agents/image_google_agent.d.ts

@@ -1,4 +1,4 @@
-import { AgentFunction, AgentFunctionInfo } from "graphai";
+import type { AgentFunction, AgentFunctionInfo } from "graphai";
 export type ImageGoogleConfig = {
     projectId?: string;
     token?: string;

package/lib/agents/image_google_agent.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.imageGoogleAgent = void 0;
+import { GraphAILogger } from "graphai";
 async function generateImage(projectId, model, token, prompt, aspectRatio) {
     const GOOGLE_IMAGEN_ENDPOINT = `https://us-central1-aiplatform.googleapis.com/v1/projects/${projectId}/locations/us-central1/publishers/google/models/${model}:predict`;
     try {
@@ -43,16 +41,16 @@ async function generateImage(projectId, model, token, prompt, aspectRatio) {
         }
         else {
             // console.log(response);
-            console.log("No predictions returned from the API.", responseData, prompt);
+            GraphAILogger.info("No predictions returned from the API.", responseData, prompt);
             return undefined;
         }
     }
     catch (error) {
-        console.error("Error generating image:", error);
+        GraphAILogger.info("Error generating image:", error);
         throw error;
     }
 }
-const imageGoogleAgent = async ({ namedInputs, params, config, }) => {
+export const imageGoogleAgent = async ({ namedInputs, params, config, }) => {
     const { prompt } = namedInputs;
     const aspectRatio = params.aspectRatio ?? "16:9";
     const model = params.model ?? "imagen-3.0-fast-generate-001";
@@ -67,15 +65,14 @@ const imageGoogleAgent = async ({ namedInputs, params, config, }) => {
         throw new Error("ERROR: geneateImage returned undefined");
     }
     catch (error) {
-        console.error("Failed to generate image:", error);
+        GraphAILogger.info("Failed to generate image:", error);
         throw error;
     }
 };
-exports.imageGoogleAgent = imageGoogleAgent;
 const imageGoogleAgentInfo = {
     name: "imageGoogleAgent",
-    agent: exports.imageGoogleAgent,
-    mock: exports.imageGoogleAgent,
+    agent: imageGoogleAgent,
+    mock: imageGoogleAgent,
     samples: [],
     description: "Google Image agent",
     category: ["image"],
@@ -85,4 +82,4 @@ const imageGoogleAgentInfo = {
     license: "MIT",
     environmentVariables: [],
 };
-exports.default = imageGoogleAgentInfo;
+export default imageGoogleAgentInfo;

package/lib/agents/image_openai_agent.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.imageOpenaiAgent = void 0;
-const openai_1 = __importDefault(require("openai"));
+import OpenAI from "openai";
 // https://platform.openai.com/docs/guides/image-generation
-const imageOpenaiAgent = async ({ namedInputs, params }) => {
+export const imageOpenaiAgent = async ({ namedInputs, params }) => {
     const { prompt } = namedInputs;
     const { apiKey, model, size, moderation } = params;
-    const openai = new openai_1.default({ apiKey });
+    const openai = new OpenAI({ apiKey });
     const imageOptions = {
         model: model ?? "dall-e-3",
         prompt,
         n: 1,
-        size: size || "1792x1024",
+        size: size || model === "gpt-image-1" ? "1536x1024" : "1792x1024",
     };
     if (model === "gpt-image-1") {
         imageOptions.moderation = moderation || "auto";
@@ -42,11 +36,10 @@ const imageOpenaiAgent = async ({ namedInputs, params }) => {
     // 3. Convert the ArrayBuffer to a Node.js Buffer and return it along with url
     return { buffer: Buffer.from(arrayBuffer) };
 };
-exports.imageOpenaiAgent = imageOpenaiAgent;
 const imageOpenaiAgentInfo = {
     name: "imageOpenaiAgent",
-    agent: exports.imageOpenaiAgent,
-    mock: exports.imageOpenaiAgent,
+    agent: imageOpenaiAgent,
+    mock: imageOpenaiAgent,
     samples: [],
     description: "OpenAI Image agent",
     category: ["image"],
@@ -56,4 +49,4 @@ const imageOpenaiAgentInfo = {
     license: "MIT",
     environmentVariables: ["OPENAI_API_KEY"],
 };
-exports.default = imageOpenaiAgentInfo;
+export default imageOpenaiAgentInfo;

package/lib/agents/index.d.ts

@@ -1,11 +1,11 @@
-import addBGMAgent from "./add_bgm_agent";
-import combineAudioFilesAgent from "./combine_audio_files_agent";
-import imageGoogleAgent from "./image_google_agent";
-import imageOpenaiAgent from "./image_openai_agent";
-import mulmoPromptsAgent from "./mulmo_prompts_agent";
-import ttsNijivoiceAgent from "./tts_nijivoice_agent";
-import ttsOpenaiAgent from "./tts_openai_agent";
-import validateMulmoScriptAgent from "./validate_mulmo_script_agent";
+import addBGMAgent from "./add_bgm_agent.js";
+import combineAudioFilesAgent from "./combine_audio_files_agent.js";
+import imageGoogleAgent from "./image_google_agent.js";
+import imageOpenaiAgent from "./image_openai_agent.js";
+import mulmoPromptsAgent from "./mulmo_prompts_agent.js";
+import ttsNijivoiceAgent from "./tts_nijivoice_agent.js";
+import ttsOpenaiAgent from "./tts_openai_agent.js";
+import validateMulmoScriptAgent from "./validate_mulmo_script_agent.js";
 import { browserlessAgent } from "@graphai/browserless_agent";
 import { textInputAgent } from "@graphai/input_agents";
 import { openAIAgent } from "@graphai/openai_agent";