@vibeframe/cli 0.27.0

package/dist/agent/tools/ai-generation.js

@@ -0,0 +1,973 @@
+/**
+ * @module ai-generation
+ * @description Agent tools for AI asset generation (image, video, TTS, SFX, music,
+ * storyboard, motion). Wraps providers for agent use. Some features require
+ * async polling -- tool returns immediately with task status.
+ *
+ * ## Tools: generate_image, generate_video, generate_speech, generate_sound_effect, generate_music, generate_storyboard, generate_motion
+ * ## Dependencies: OpenAI, Gemini, Runway, Kling, ElevenLabs (TTS/SFX/Music), Replicate, Claude, Remotion
+ * @see MODELS.md for the Single Source of Truth (SSOT) on supported providers/models
+ */
+import { writeFile, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { getApiKeyFromConfig } from "../../config/index.js";
+import { downloadVideo } from "../../commands/ai-helpers.js";
+import { sanitizeAIResult } from "../../commands/sanitize.js";
+// Helper to get timestamp for filenames
+function getTimestamp() {
+    return Date.now().toString();
+}
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+const imageDef = {
+    name: "generate_image",
+    description: "Generate an image using AI (OpenAI GPT Image 1.5, Gemini, or xAI Grok)",
+    parameters: {
+        type: "object",
+        properties: {
+            prompt: {
+                type: "string",
+                description: "Image generation prompt",
+            },
+            output: {
+                type: "string",
+                description: "Output file path (default: generated-{timestamp}.png)",
+            },
+            provider: {
+                type: "string",
+                description: "Provider to use: openai (GPT Image 1.5), gemini (Nano Banana), grok (Grok Imagine). 'dalle' is deprecated, use 'openai' instead.",
+                enum: ["openai", "dalle", "gemini", "grok"],
+            },
+            size: {
+                type: "string",
+                description: "Image size (1024x1024, 1536x1024, 1024x1536)",
+                enum: ["1024x1024", "1536x1024", "1024x1536"],
+            },
+        },
+        required: ["prompt"],
+    },
+};
+const videoDef = {
+    name: "generate_video",
+    description: "Generate video using AI. Supports Grok Imagine (default, native audio), Runway Gen-4.5 (text/image-to-video) and gen4_turbo (image-to-video), Kling (text/image-to-video), and Veo (text/image-to-video) via provider selection.",
+    parameters: {
+        type: "object",
+        properties: {
+            prompt: {
+                type: "string",
+                description: "Video generation prompt describing the motion/animation",
+            },
+            provider: {
+                type: "string",
+                description: "Video provider to use (default: grok)",
+                enum: ["grok", "runway", "kling", "veo"],
+            },
+            image: {
+                type: "string",
+                description: "Input image path. Required for runway gen4_turbo, optional for runway gen4.5/kling/veo.",
+            },
+            runwayModel: {
+                type: "string",
+                description: "Runway model: gen4.5 (default, text+image-to-video) or gen4_turbo (image-to-video only)",
+                enum: ["gen4.5", "gen4_turbo"],
+            },
+            output: {
+                type: "string",
+                description: "Output file path",
+            },
+            duration: {
+                type: "number",
+                description: "Video duration in seconds",
+            },
+            mode: {
+                type: "string",
+                description: "Quality mode for Kling (std or pro)",
+                enum: ["std", "pro"],
+            },
+            negativePrompt: {
+                type: "string",
+                description: "What to avoid in the generated video (Veo only)",
+            },
+            resolution: {
+                type: "string",
+                description: "Video resolution (Veo only)",
+                enum: ["720p", "1080p", "4k"],
+            },
+        },
+        required: ["prompt"],
+    },
+};
+const ttsDef = {
+    name: "generate_speech",
+    description: "Generate speech from text using ElevenLabs",
+    parameters: {
+        type: "object",
+        properties: {
+            text: {
+                type: "string",
+                description: "Text to convert to speech",
+            },
+            output: {
+                type: "string",
+                description: "Output audio file path",
+            },
+            voice: {
+                type: "string",
+                description: "Voice ID or name",
+            },
+        },
+        required: ["text"],
+    },
+};
+const sfxDef = {
+    name: "generate_sound_effect",
+    description: "Generate sound effects using ElevenLabs",
+    parameters: {
+        type: "object",
+        properties: {
+            prompt: {
+                type: "string",
+                description: "Sound effect description",
+            },
+            output: {
+                type: "string",
+                description: "Output audio file path",
+            },
+            duration: {
+                type: "number",
+                description: "Duration in seconds",
+            },
+        },
+        required: ["prompt"],
+    },
+};
+const musicDef = {
+    name: "generate_music",
+    description: "Generate music using AI. Default: ElevenLabs (synchronous, up to 10min). Alternative: Replicate/MusicGen (async, max 30s).",
+    parameters: {
+        type: "object",
+        properties: {
+            prompt: {
+                type: "string",
+                description: "Music description/prompt",
+            },
+            output: {
+                type: "string",
+                description: "Output audio file path",
+            },
+            duration: {
+                type: "number",
+                description: "Duration in seconds (elevenlabs: 3-600, replicate: 1-30)",
+            },
+            provider: {
+                type: "string",
+                description: "Provider: elevenlabs (default, synchronous, up to 10min) or replicate (async, max 30s)",
+                enum: ["elevenlabs", "replicate"],
+            },
+            instrumental: {
+                type: "boolean",
+                description: "Force instrumental music with no vocals (ElevenLabs only)",
+            },
+        },
+        required: ["prompt"],
+    },
+};
+const storyboardDef = {
+    name: "generate_storyboard",
+    description: "Generate a storyboard from a script using Claude",
+    parameters: {
+        type: "object",
+        properties: {
+            script: {
+                type: "string",
+                description: "Video script or concept",
+            },
+            targetDuration: {
+                type: "number",
+                description: "Target video duration in seconds",
+            },
+            output: {
+                type: "string",
+                description: "Output JSON file path",
+            },
+            creativity: {
+                type: "string",
+                description: "Creativity level: 'low' (default, consistent scenes) or 'high' (varied, unexpected scenes)",
+                enum: ["low", "high"],
+            },
+        },
+        required: ["script"],
+    },
+};
+const motionDef = {
+    name: "generate_motion",
+    description: "Generate motion graphics using Claude + Remotion. Can render to video and composite onto existing footage. " +
+        "Without --video: generates and renders a standalone motion graphic. With --video: renders and composites onto the base video.",
+    parameters: {
+        type: "object",
+        properties: {
+            description: {
+                type: "string",
+                description: "Natural language description of the motion graphic (e.g., 'cinematic title card with fade-in')",
+            },
+            video: {
+                type: "string",
+                description: "Base video path to composite the motion graphic onto (triggers render + composite)",
+            },
+            output: {
+                type: "string",
+                description: "Output file path (.mp4 if compositing, .webm if render-only, .tsx if code-only)",
+            },
+            duration: {
+                type: "number",
+                description: "Duration in seconds (default: 5)",
+            },
+            width: {
+                type: "number",
+                description: "Width in pixels (default: 1920)",
+            },
+            height: {
+                type: "number",
+                description: "Height in pixels (default: 1080)",
+            },
+            style: {
+                type: "string",
+                description: "Style preset",
+                enum: ["minimal", "corporate", "playful", "cinematic"],
+            },
+        },
+        required: ["description"],
+    },
+};
+// ============================================================================
+// Tool Handlers
+// ============================================================================
+const generateImage = async (args, context) => {
+    const prompt = args.prompt;
+    const provider = args.provider || "gemini";
+    const output = args.output || `generated-${getTimestamp()}.png`;
+    const size = args.size || "1024x1024";
+    try {
+        let providerKey;
+        switch (provider) {
+            case "gemini":
+                providerKey = "google";
+                break;
+            case "openai":
+            case "dalle": // backward compatibility
+                providerKey = "openai";
+                break;
+            case "grok":
+                providerKey = "xai";
+                break;
+            default:
+                providerKey = "openai";
+        }
+        const apiKey = await getApiKeyFromConfig(providerKey);
+        if (!apiKey) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: `API key required for ${provider}. Configure via 'vibe setup'.`,
+            };
+        }
+        const outputPath = resolve(context.workingDirectory, output);
+        if (provider === "dalle" || provider === "openai") {
+            const { OpenAIImageProvider } = await import("@vibeframe/ai-providers");
+            const openaiImage = new OpenAIImageProvider();
+            await openaiImage.initialize({ apiKey });
+            const result = await openaiImage.generateImage(prompt, {
+                size: size,
+            });
+            if (!result.success || !result.images || result.images.length === 0) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Image generation failed: ${result.error || "No image generated"}`,
+                };
+            }
+            // Save image (handle both URL and base64)
+            const image = result.images[0];
+            let buffer;
+            if (image.url) {
+                const response = await fetch(image.url);
+                buffer = Buffer.from(await response.arrayBuffer());
+            }
+            else if (image.base64) {
+                buffer = Buffer.from(image.base64, "base64");
+            }
+            else {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "Image generated but no URL or base64 data returned",
+                };
+            }
+            await writeFile(outputPath, buffer);
+        }
+        else if (provider === "gemini") {
+            const { GeminiProvider } = await import("@vibeframe/ai-providers");
+            const gemini = new GeminiProvider();
+            await gemini.initialize({ apiKey });
+            const result = await gemini.generateImage(prompt);
+            if (!result.success || !result.images || result.images.length === 0) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Image generation failed: ${result.error || "No image generated"}`,
+                };
+            }
+            // Gemini returns base64
+            const image = result.images[0];
+            if (image.base64) {
+                const buffer = Buffer.from(image.base64, "base64");
+                await writeFile(outputPath, buffer);
+            }
+        }
+        else if (provider === "grok") {
+            const { GrokProvider } = await import("@vibeframe/ai-providers");
+            const grok = new GrokProvider();
+            await grok.initialize({ apiKey });
+            const result = await grok.generateImage(prompt);
+            if (!result.success || !result.images || result.images.length === 0) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Image generation failed: ${result.error || "No image generated"}`,
+                };
+            }
+            // Grok returns URLs
+            const image = result.images[0];
+            if (image.url) {
+                const response = await fetch(image.url);
+                const buffer = Buffer.from(await response.arrayBuffer());
+                await writeFile(outputPath, buffer);
+            }
+            else if (image.base64) {
+                const buffer = Buffer.from(image.base64, "base64");
+                await writeFile(outputPath, buffer);
+            }
+        }
+        return {
+            toolCallId: "",
+            success: true,
+            output: `Image generated: ${output}\nPrompt: ${prompt}\nProvider: ${provider}\nSize: ${size}`,
+        };
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Failed to generate image: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const generateVideo = async (args, context) => {
+    const prompt = args.prompt;
+    const provider = args.provider || "grok";
+    const imagePath = args.image;
+    const output = args.output || `${provider}-${getTimestamp()}.mp4`;
+    const duration = args.duration || (provider === "veo" ? 6 : 5);
+    const runwayModel = args.runwayModel || "gen4.5";
+    // Validate: Runway gen4_turbo requires an image; gen4.5 supports text-to-video
+    if (provider === "runway" && !imagePath && runwayModel !== "gen4.5") {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Runway ${runwayModel} requires an input image. Provide 'image' parameter, use 'gen4.5' model, or use provider 'kling'/'veo' for text-to-video.`,
+        };
+    }
+    // Helper to prepare reference image
+    async function prepareReferenceImage(imgPath) {
+        const absImagePath = resolve(context.workingDirectory, imgPath);
+        const imageBuffer = await readFile(absImagePath);
+        const base64 = imageBuffer.toString("base64");
+        const ext = imgPath.split(".").pop()?.toLowerCase() || "png";
+        const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext}`;
+        return `data:${mimeType};base64,${base64}`;
+    }
+    try {
+        if (provider === "runway") {
+            const apiKey = await getApiKeyFromConfig("runway");
+            if (!apiKey) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "Runway API key required. Configure via 'vibe setup'.",
+                };
+            }
+            const { RunwayProvider } = await import("@vibeframe/ai-providers");
+            const runway = new RunwayProvider();
+            await runway.initialize({ apiKey });
+            const referenceImage = imagePath ? await prepareReferenceImage(imagePath) : undefined;
+            const result = await runway.generateVideo(prompt, {
+                prompt,
+                model: runwayModel,
+                duration,
+                referenceImage,
+            });
+            if (result.status === "failed") {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Video generation failed: ${result.error}`,
+                };
+            }
+            if (result.status === "pending" || result.status === "processing") {
+                let finalResult = result;
+                const maxAttempts = 60;
+                for (let i = 0; i < maxAttempts; i++) {
+                    await new Promise((r) => setTimeout(r, 5000));
+                    finalResult = await runway.getGenerationStatus(result.id);
+                    if (finalResult.status === "completed" || finalResult.status === "failed") {
+                        break;
+                    }
+                }
+                if (finalResult.status !== "completed") {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: `Video generation timed out or failed: ${finalResult.error || finalResult.status}`,
+                    };
+                }
+                if (finalResult.videoUrl) {
+                    const outputPath = resolve(context.workingDirectory, output);
+                    const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
+                    await writeFile(outputPath, buffer);
+                }
+            }
+            return {
+                toolCallId: "",
+                success: true,
+                output: `Video generated: ${output}\nProvider: runway\nPrompt: ${prompt}\nDuration: ${duration}s`,
+            };
+        }
+        else if (provider === "veo") {
+            const apiKey = await getApiKeyFromConfig("google");
+            if (!apiKey) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "Google API key required. Configure via 'vibe setup'.",
+                };
+            }
+            const { GeminiProvider } = await import("@vibeframe/ai-providers");
+            const gemini = new GeminiProvider();
+            await gemini.initialize({ apiKey });
+            const referenceImage = imagePath ? await prepareReferenceImage(imagePath) : undefined;
+            const negativePrompt = args.negativePrompt;
+            const resolution = args.resolution;
+            const veoDuration = duration <= 6 ? (duration <= 4 ? 4 : 6) : 8;
+            const result = await gemini.generateVideo(prompt, {
+                prompt,
+                duration: veoDuration,
+                referenceImage,
+                model: "veo-3.1-fast-generate-preview",
+                negativePrompt,
+                resolution,
+            });
+            if (result.status === "failed") {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Veo video generation failed: ${result.error}`,
+                };
+            }
+            if (result.status === "pending" || result.status === "processing") {
+                const finalResult = await gemini.waitForVideoCompletion(result.id, undefined, 300000);
+                if (finalResult.status !== "completed") {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: `Veo video generation timed out or failed: ${finalResult.error || finalResult.status}`,
+                    };
+                }
+                if (finalResult.videoUrl) {
+                    const outputPath = resolve(context.workingDirectory, output);
+                    const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
+                    await writeFile(outputPath, buffer);
+                }
+            }
+            return {
+                toolCallId: "",
+                success: true,
+                output: `Video generated: ${output}\nProvider: veo\nPrompt: ${prompt}\nDuration: ${duration}s`,
+            };
+        }
+        else if (provider === "grok") {
+            const apiKey = await getApiKeyFromConfig("xai");
+            if (!apiKey) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "xAI API key required. Configure via 'vibe setup'.",
+                };
+            }
+            const { GrokProvider } = await import("@vibeframe/ai-providers");
+            const grok = new GrokProvider();
+            await grok.initialize({ apiKey });
+            const referenceImage = imagePath ? await prepareReferenceImage(imagePath) : undefined;
+            const result = await grok.generateVideo(prompt, {
+                prompt,
+                duration,
+                referenceImage,
+                aspectRatio: "16:9",
+            });
+            if (result.status === "failed") {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Grok video generation failed: ${result.error}`,
+                };
+            }
+            if (result.status === "pending" || result.status === "processing") {
+                const finalResult = await grok.waitForCompletion(result.id, undefined, 300000);
+                if (finalResult.status !== "completed") {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: `Grok video generation timed out or failed: ${finalResult.error || finalResult.status}`,
+                    };
+                }
+                if (finalResult.videoUrl) {
+                    const outputPath = resolve(context.workingDirectory, output);
+                    const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
+                    await writeFile(outputPath, buffer);
+                }
+            }
+            return {
+                toolCallId: "",
+                success: true,
+                output: `Video generated: ${output}\nProvider: grok (native audio)\nPrompt: ${prompt}\nDuration: ${duration}s`,
+            };
+        }
+        else {
+            // kling
+            const apiKey = await getApiKeyFromConfig("kling");
+            if (!apiKey) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "Kling API key required. Configure via 'vibe setup'.",
+                };
+            }
+            const { KlingProvider } = await import("@vibeframe/ai-providers");
+            const kling = new KlingProvider();
+            await kling.initialize({ apiKey });
+            let referenceImage = imagePath ? await prepareReferenceImage(imagePath) : undefined;
+            const mode = args.mode || "std";
+            // Kling v2.5+ requires image URL, not base64 — auto-upload to ImgBB
+            if (referenceImage && referenceImage.startsWith("data:")) {
+                const imgbbKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
+                if (!imgbbKey) {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: "Kling requires image URL for image-to-video. Set IMGBB_API_KEY for auto-upload via 'vibe setup'.",
+                    };
+                }
+                const { uploadToImgbb } = await import("../../commands/ai-script-pipeline.js");
+                const base64Data = referenceImage.split(",")[1];
+                const imageBuffer = Buffer.from(base64Data, "base64");
+                const uploadResult = await uploadToImgbb(imageBuffer, imgbbKey);
+                if (!uploadResult.success || !uploadResult.url) {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: `ImgBB upload failed: ${uploadResult.error || "Unknown error"}`,
+                    };
+                }
+                referenceImage = uploadResult.url;
+            }
+            const result = await kling.generateVideo(prompt, {
+                prompt,
+                duration: duration,
+                mode,
+                referenceImage,
+            });
+            if (result.status === "failed") {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Kling video generation failed: ${result.error}`,
+                };
+            }
+            if (result.status === "pending" || result.status === "processing") {
+                let finalResult = result;
+                const maxAttempts = 60;
+                for (let i = 0; i < maxAttempts; i++) {
+                    await new Promise((r) => setTimeout(r, 5000));
+                    finalResult = await kling.getGenerationStatus(result.id);
+                    if (finalResult.status === "completed" || finalResult.status === "failed") {
+                        break;
+                    }
+                }
+                if (finalResult.status !== "completed") {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: `Kling video generation timed out or failed: ${finalResult.error || finalResult.status}`,
+                    };
+                }
+                if (finalResult.videoUrl) {
+                    const outputPath = resolve(context.workingDirectory, output);
+                    const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
+                    await writeFile(outputPath, buffer);
+                }
+            }
+            return {
+                toolCallId: "",
+                success: true,
+                output: `Video generated: ${output}\nProvider: kling\nPrompt: ${prompt}\nDuration: ${duration}s\nMode: ${mode}`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Failed to generate video: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const generateTTS = async (args, context) => {
+    const text = args.text;
+    const output = args.output || `tts-${getTimestamp()}.mp3`;
+    const voice = args.voice;
+    try {
+        const apiKey = await getApiKeyFromConfig("elevenlabs");
+        if (!apiKey) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: "ElevenLabs API key required. Configure via 'vibe setup'.",
+            };
+        }
+        const { ElevenLabsProvider } = await import("@vibeframe/ai-providers");
+        const elevenlabs = new ElevenLabsProvider();
+        await elevenlabs.initialize({ apiKey });
+        const result = await elevenlabs.textToSpeech(text, {
+            voiceId: voice,
+        });
+        if (!result.success || !result.audioBuffer) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: `TTS generation failed: ${result.error || "No audio generated"}`,
+            };
+        }
+        // Save audio
+        const outputPath = resolve(context.workingDirectory, output);
+        await writeFile(outputPath, result.audioBuffer);
+        return {
+            toolCallId: "",
+            success: true,
+            output: `Speech generated: ${output}\nText: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`,
+        };
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Failed to generate speech: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const generateSFX = async (args, context) => {
+    const prompt = args.prompt;
+    const output = args.output || `sfx-${getTimestamp()}.mp3`;
+    const duration = args.duration;
+    try {
+        const apiKey = await getApiKeyFromConfig("elevenlabs");
+        if (!apiKey) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: "ElevenLabs API key required. Configure via 'vibe setup'.",
+            };
+        }
+        const { ElevenLabsProvider } = await import("@vibeframe/ai-providers");
+        const elevenlabs = new ElevenLabsProvider();
+        await elevenlabs.initialize({ apiKey });
+        const result = await elevenlabs.generateSoundEffect(prompt, {
+            duration,
+        });
+        if (!result.success || !result.audioBuffer) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: `SFX generation failed: ${result.error || "No audio generated"}`,
+            };
+        }
+        // Save audio
+        const outputPath = resolve(context.workingDirectory, output);
+        await writeFile(outputPath, result.audioBuffer);
+        return {
+            toolCallId: "",
+            success: true,
+            output: `Sound effect generated: ${output}\nPrompt: ${prompt}`,
+        };
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Failed to generate sound effect: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const generateMusic = async (args, context) => {
+    const prompt = args.prompt;
+    const output = args.output || `music-${getTimestamp()}.mp3`;
+    const duration = args.duration || 8;
+    const provider = args.provider || "elevenlabs";
+    const instrumental = args.instrumental || false;
+    try {
+        if (provider === "elevenlabs") {
+            // ElevenLabs Music API — synchronous, up to 10 minutes
+            const apiKey = await getApiKeyFromConfig("elevenlabs");
+            if (!apiKey) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "ElevenLabs API key required. Configure via 'vibe setup'.",
+                };
+            }
+            const { ElevenLabsProvider } = await import("@vibeframe/ai-providers");
+            const elevenlabs = new ElevenLabsProvider();
+            await elevenlabs.initialize({ apiKey });
+            const result = await elevenlabs.generateMusic(prompt, {
+                duration,
+                forceInstrumental: instrumental,
+            });
+            if (!result.success || !result.audioBuffer) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Music generation failed: ${result.error || "No audio generated"}`,
+                };
+            }
+            const outputPath = resolve(context.workingDirectory, output);
+            await writeFile(outputPath, result.audioBuffer);
+            return {
+                toolCallId: "",
+                success: true,
+                output: `Music generated: ${output}\nPrompt: ${prompt}\nDuration: ${duration}s\nProvider: ElevenLabs${instrumental ? "\nMode: Instrumental" : ""}`,
+            };
+        }
+        else {
+            // Replicate MusicGen — async polling
+            const apiKey = await getApiKeyFromConfig("replicate");
+            if (!apiKey) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: "Replicate API key required. Configure via 'vibe setup'.",
+                };
+            }
+            const { ReplicateProvider } = await import("@vibeframe/ai-providers");
+            const replicate = new ReplicateProvider();
+            await replicate.initialize({ apiKey });
+            const result = await replicate.generateMusic(prompt, {
+                duration,
+            });
+            if (!result.success) {
+                return {
+                    toolCallId: "",
+                    success: false,
+                    output: "",
+                    error: `Music generation failed: ${result.error || "Unknown error"}`,
+                };
+            }
+            // Music generation is async - need to poll
+            if (result.taskId) {
+                let finalResult = result;
+                const maxAttempts = 60;
+                for (let i = 0; i < maxAttempts; i++) {
+                    await new Promise((r) => setTimeout(r, 3000));
+                    finalResult = await replicate.getMusicStatus(result.taskId);
+                    if (finalResult.success && finalResult.audioUrl) {
+                        break;
+                    }
+                    if (finalResult.error) {
+                        return {
+                            toolCallId: "",
+                            success: false,
+                            output: "",
+                            error: `Music generation failed: ${finalResult.error}`,
+                        };
+                    }
+                }
+                if (finalResult.audioUrl) {
+                    const outputPath = resolve(context.workingDirectory, output);
+                    const response = await fetch(finalResult.audioUrl);
+                    const buffer = Buffer.from(await response.arrayBuffer());
+                    await writeFile(outputPath, buffer);
+                }
+                else {
+                    return {
+                        toolCallId: "",
+                        success: false,
+                        output: "",
+                        error: "Music generation timed out",
+                    };
+                }
+            }
+            return {
+                toolCallId: "",
+                success: true,
+                output: `Music generated: ${output}\nPrompt: ${prompt}\nDuration: ${duration}s\nProvider: Replicate`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Failed to generate music: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const generateStoryboard = async (args, context) => {
+    const script = args.script;
+    const targetDuration = args.targetDuration;
+    const output = args.output || `storyboard-${getTimestamp()}.json`;
+    const creativity = args.creativity;
+    try {
+        const apiKey = await getApiKeyFromConfig("anthropic");
+        if (!apiKey) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: "Anthropic API key required. Configure via 'vibe setup'.",
+            };
+        }
+        const { ClaudeProvider } = await import("@vibeframe/ai-providers");
+        const claude = new ClaudeProvider();
+        await claude.initialize({ apiKey });
+        const result = await claude.analyzeContent(script, targetDuration, { creativity });
+        if (!result || result.length === 0) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: "",
+                error: "Failed to generate storyboard",
+            };
+        }
+        // Save storyboard
+        const outputPath = resolve(context.workingDirectory, output);
+        await writeFile(outputPath, JSON.stringify(result, null, 2), "utf-8");
+        // Format summary
+        const sanitizedResult = sanitizeAIResult(result);
+        const summary = sanitizedResult.map((scene, i) => `Scene ${i + 1}: ${scene.description.substring(0, 60)}...`).join("\n");
+        return {
+            toolCallId: "",
+            success: true,
+            output: `Storyboard generated: ${output}\n\n${summary}`,
+        };
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Failed to generate storyboard: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const generateMotion = async (args, context) => {
+    try {
+        const { executeMotion } = await import("../../commands/ai-motion.js");
+        const video = args.video
+            ? resolve(context.workingDirectory, args.video)
+            : undefined;
+        const output = args.output
+            ? resolve(context.workingDirectory, args.output)
+            : undefined;
+        const result = await executeMotion({
+            description: args.description,
+            duration: args.duration,
+            width: args.width,
+            height: args.height,
+            style: args.style,
+            render: true, // Always render in agent mode
+            video,
+            output,
+        });
+        if (!result.success) {
+            return {
+                toolCallId: "",
+                success: false,
+                output: result.codePath ? `TSX code saved to: ${result.codePath}` : "",
+                error: result.error || "Motion generation failed",
+            };
+        }
+        const parts = [];
+        if (result.codePath)
+            parts.push(`Code: ${result.codePath}`);
+        if (result.renderedPath)
+            parts.push(`Rendered: ${result.renderedPath}`);
+        if (result.compositedPath)
+            parts.push(`Composited: ${result.compositedPath}`);
+        return {
+            toolCallId: "",
+            success: true,
+            output: parts.join("\n"),
+        };
+    }
+    catch (error) {
+        return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: `Motion generation failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+// ============================================================================
+// Registration
+// ============================================================================
+export function registerGenerationTools(registry) {
+    registry.register(imageDef, generateImage);
+    registry.register(videoDef, generateVideo);
+    registry.register(ttsDef, generateTTS);
+    registry.register(sfxDef, generateSFX);
+    registry.register(musicDef, generateMusic);
+    registry.register(storyboardDef, generateStoryboard);
+    registry.register(motionDef, generateMotion);
+}
+//# sourceMappingURL=ai-generation.js.map