@vibeframe/cli 0.55.0 → 0.55.1

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

@@ -1,973 +0,0 @@
-/**
- * @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