@vibeframe/mcp-server 0.20.0 → 0.29.0

package/dist/index.js

@@ -60,6 +60,7 @@ __export(remotion_exports, {
   compositeOverlay: () => compositeOverlay,
   compositeWithImage: () => compositeWithImage,
   ensureRemotionInstalled: () => ensureRemotionInstalled,
+  generateAnimatedCaptionComponent: () => generateAnimatedCaptionComponent,
   generateCaptionComponent: () => generateCaptionComponent,
   renderAndComposite: () => renderAndComposite,
   renderMotion: () => renderMotion,
@@ -491,6 +492,190 @@ export const ${name} = () => {
 `;
   return { code, name };
 }
+function generateAnimatedCaptionComponent(options) {
+  const { groups, style, highlightColor, fontSize, position, width, fps, videoFileName } = options;
+  const name = videoFileName ? "VideoAnimatedCaption" : "AnimatedCaptionOverlay";
+  const groupsJSON = JSON.stringify(
+    groups.map((g) => ({
+      words: g.words.map((w) => ({ word: w.word, start: w.start, end: w.end })),
+      startTime: g.startTime,
+      endTime: g.endTime,
+      text: g.text
+    }))
+  );
+  const justifyContent = position === "top" ? "flex-start" : position === "center" ? "center" : "flex-end";
+  const paddingDir = position === "top" ? "paddingTop" : position === "bottom" ? "paddingBottom" : "";
+  const paddingVal = position === "center" ? "" : `${paddingDir}: 40,`;
+  const videoImport = videoFileName ? `, staticFile` : "";
+  const videoElement = videoFileName ? `<Video src={staticFile("${videoFileName}")} style={{ width: "100%", height: "100%" }} muted />` : "";
+  const videoMediaImport = videoFileName ? `import { Video } from "@remotion/media";
+` : "";
+  let wordRenderer;
+  switch (style) {
+    case "highlight":
+      wordRenderer = `
+    const isActive = currentTime >= w.start && currentTime < w.end;
+    const bgOpacity = isActive ? 1 : 0;
+    return (
+      <span
+        key={wi}
+        style={{
+          display: "inline-block",
+          padding: "2px 6px",
+          margin: "0 2px",
+          borderRadius: 4,
+          backgroundColor: isActive ? "${highlightColor}" : "transparent",
+          color: isActive ? "#000000" : "#FFFFFF",
+          transition: "background-color 0.1s",
+          fontWeight: "bold",
+          textShadow: isActive ? "none" : "2px 2px 4px rgba(0,0,0,0.8)",
+        }}
+      >
+        {w.word}
+      </span>
+    );`;
+      break;
+    case "bounce":
+      wordRenderer = `
+    const isActive = currentTime >= w.start && currentTime < w.end;
+    const entryFrame = w.start * ${fps};
+    const progress = Math.min(1, Math.max(0, (frame - entryFrame) / 5));
+    const springVal = isActive
+      ? 1 + Math.sin(progress * Math.PI) * 0.15
+      : 1;
+    const translateY = isActive
+      ? -Math.sin(progress * Math.PI) * 8
+      : 0;
+    return (
+      <span
+        key={wi}
+        style={{
+          display: "inline-block",
+          margin: "0 3px",
+          transform: \`scale(\${springVal}) translateY(\${translateY}px)\`,
+          color: isActive ? "${highlightColor}" : "#FFFFFF",
+          fontWeight: "bold",
+          textShadow: "2px 2px 4px rgba(0,0,0,0.8)",
+        }}
+      >
+        {w.word}
+      </span>
+    );`;
+      break;
+    case "pop-in":
+      wordRenderer = `
+    const entryFrame = w.start * ${fps};
+    const scale = frame >= entryFrame
+      ? Math.min(1, (frame - entryFrame) / 5)
+      : 0;
+    const isActive = currentTime >= w.start && currentTime < w.end;
+    return (
+      <span
+        key={wi}
+        style={{
+          display: "inline-block",
+          margin: "0 3px",
+          transform: \`scale(\${scale})\`,
+          opacity: scale,
+          color: isActive ? "${highlightColor}" : "#FFFFFF",
+          fontWeight: "bold",
+          textShadow: "2px 2px 4px rgba(0,0,0,0.8)",
+        }}
+      >
+        {w.word}
+      </span>
+    );`;
+      break;
+    case "neon":
+      wordRenderer = `
+    const isActive = currentTime >= w.start && currentTime < w.end;
+    const pulse = isActive ? 0.8 + Math.sin(frame * 0.3) * 0.2 : 0.5;
+    const glowSize = isActive ? 15 : 0;
+    return (
+      <span
+        key={wi}
+        style={{
+          display: "inline-block",
+          margin: "0 3px",
+          color: isActive ? "${highlightColor}" : "#FFFFFF",
+          fontWeight: "bold",
+          opacity: isActive ? 1 : pulse,
+          textShadow: isActive
+            ? \`0 0 \${glowSize}px ${highlightColor}, 0 0 \${glowSize * 2}px ${highlightColor}, 0 0 \${glowSize * 3}px ${highlightColor}\`
+            : "2px 2px 4px rgba(0,0,0,0.8)",
+        }}
+      >
+        {w.word}
+      </span>
+    );`;
+      break;
+  }
+  const code = `import { AbsoluteFill, useCurrentFrame, useVideoConfig${videoImport} } from "remotion";
+${videoMediaImport}
+interface Word {
+  word: string;
+  start: number;
+  end: number;
+}
+
+interface WordGroup {
+  words: Word[];
+  startTime: number;
+  endTime: number;
+  text: string;
+}
+
+const groups: WordGroup[] = ${groupsJSON};
+
+export const ${name} = () => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const currentTime = frame / fps;
+
+  const activeGroup = groups.find(
+    (g) => currentTime >= g.startTime && currentTime < g.endTime
+  );
+
+  const renderWord = (w: Word, wi: number) => {
+    ${wordRenderer}
+  };
+
+  return (
+    <AbsoluteFill>
+      ${videoElement}
+      {activeGroup && (
+        <AbsoluteFill
+          style={{
+            display: "flex",
+            justifyContent: "${justifyContent}",
+            alignItems: "center",
+            ${paddingVal}
+          }}
+        >
+          <div
+            style={{
+              fontSize: ${fontSize},
+              fontFamily: "Arial, Helvetica, sans-serif",
+              textAlign: "center" as const,
+              maxWidth: "${Math.round(width * 0.9)}px",
+              lineHeight: 1.5,
+              padding: "8px 16px",
+              display: "flex",
+              flexWrap: "wrap" as const,
+              justifyContent: "center",
+              gap: "0px",
+            }}
+          >
+            {activeGroup.words.map((w, wi) => renderWord(w, wi))}
+          </div>
+        </AbsoluteFill>
+      )}
+    </AbsoluteFill>
+  );
+};
+`;
+  return { code, name };
+}
 async function compositeOverlay(options) {
   try {
     await execSafe("ffmpeg", [
@@ -1694,7 +1879,18 @@ function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, so
       if (hasAudio) {
         const audioTrimStart = clip.sourceStartOffset;
         const audioTrimEnd = clip.sourceStartOffset + clip.duration;
-        audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+        const sourceDuration = source.duration || 0;
+        const clipDuration = clip.duration;
+        if (source.type === "audio" && sourceDuration > clipDuration && audioTrimStart === 0) {
+          const tempo = sourceDuration / clipDuration;
+          if (tempo <= 2) {
+            audioFilter = `[${srcIdx}:a]atempo=${tempo.toFixed(4)},asetpts=PTS-STARTPTS`;
+          } else {
+            audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+          }
+        } else {
+          audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+        }
       } else {
         audioFilter = `anullsrc=r=48000:cl=stereo,atrim=0:${clip.duration},asetpts=PTS-STARTPTS`;
       }
@@ -1742,7 +1938,7 @@ function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, so
   return args;
 }
 function runFFmpegProcess(ffmpegPath, args, onProgress) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve12, reject) => {
     const ffmpeg = spawn(ffmpegPath, args, {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1766,7 +1962,7 @@ function runFFmpegProcess(ffmpegPath, args, onProgress) {
     });
     ffmpeg.on("close", (code) => {
       if (code === 0) {
-        resolve13();
+        resolve12();
       } else {
         const errorMatch = stderr.match(/Error.*$/m);
         const errorMsg = errorMatch ? errorMatch[0] : `FFmpeg exited with code ${code}`;
@@ -2487,8 +2683,11 @@ async function analyzeContent(api, content, targetDuration, options) {
 // ../ai-providers/dist/gemini/GeminiProvider.js
 var MODEL_MAP = {
   "flash": "gemini-2.5-flash-image",
+  "3.1-flash": "gemini-3.1-flash-image-preview",
+  "latest": "gemini-3.1-flash-image-preview",
   "pro": "gemini-3-pro-image-preview",
   "gemini-2.5-flash-image": "gemini-2.5-flash-image",
+  "gemini-3.1-flash-image-preview": "gemini-3.1-flash-image-preview",
   "gemini-3-pro-image-preview": "gemini-3-pro-image-preview"
 };
 var GeminiProvider = class {
@@ -2523,36 +2722,57 @@ var GeminiProvider = class {
       };
     }
     try {
-      const model = options?.model || "veo-3.1-fast-generate-preview";
+      const veoOpts = options ?? {};
+      const model = veoOpts.model || "veo-3.1-fast-generate-preview";
       const aspectRatioMap = {
         "16:9": "16:9",
         "9:16": "9:16",
         "1:1": "1:1"
       };
-      const requestBody = {
-        instances: [{
-          prompt: prompt2
-        }],
-        parameters: {
-          aspectRatio: aspectRatioMap[options?.aspectRatio || "16:9"] || "16:9",
-          durationSeconds: Math.max(4, Math.min(8, options?.duration || 8))
-        }
+      const parameters = {
+        aspectRatio: aspectRatioMap[veoOpts.aspectRatio || "16:9"] || "16:9",
+        durationSeconds: Math.max(4, Math.min(8, veoOpts.duration || 8))
       };
-      if (options?.referenceImage) {
-        const imageData = options.referenceImage;
+      if (veoOpts.negativePrompt) {
+        parameters.negativePrompt = veoOpts.negativePrompt;
+      }
+      if (veoOpts.resolution) {
+        parameters.resolution = veoOpts.resolution;
+      }
+      if (veoOpts.personGeneration) {
+        parameters.personGeneration = veoOpts.personGeneration;
+      }
+      const instance = { prompt: prompt2 };
+      if (veoOpts.referenceImage) {
+        const imageData = veoOpts.referenceImage;
         if (imageData.startsWith("data:")) {
           const base64 = imageData.split(",")[1];
           const mimeType = imageData.split(";")[0].split(":")[1];
-          requestBody.instances[0].image = {
-            bytesBase64Encoded: base64,
-            mimeType
-          };
+          instance.image = { bytesBase64Encoded: base64, mimeType };
         } else if (imageData.startsWith("http")) {
-          requestBody.instances[0].image = {
-            gcsUri: imageData
-          };
+          instance.image = { gcsUri: imageData };
         }
       }
+      if (veoOpts.lastFrame) {
+        const lastFrameData = veoOpts.lastFrame;
+        if (lastFrameData.startsWith("data:")) {
+          const base64 = lastFrameData.split(",")[1];
+          const mimeType = lastFrameData.split(";")[0].split(":")[1];
+          instance.lastFrame = { bytesBase64Encoded: base64, mimeType };
+        } else if (lastFrameData.startsWith("http")) {
+          instance.lastFrame = { gcsUri: lastFrameData };
+        }
+      }
+      if (veoOpts.referenceImages && veoOpts.referenceImages.length > 0) {
+        instance.referenceImages = veoOpts.referenceImages.slice(0, 3).map((img) => ({
+          bytesBase64Encoded: img.base64,
+          mimeType: img.mimeType
+        }));
+      }
+      const requestBody = {
+        instances: [instance],
+        parameters
+      };
       const response = await fetch(`${this.baseUrl}/models/${model}:predictLongRunning`, {
         method: "POST",
         headers: {
@@ -2687,7 +2907,70 @@ var GeminiProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve13) => setTimeout(resolve13, ms));
+    return new Promise((resolve12) => setTimeout(resolve12, ms));
+  }
+  /**
+   * Extend a previously generated Veo video
+   * Uses the operation name from a completed generation to create a continuation
+   */
+  async extendVideo(previousOperationName, prompt2, options) {
+    if (!this.apiKey) {
+      return {
+        id: "",
+        status: "failed",
+        error: "Gemini API key not configured"
+      };
+    }
+    try {
+      const model = options?.model || "veo-3.1-generate-preview";
+      const instance = {
+        video: { previousOperationName }
+      };
+      if (prompt2) {
+        instance.prompt = prompt2;
+      }
+      const requestBody = {
+        instances: [instance],
+        parameters: {
+          durationSeconds: Math.max(4, Math.min(8, options?.duration || 6))
+        }
+      };
+      const response = await fetch(`${this.baseUrl}/models/${model}:predictLongRunning`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": this.apiKey
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          id: "",
+          status: "failed",
+          error: `Veo extend API error (${response.status}): ${errorText}`
+        };
+      }
+      const data = await response.json();
+      if (data.name) {
+        return {
+          id: data.name,
+          status: "pending",
+          progress: 0
+        };
+      }
+      return {
+        id: "",
+        status: "failed",
+        error: data.error?.message || "Unknown Veo extend error"
+      };
+    } catch (error) {
+      return {
+        id: "",
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
   }
   async cancelGeneration(_id) {
     return false;
@@ -2726,18 +3009,26 @@ var GeminiProvider = class {
       } else {
         imageConfig.aspectRatio = "1:1";
       }
-      if (options.resolution && isPro) {
-        imageConfig.imageSize = options.resolution;
+      if (options.resolution) {
+        if (options.resolution === "512px" || options.resolution === "1K" || isPro) {
+          imageConfig.imageSize = options.resolution;
+        }
       }
       const generationConfig = {
         responseModalities: ["TEXT", "IMAGE"],
         imageConfig
       };
+      if (options.thinkingConfig) {
+        generationConfig.thinkingConfig = options.thinkingConfig;
+      }
       const payload = {
         contents: [{ parts: [{ text: prompt2 }] }],
         generationConfig
       };
-      if (options.grounding && isPro) {
+      const is31Flash = modelId === "gemini-3.1-flash-image-preview";
+      if (options.imageSearchGrounding && is31Flash) {
+        payload.tools = [{ googleSearch: { searchTypes: { webSearch: {}, imageSearch: {} } } }];
+      } else if (options.grounding && isPro) {
         payload.tools = [{ googleSearch: {} }];
       }
       const response = await fetch(`${this.baseUrl}/models/${modelId}:generateContent?key=${this.apiKey}`, {
@@ -2764,9 +3055,12 @@ var GeminiProvider = class {
       const data = await response.json();
       const parts = data.candidates?.[0]?.content?.parts;
       if (!parts || parts.length === 0) {
+        const finishReason = data.candidates?.[0]?.finishReason;
+        const blockReason = data.promptFeedback?.blockReason;
+        const detail = blockReason ? `Blocked by safety filter: ${blockReason}` : finishReason ? `Model returned no image (finishReason: ${finishReason})` : "No content in response";
         return {
           success: false,
-          error: "No content in response"
+          error: detail
         };
       }
       const images = [];
@@ -2873,9 +3167,12 @@ var GeminiProvider = class {
       const data = await response.json();
       const responseParts = data.candidates?.[0]?.content?.parts;
       if (!responseParts || responseParts.length === 0) {
+        const finishReason = data.candidates?.[0]?.finishReason;
+        const blockReason = data.promptFeedback?.blockReason;
+        const detail = blockReason ? `Blocked by safety filter: ${blockReason}` : finishReason ? `Model returned no image (finishReason: ${finishReason})` : "No content in response";
         return {
           success: false,
-          error: "No content in response"
+          error: detail
         };
       }
       const images = [];
@@ -3130,7 +3427,7 @@ Example response:
 [{"type":"trim","description":"Trim intro to 3 seconds","clipIds":["clip-1"],"params":{"newDuration":3},"confidence":0.9}]
 
 Respond with ONLY the JSON array, no other text.`;
-      const response = await fetch(`${this.baseUrl}/models/gemini-1.5-flash:generateContent?key=${this.apiKey}`, {
+      const response = await fetch(`${this.baseUrl}/models/gemini-2.5-flash:generateContent?key=${this.apiKey}`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -3257,7 +3554,7 @@ async function analyzeContent2(apiKey, content, targetDuration, options) {
         Authorization: `Bearer ${apiKey}`
       },
       body: JSON.stringify({
-        model: "gpt-4o",
+        model: "gpt-5-mini",
         messages: [
           { role: "system", content: systemPrompt },
           { role: "user", content: buildStoryboardUserMessage(content) }
@@ -3309,7 +3606,7 @@ var OpenAIProvider = class {
     this.iconUrl = "/icons/openai.svg";
     this.isAvailable = true;
     this.baseUrl = "https://api.openai.com/v1";
-    this.model = "gpt-4o-mini";
+    this.model = "gpt-5-mini";
   }
   async initialize(config2) {
     this.apiKey = config2.apiKey;
@@ -3616,7 +3913,7 @@ Each segment should be 3-10 seconds long.`;
           Authorization: `Bearer ${this.apiKey}`
         },
         body: JSON.stringify({
-          model: "gpt-4o",
+          model: "gpt-5-mini",
           max_tokens: 4096,
           response_format: { type: "json_object" },
           messages: [
@@ -3650,7 +3947,7 @@ ${videoAnalysis}` }
     }
   }
   /**
-   * Generate a storyboard from script content using GPT-4o.
+   * Generate a storyboard from script content using GPT-5-mini.
    * Alternative to ClaudeProvider.analyzeContent for when Claude is unavailable.
    */
   async analyzeContent(content, targetDuration, options) {
@@ -5575,7 +5872,7 @@ var ElevenLabsProvider = class {
     this.id = "elevenlabs";
     this.name = "ElevenLabs";
     this.description = "AI text-to-speech with natural voices and voice cloning";
-    this.capabilities = ["text-to-speech", "sound-generation", "audio-isolation", "voice-clone"];
+    this.capabilities = ["text-to-speech", "sound-generation", "music-generation", "audio-isolation", "voice-clone"];
     this.iconUrl = "/icons/elevenlabs.svg";
     this.isAvailable = true;
     this.baseUrl = "https://api.elevenlabs.io/v1";
@@ -5633,7 +5930,7 @@ var ElevenLabsProvider = class {
           error: voiceError instanceof Error ? voiceError.message : String(voiceError)
         };
       }
-      const model = options.model || "eleven_multilingual_v2";
+      const model = options.model || "eleven_v3";
       const response = await fetch(`${this.baseUrl}/text-to-speech/${voiceId}`, {
         method: "POST",
         headers: {
@@ -5746,6 +6043,60 @@ var ElevenLabsProvider = class {
       };
     }
   }
+  /**
+   * Generate music from text prompt
+   */
+  async generateMusic(prompt2, options = {}) {
+    if (!this.apiKey) {
+      return {
+        success: false,
+        error: "ElevenLabs API key not configured"
+      };
+    }
+    try {
+      const body = {
+        prompt: prompt2,
+        model_id: "music_v1"
+      };
+      if (options.duration !== void 0) {
+        const duration = Math.max(3, Math.min(600, options.duration));
+        body.music_length_ms = duration * 1e3;
+      }
+      if (options.forceInstrumental !== void 0) {
+        body.force_instrumental = options.forceInstrumental;
+      }
+      if (options.seed !== void 0) {
+        body.seed = options.seed;
+      }
+      const response = await fetch(`${this.baseUrl}/music`, {
+        method: "POST",
+        headers: {
+          "xi-api-key": this.apiKey,
+          "Content-Type": "application/json",
+          Accept: "audio/mpeg"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        return {
+          success: false,
+          error: `Music generation failed: ${error}`
+        };
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const audioBuffer = Buffer.from(arrayBuffer);
+      return {
+        success: true,
+        audioBuffer
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
   /**
    * Isolate vocals from audio
    * Separates the vocal track from the background music/noise
@@ -5896,7 +6247,7 @@ var OpenAIImageProvider = class {
     this.id = "openai-image";
     this.name = "OpenAI GPT Image";
     this.description = "AI image generation with GPT Image 1.5 (fastest, best quality)";
-    this.capabilities = ["text-to-image", "background-removal"];
+    this.capabilities = ["text-to-image", "background-removal", "image-editing"];
     this.iconUrl = "/icons/openai.svg";
     this.isAvailable = true;
     this.baseUrl = "https://api.openai.com/v1";
@@ -6026,6 +6377,76 @@ var OpenAIImageProvider = class {
       quality: "high"
     });
   }
+  /**
+   * Edit images using GPT Image 1.5
+   * Supports up to 16 input images with text instruction-based editing
+   */
+  async editImage(imageBuffers, prompt2, options = {}) {
+    if (!this.apiKey) {
+      return {
+        success: false,
+        error: "OpenAI API key not configured"
+      };
+    }
+    try {
+      const formData = new FormData();
+      formData.append("model", options.model || DEFAULT_MODEL);
+      formData.append("prompt", prompt2);
+      for (const buf of imageBuffers) {
+        const uint8Array = new Uint8Array(buf);
+        formData.append("image[]", new Blob([uint8Array], { type: "image/png" }), "image.png");
+      }
+      if (options.mask) {
+        const maskUint8 = new Uint8Array(options.mask);
+        formData.append("mask", new Blob([maskUint8], { type: "image/png" }), "mask.png");
+      }
+      if (options.quality) {
+        formData.append("quality", options.quality);
+      }
+      if (options.size) {
+        formData.append("size", options.size);
+      }
+      const response = await fetch(`${this.baseUrl}/images/edits`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `API error: ${response.status}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          if (errorJson.error?.message) {
+            errorMessage = errorJson.error.message;
+          }
+        } catch {
+          if (errorText) {
+            errorMessage = errorText.substring(0, 200);
+          }
+        }
+        return {
+          success: false,
+          error: errorMessage
+        };
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        images: data.data.map((img) => ({
+          base64: img.b64_json,
+          url: img.url,
+          revisedPrompt: img.revised_prompt
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
   /**
    * Create image variations (uses DALL-E 2)
    */
@@ -6039,7 +6460,7 @@ var OpenAIImageProvider = class {
     try {
       const formData = new FormData();
       const uint8Array = new Uint8Array(imageBuffer);
-      formData.append("image", new Blob([uint8Array]), "image.png");
+      formData.append("image", new Blob([uint8Array], { type: "image/png" }), "image.png");
       formData.append("model", "dall-e-2");
       formData.append("n", String(options.n || 1));
       formData.append("size", options.size || "1024x1024");
@@ -6073,7 +6494,7 @@ var OpenAIImageProvider = class {
 var openaiImageProvider = new OpenAIImageProvider();
 
 // ../ai-providers/dist/runway/RunwayProvider.js
-var DEFAULT_MODEL2 = "gen4_turbo";
+var DEFAULT_MODEL2 = "gen4.5";
 var RunwayProvider = class {
   constructor() {
     this.id = "runway";
@@ -6117,25 +6538,29 @@ var RunwayProvider = class {
       };
       const apiRatio = ratioMap[options?.aspectRatio || "16:9"] || "1280:720";
       const model = options?.model || DEFAULT_MODEL2;
-      if (!options?.referenceImage) {
+      if (!options?.referenceImage && model !== "gen4.5") {
         return {
           id: "",
           status: "failed",
-          error: "Runway Gen-4 requires an input image. Use -i <image> to specify an image."
+          error: `Runway ${model} requires an input image. Use -i <image> or switch to gen4.5 for text-to-video.`
         };
       }
-      const imageData = typeof options.referenceImage === "string" ? options.referenceImage : await this.blobToDataUri(options.referenceImage);
+      const hasImage = !!options?.referenceImage;
+      const endpoint = hasImage ? "image_to_video" : "text_to_video";
       const body = {
         model,
         promptText: prompt2,
-        promptImage: imageData,
         ratio: apiRatio,
-        duration: options?.duration === 10 ? 10 : 5
+        duration: this.clampDuration(options?.duration, model)
       };
+      if (hasImage) {
+        const imageData = typeof options.referenceImage === "string" ? options.referenceImage : await this.blobToDataUri(options.referenceImage);
+        body.promptImage = imageData;
+      }
       if (options?.seed !== void 0) {
         body.seed = options.seed;
       }
-      const response = await fetch(`${this.baseUrl}/image_to_video`, {
+      const response = await fetch(`${this.baseUrl}/${endpoint}`, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${this.apiKey}`,
@@ -6302,6 +6727,16 @@ var RunwayProvider = class {
       error: "Generation timed out"
     };
   }
+  /**
+   * Clamp duration to valid range for the given model
+   */
+  clampDuration(duration, model) {
+    if (model === "gen4.5") {
+      const d = duration ?? 5;
+      return Math.max(2, Math.min(10, Math.round(d)));
+    }
+    return duration === 10 ? 10 : 5;
+  }
   /**
    * Convert Blob to data URI
    */
@@ -6315,7 +6750,7 @@ var RunwayProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve13) => setTimeout(resolve13, ms));
+    return new Promise((resolve12) => setTimeout(resolve12, ms));
   }
 };
 var runwayProvider = new RunwayProvider();
@@ -6323,7 +6758,7 @@ var runwayProvider = new RunwayProvider();
 // ../ai-providers/dist/kling/KlingProvider.js
 import { createHmac } from "node:crypto";
 var DEFAULT_MODEL3 = "kling-v2-5-turbo";
-var STD_MODE_MODELS = ["kling-v2-5-turbo", "kling-v2-6"];
+var STD_MODE_MODELS = ["kling-v2-5-turbo", "kling-v2-6", "kling-v3", "kling-v3-omni"];
 var KlingProvider = class {
   constructor() {
     this.id = "kling";
@@ -6419,14 +6854,14 @@ var KlingProvider = class {
             return {
               id: "",
               status: "failed",
-              error: "Kling v2.5/v2.6 requires image URL, not base64. Upload image to a hosting service first."
+              error: "Kling v2.5+ requires image URL, not base64. Upload image to a hosting service first."
             };
           }
         } else {
           return {
             id: "",
             status: "failed",
-            error: "Kling v2.5/v2.6 requires image URL, not Blob. Upload image to a hosting service first."
+            error: "Kling v2.5+ requires image URL, not Blob. Upload image to a hosting service first."
           };
         }
         const response2 = await fetch(`${this.baseUrl}/videos/image2video`, {
@@ -6731,7 +7166,7 @@ var KlingProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve13) => setTimeout(resolve13, ms));
+    return new Promise((resolve12) => setTimeout(resolve12, ms));
   }
 };
 var klingProvider = new KlingProvider();
@@ -6743,7 +7178,7 @@ var GrokProvider = class {
     this.id = "grok";
     this.name = "xAI Grok Imagine";
     this.description = "AI video generation with Grok Imagine (native audio, 1-15 sec)";
-    this.capabilities = ["text-to-video", "image-to-video"];
+    this.capabilities = ["text-to-video", "image-to-video", "text-to-image", "image-editing"];
     this.iconUrl = "/icons/xai.svg";
     this.isAvailable = true;
     this.baseUrl = "https://api.x.ai/v1";
@@ -6759,33 +7194,29 @@ var GrokProvider = class {
     return !!this.apiKey;
   }
   /**
-   * Generate video using Grok Imagine
+   * Generate image using Grok Imagine
    */
-  async generateVideo(prompt2, options) {
+  async generateImage(prompt2, options = {}) {
     if (!this.apiKey) {
       return {
-        id: "",
-        status: "failed",
+        success: false,
         error: "xAI API key not configured. Set XAI_API_KEY environment variable."
       };
     }
     try {
-      const duration = Math.min(15, Math.max(1, options?.duration || 5));
       const body = {
-        model: DEFAULT_MODEL4,
+        model: options.model || "grok-imagine-image",
         prompt: prompt2,
-        duration,
-        aspect_ratio: options?.aspectRatio || "16:9"
+        n: options.n || 1,
+        response_format: options.responseFormat || "url"
       };
-      if (options?.referenceImage) {
-        const imageData = options.referenceImage;
-        if (imageData.startsWith("http")) {
-          body.image_url = imageData;
-        } else if (imageData.startsWith("data:")) {
-          body.image = imageData;
-        }
+      if (options.aspectRatio) {
+        body.aspect_ratio = options.aspectRatio;
       }
-      const response = await fetch(`${this.baseUrl}/video/generations`, {
+      if (options.resolution) {
+        body.resolution = options.resolution;
+      }
+      const response = await fetch(`${this.baseUrl}/images/generations`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -6795,210 +7226,29 @@ var GrokProvider = class {
       });
       if (!response.ok) {
         const errorText = await response.text();
-        return {
-          id: "",
-          status: "failed",
-          error: `Grok API error (${response.status}): ${errorText}`
-        };
-      }
-      const data = await response.json();
-      return {
-        id: data.id,
-        status: data.status === "completed" ? "completed" : "pending",
-        videoUrl: data.video_url
-      };
-    } catch (error) {
-      return {
-        id: "",
-        status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Get generation status
-   */
-  async getGenerationStatus(id) {
-    if (!this.apiKey) {
-      return {
-        id,
-        status: "failed",
-        error: "xAI API key not configured"
-      };
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}/video/generations/${id}`, {
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        return {
-          id,
-          status: "failed",
-          error: `Failed to get status: ${errorText}`
-        };
-      }
-      const data = await response.json();
-      const statusMap = {
-        pending: "pending",
-        processing: "processing",
-        completed: "completed",
-        failed: "failed"
-      };
-      return {
-        id: data.id,
-        status: statusMap[data.status] || "pending",
-        videoUrl: data.video_url,
-        error: data.error
-      };
-    } catch (error) {
-      return {
-        id,
-        status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Wait for generation to complete
-   */
-  async waitForCompletion(id, onProgress, maxWaitMs = 3e5) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < maxWaitMs) {
-      const result = await this.getGenerationStatus(id);
-      if (onProgress) {
-        onProgress(result);
-      }
-      if (result.status === "completed" || result.status === "failed") {
-        return result;
-      }
-      await this.sleep(this.pollingInterval);
-    }
-    return {
-      id,
-      status: "failed",
-      error: "Generation timed out"
-    };
-  }
-  /**
-   * Cancel generation (if supported)
-   */
-  async cancelGeneration(id) {
-    if (!this.apiKey)
-      return false;
-    try {
-      const response = await fetch(`${this.baseUrl}/video/generations/${id}`, {
-        method: "DELETE",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  sleep(ms) {
-    return new Promise((resolve13) => setTimeout(resolve13, ms));
-  }
-};
-var grokProvider = new GrokProvider();
-
-// ../ai-providers/dist/stability/StabilityProvider.js
-var StabilityProvider = class {
-  constructor() {
-    this.id = "stability";
-    this.name = "Stability AI";
-    this.description = "Stable Diffusion image generation with SD3.5 and SDXL";
-    this.capabilities = ["background-removal", "upscale", "search-replace", "outpaint"];
-    this.iconUrl = "/icons/stability.svg";
-    this.isAvailable = true;
-    this.baseUrl = "https://api.stability.ai";
-    this.modelMapping = {
-      "sd3.5-large": ["sd3", "sd3.5-large"],
-      "sd3.5-large-turbo": ["sd3", "sd3.5-large-turbo"],
-      "sd3.5-medium": ["sd3", "sd3.5-medium"],
-      "sd3-large": ["sd3", "sd3-large"],
-      "sd3-medium": ["sd3", "sd3-medium"],
-      "stable-image-core": ["core", null],
-      "stable-image-ultra": ["ultra", null]
-    };
-  }
-  async initialize(config2) {
-    this.apiKey = config2.apiKey;
-    if (config2.baseUrl) {
-      this.baseUrl = config2.baseUrl;
-    }
-  }
-  isConfigured() {
-    return !!this.apiKey;
-  }
-  /**
-   * Generate images from text prompt using SD3.5 or newer models
-   */
-  async generateImage(prompt2, options = {}) {
-    if (!this.apiKey) {
-      return {
-        success: false,
-        error: "Stability AI API key not configured"
-      };
-    }
-    try {
-      const model = options.model || "sd3.5-large";
-      const [endpoint, modelParam] = this.modelMapping[model] || ["sd3", model];
-      const formData = new FormData();
-      formData.append("prompt", prompt2);
-      formData.append("output_format", options.outputFormat || "png");
-      if (modelParam) {
-        formData.append("model", modelParam);
-      }
-      if (options.negativePrompt) {
-        formData.append("negative_prompt", options.negativePrompt);
-      }
-      if (options.aspectRatio) {
-        formData.append("aspect_ratio", options.aspectRatio);
-      }
-      if (options.seed !== void 0) {
-        formData.append("seed", String(options.seed));
-      }
-      if (options.stylePreset) {
-        formData.append("style_preset", options.stylePreset);
-      }
-      const response = await fetch(`${this.baseUrl}/v2beta/stable-image/generate/${endpoint}`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
-        },
-        body: formData
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage;
+        let errorMessage = `API error: ${response.status}`;
         try {
-          const errorData = JSON.parse(errorText);
-          errorMessage = errorData.message || errorData.error || errorText;
+          const errorJson = JSON.parse(errorText);
+          if (errorJson.error?.message) {
+            errorMessage = errorJson.error.message;
+          }
         } catch {
-          errorMessage = errorText;
+          if (errorText) {
+            errorMessage = errorText.substring(0, 200);
+          }
         }
         return {
           success: false,
-          error: `API error (${response.status}): ${errorMessage}`
+          error: errorMessage
         };
       }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      const seed = response.headers.get("seed");
-      const finishReason = response.headers.get("finish-reason");
+      const data = await response.json();
       return {
         success: true,
-        images: [{
-          base64,
-          seed: seed ? parseInt(seed) : void 0,
-          finishReason: finishReason || void 0
-        }]
+        images: data.data.map((img) => ({
+          url: img.url,
+          base64: img.b64_json
+        }))
       };
     } catch (error) {
       return {
@@ -7008,77 +7258,64 @@ var StabilityProvider = class {
     }
   }
   /**
-   * Generate image using legacy SDXL API (supports more options)
+   * Edit image using Grok Imagine
+   * Supports single image input with text instruction-based editing
    */
-  async generateImageSDXL(prompt2, options = {}) {
+  async editImage(imageBuffer, prompt2, options = {}) {
     if (!this.apiKey) {
       return {
         success: false,
-        error: "Stability AI API key not configured"
+        error: "xAI API key not configured. Set XAI_API_KEY environment variable."
       };
     }
     try {
+      const base64 = imageBuffer.toString("base64");
+      const dataUri = `data:image/png;base64,${base64}`;
       const body = {
-        text_prompts: [
-          { text: prompt2, weight: 1 }
-        ],
-        cfg_scale: options.cfgScale || 7,
-        steps: options.steps || 30,
-        samples: options.count || 1
-      };
-      if (options.negativePrompt) {
-        body.text_prompts.push({
-          text: options.negativePrompt,
-          weight: -1
-        });
-      }
-      if (options.seed !== void 0) {
-        body.seed = options.seed;
-      }
-      if (options.sampler) {
-        body.sampler = options.sampler;
-      }
-      if (options.stylePreset) {
-        body.style_preset = options.stylePreset;
-      }
-      if (options.size) {
-        const [width, height] = options.size.split("x").map(Number);
-        body.width = width;
-        body.height = height;
-      } else {
-        body.width = 1024;
-        body.height = 1024;
+        model: options.model || "grok-imagine-image",
+        prompt: prompt2,
+        image: {
+          url: dataUri,
+          type: "image_url"
+        },
+        n: 1,
+        response_format: options.responseFormat || "url"
+      };
+      if (options.aspectRatio) {
+        body.aspect_ratio = options.aspectRatio;
       }
-      const response = await fetch(`${this.baseUrl}/v1/generation/stable-diffusion-xl-1024-v1-0/text-to-image`, {
+      const response = await fetch(`${this.baseUrl}/images/edits`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "application/json"
+          Authorization: `Bearer ${this.apiKey}`
         },
         body: JSON.stringify(body)
       });
       if (!response.ok) {
         const errorText = await response.text();
-        let errorMessage;
+        let errorMessage = `API error: ${response.status}`;
         try {
-          const errorData = JSON.parse(errorText);
-          errorMessage = errorData.message || errorData.error || errorText;
+          const errorJson = JSON.parse(errorText);
+          if (errorJson.error?.message) {
+            errorMessage = errorJson.error.message;
+          }
         } catch {
-          errorMessage = errorText;
+          if (errorText) {
+            errorMessage = errorText.substring(0, 200);
+          }
         }
         return {
           success: false,
-          error: `API error (${response.status}): ${errorMessage}`
+          error: errorMessage
         };
       }
       const data = await response.json();
       return {
         success: true,
-        images: data.artifacts.map((a) => ({
-          base64: a.base64,
-          seed: a.seed,
-          finishReason: a.finishReason
+        images: data.data.map((img) => ({
+          url: img.url,
+          base64: img.b64_json
         }))
       };
     } catch (error) {
@@ -7089,350 +7326,145 @@ var StabilityProvider = class {
     }
   }
   /**
-   * Image-to-image transformation
-   */
-  async imageToImage(imageData, prompt2, options = {}) {
-    if (!this.apiKey) {
-      return {
-        success: false,
-        error: "Stability AI API key not configured"
-      };
-    }
-    try {
-      const formData = new FormData();
-      const imageBlob = Buffer.isBuffer(imageData) ? new Blob([new Uint8Array(imageData)]) : imageData;
-      formData.append("image", imageBlob, "image.png");
-      formData.append("prompt", prompt2);
-      formData.append("output_format", options.outputFormat || "png");
-      formData.append("strength", String(options.strength || 0.35));
-      formData.append("mode", options.mode || "image-to-image");
-      if (options.negativePrompt) {
-        formData.append("negative_prompt", options.negativePrompt);
-      }
-      if (options.seed !== void 0) {
-        formData.append("seed", String(options.seed));
-      }
-      const response = await fetch(`${this.baseUrl}/v2beta/stable-image/generate/sd3`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
-        },
-        body: formData
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        return {
-          success: false,
-          error: `API error (${response.status}): ${errorText}`
-        };
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      return {
-        success: true,
-        images: [{ base64 }]
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Upscale image
-   */
-  async upscaleImage(imageData, options = {}) {
-    if (!this.apiKey) {
-      return {
-        success: false,
-        error: "Stability AI API key not configured"
-      };
-    }
-    try {
-      const formData = new FormData();
-      const imageBlob = Buffer.isBuffer(imageData) ? new Blob([new Uint8Array(imageData)]) : imageData;
-      formData.append("image", imageBlob, "image.png");
-      formData.append("output_format", options.outputFormat || "png");
-      const upscaleType = options.type || "fast";
-      let endpoint;
-      if (upscaleType === "creative") {
-        endpoint = `${this.baseUrl}/v2beta/stable-image/upscale/creative`;
-        if (options.creativity !== void 0) {
-          formData.append("creativity", String(options.creativity));
-        }
-      } else if (upscaleType === "conservative") {
-        endpoint = `${this.baseUrl}/v2beta/stable-image/upscale/conservative`;
-      } else {
-        endpoint = `${this.baseUrl}/v2beta/stable-image/upscale/fast`;
-      }
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
-        },
-        body: formData
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        return {
-          success: false,
-          error: `API error (${response.status}): ${errorText}`
-        };
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      return {
-        success: true,
-        images: [{ base64 }]
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Remove background from image
-   */
-  async removeBackground(imageData, outputFormat = "png") {
-    if (!this.apiKey) {
-      return {
-        success: false,
-        error: "Stability AI API key not configured"
-      };
-    }
-    try {
-      const formData = new FormData();
-      const imageBlob = Buffer.isBuffer(imageData) ? new Blob([new Uint8Array(imageData)]) : imageData;
-      formData.append("image", imageBlob, "image.png");
-      formData.append("output_format", outputFormat);
-      const response = await fetch(`${this.baseUrl}/v2beta/stable-image/edit/remove-background`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
-        },
-        body: formData
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        return {
-          success: false,
-          error: `API error (${response.status}): ${errorText}`
-        };
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      return {
-        success: true,
-        images: [{ base64 }]
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Inpaint/outpaint image
+   * Generate video using Grok Imagine
    */
-  async inpaint(imageData, maskData, prompt2, options = {}) {
+  async generateVideo(prompt2, options) {
     if (!this.apiKey) {
       return {
-        success: false,
-        error: "Stability AI API key not configured"
+        id: "",
+        status: "failed",
+        error: "xAI API key not configured. Set XAI_API_KEY environment variable."
       };
     }
     try {
-      const formData = new FormData();
-      const imageBlob = Buffer.isBuffer(imageData) ? new Blob([new Uint8Array(imageData)]) : imageData;
-      const maskBlob = Buffer.isBuffer(maskData) ? new Blob([new Uint8Array(maskData)]) : maskData;
-      formData.append("image", imageBlob, "image.png");
-      formData.append("mask", maskBlob, "mask.png");
-      formData.append("prompt", prompt2);
-      formData.append("output_format", options.outputFormat || "png");
-      if (options.negativePrompt) {
-        formData.append("negative_prompt", options.negativePrompt);
-      }
-      if (options.seed !== void 0) {
-        formData.append("seed", String(options.seed));
-      }
-      const response = await fetch(`${this.baseUrl}/v2beta/stable-image/edit/inpaint`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
-        },
-        body: formData
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        return {
-          success: false,
-          error: `API error (${response.status}): ${errorText}`
-        };
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      return {
-        success: true,
-        images: [{ base64 }]
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Search and replace objects in an image using AI
-   */
-  async searchAndReplace(imageData, searchPrompt, replacePrompt, options = {}) {
-    if (!this.apiKey) {
-      return {
-        success: false,
-        error: "Stability AI API key not configured"
+      const duration = Math.min(15, Math.max(1, options?.duration || 5));
+      const body = {
+        model: DEFAULT_MODEL4,
+        prompt: prompt2,
+        duration,
+        aspect_ratio: options?.aspectRatio || "16:9"
       };
-    }
-    try {
-      const formData = new FormData();
-      const imageBlob = Buffer.isBuffer(imageData) ? new Blob([new Uint8Array(imageData)]) : imageData;
-      formData.append("image", imageBlob, "image.png");
-      formData.append("prompt", replacePrompt);
-      formData.append("search_prompt", searchPrompt);
-      formData.append("output_format", options.outputFormat || "png");
-      if (options.negativePrompt) {
-        formData.append("negative_prompt", options.negativePrompt);
-      }
-      if (options.seed !== void 0) {
-        formData.append("seed", String(options.seed));
+      if (options?.referenceImage) {
+        body.image = { url: options.referenceImage };
       }
-      const response = await fetch(`${this.baseUrl}/v2beta/stable-image/edit/search-and-replace`, {
+      const response = await fetch(`${this.baseUrl}/videos/generations`, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
         },
-        body: formData
+        body: JSON.stringify(body)
       });
       if (!response.ok) {
         const errorText = await response.text();
-        let errorMessage;
-        try {
-          const errorData = JSON.parse(errorText);
-          errorMessage = errorData.message || errorData.error || errorText;
-        } catch {
-          errorMessage = errorText;
-        }
         return {
-          success: false,
-          error: `API error (${response.status}): ${errorMessage}`
+          id: "",
+          status: "failed",
+          error: `Grok API error (${response.status}): ${errorText}`
         };
       }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      const seed = response.headers.get("seed");
+      const data = await response.json();
       return {
-        success: true,
-        images: [{
-          base64,
-          seed: seed ? parseInt(seed) : void 0
-        }]
+        id: data.request_id,
+        status: "pending"
       };
     } catch (error) {
       return {
-        success: false,
+        id: "",
+        status: "failed",
         error: error instanceof Error ? error.message : "Unknown error"
       };
     }
   }
   /**
-   * Extend image canvas (outpainting)
+   * Get generation status
    */
-  async outpaint(imageData, options = {}) {
+  async getGenerationStatus(id) {
     if (!this.apiKey) {
       return {
-        success: false,
-        error: "Stability AI API key not configured"
-      };
-    }
-    const { left = 0, right = 0, up = 0, down = 0 } = options;
-    if (left === 0 && right === 0 && up === 0 && down === 0) {
-      return {
-        success: false,
-        error: "At least one direction (left, right, up, down) must be specified"
+        id,
+        status: "failed",
+        error: "xAI API key not configured"
       };
     }
     try {
-      const formData = new FormData();
-      const imageBlob = Buffer.isBuffer(imageData) ? new Blob([new Uint8Array(imageData)]) : imageData;
-      formData.append("image", imageBlob, "image.png");
-      formData.append("output_format", options.outputFormat || "png");
-      if (left > 0) {
-        formData.append("left", String(Math.min(2e3, Math.max(0, left))));
-      }
-      if (right > 0) {
-        formData.append("right", String(Math.min(2e3, Math.max(0, right))));
-      }
-      if (up > 0) {
-        formData.append("up", String(Math.min(2e3, Math.max(0, up))));
-      }
-      if (down > 0) {
-        formData.append("down", String(Math.min(2e3, Math.max(0, down))));
-      }
-      if (options.prompt) {
-        formData.append("prompt", options.prompt);
-      }
-      if (options.creativity !== void 0) {
-        formData.append("creativity", String(Math.min(1, Math.max(0, options.creativity))));
-      }
-      const response = await fetch(`${this.baseUrl}/v2beta/stable-image/edit/outpaint`, {
-        method: "POST",
+      const response = await fetch(`${this.baseUrl}/videos/${id}`, {
         headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          Accept: "image/*"
-        },
-        body: formData
+          Authorization: `Bearer ${this.apiKey}`
+        }
       });
       if (!response.ok) {
         const errorText = await response.text();
-        let errorMessage;
-        try {
-          const errorData = JSON.parse(errorText);
-          errorMessage = errorData.message || errorData.error || errorText;
-        } catch {
-          errorMessage = errorText;
-        }
         return {
-          success: false,
-          error: `API error (${response.status}): ${errorMessage}`
+          id,
+          status: "failed",
+          error: `Failed to get status: ${errorText}`
         };
       }
-      const arrayBuffer = await response.arrayBuffer();
-      const base64 = Buffer.from(arrayBuffer).toString("base64");
-      const seed = response.headers.get("seed");
+      const data = await response.json();
+      const statusMap = {
+        pending: "pending",
+        done: "completed",
+        expired: "failed"
+      };
       return {
-        success: true,
-        images: [{
-          base64,
-          seed: seed ? parseInt(seed) : void 0
-        }]
+        id,
+        status: statusMap[data.status] || "pending",
+        videoUrl: data.video?.url,
+        error: data.status === "expired" ? "Generation expired" : void 0
       };
     } catch (error) {
       return {
-        success: false,
+        id,
+        status: "failed",
         error: error instanceof Error ? error.message : "Unknown error"
       };
     }
   }
+  /**
+   * Wait for generation to complete
+   */
+  async waitForCompletion(id, onProgress, maxWaitMs = 3e5) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitMs) {
+      const result = await this.getGenerationStatus(id);
+      if (onProgress) {
+        onProgress(result);
+      }
+      if (result.status === "completed" || result.status === "failed") {
+        return result;
+      }
+      await this.sleep(this.pollingInterval);
+    }
+    return {
+      id,
+      status: "failed",
+      error: "Generation timed out"
+    };
+  }
+  /**
+   * Cancel generation (if supported)
+   */
+  async cancelGeneration(id) {
+    if (!this.apiKey)
+      return false;
+    try {
+      const response = await fetch(`${this.baseUrl}/videos/${id}`, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve12) => setTimeout(resolve12, ms));
+  }
 };
-var stabilityProvider = new StabilityProvider();
+var grokProvider = new GrokProvider();
 
 // ../ai-providers/dist/replicate/ReplicateProvider.js
 var ReplicateProvider = class {
@@ -7688,7 +7720,7 @@ var ReplicateProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve13) => setTimeout(resolve13, ms));
+    return new Promise((resolve12) => setTimeout(resolve12, ms));
   }
   /**
    * Generate music from text prompt using MusicGen
@@ -7829,8 +7861,7 @@ var ReplicateProvider = class {
           Authorization: `Bearer ${this.apiToken}`
         },
         body: JSON.stringify({
-          version: "aa9adce25e29d8a8a6c6cddbd25627d7e11b9c1a4e3f8f7f7b7f5e88d5b8f4c1",
-          // resemble-enhance
+          model: "lucataco/resemble-enhance",
           input
         })
       });
@@ -7993,8 +8024,7 @@ var ReplicateProvider = class {
       let modelVersion;
       if (point) {
         input.query_points = [[point[0], point[1], 0]];
-        modelVersion = "facebookresearch/co-tracker:a12e tried";
-        modelVersion = "0a0dcaf0c51e8d6a8b1a3e4c5f6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5";
+        modelVersion = "facebookresearch/co-tracker";
       } else if (box) {
         input.box = [box[0], box[1], box[0] + box[2], box[1] + box[3]];
         modelVersion = "meta/sam-2:fe97b453a6455861e3bac769b441ca1f1086110da7466dbb65cf1eecfd60dc83";
@@ -8015,7 +8045,7 @@ var ReplicateProvider = class {
           Authorization: `Bearer ${this.apiToken}`
         },
         body: JSON.stringify({
-          version: modelVersion.split(":")[1] || modelVersion,
+          ...modelVersion.includes(":") ? { version: modelVersion.split(":")[1] } : { model: modelVersion },
           input
         })
       });
@@ -8093,9 +8123,9 @@ var PROVIDER_ENV_VARS = {
   runway: "RUNWAY_API_SECRET",
   kling: "KLING_API_KEY",
   imgbb: "IMGBB_API_KEY",
-  stability: "STABILITY_API_KEY",
   replicate: "REPLICATE_API_TOKEN",
-  xai: "XAI_API_KEY"
+  xai: "XAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY"
 };
 function createDefaultConfig() {
   return {
@@ -8148,7 +8178,14 @@ async function getApiKeyFromConfig(providerKey) {
 }
 
 // ../cli/src/utils/api-key.ts
-function findProjectRoot() {
+function loadEnv() {
+  config({ path: resolve5(process.cwd(), ".env"), debug: false });
+  const monorepoRoot = findMonorepoRoot();
+  if (monorepoRoot && monorepoRoot !== process.cwd()) {
+    config({ path: resolve5(monorepoRoot, ".env"), debug: false });
+  }
+}
+function findMonorepoRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
     try {
@@ -8158,18 +8195,14 @@ function findProjectRoot() {
       dir = resolve5(dir, "..");
     }
   }
-  return process.cwd();
-}
-function loadEnv() {
-  const projectRoot = findProjectRoot();
-  config({ path: resolve5(projectRoot, ".env") });
+  return null;
 }
 async function prompt(question, hidden = false) {
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve13) => {
+  return new Promise((resolve12) => {
     if (hidden && process.stdin.isTTY) {
       process.stdout.write(question);
       let input = "";
@@ -8183,7 +8216,7 @@ async function prompt(question, hidden = false) {
           process.stdin.removeListener("data", onData);
           process.stdout.write("\n");
           rl.close();
-          resolve13(input);
+          resolve12(input);
         } else if (char === "") {
           process.exit(1);
         } else if (char === "\x7F" || char === "\b") {
@@ -8198,7 +8231,7 @@ async function prompt(question, hidden = false) {
     } else {
       rl.question(question, (answer) => {
         rl.close();
-        resolve13(answer);
+        resolve12(answer);
       });
     }
   });
@@ -8215,7 +8248,6 @@ async function getApiKey(envVar, providerName, optionValue) {
     RUNWAY_API_SECRET: "runway",
     KLING_API_KEY: "kling",
     IMGBB_API_KEY: "imgbb",
-    STABILITY_API_KEY: "stability",
     REPLICATE_API_TOKEN: "replicate"
   };
   const providerKey = providerKeyMap[envVar];
@@ -8235,7 +8267,7 @@ async function getApiKey(envVar, providerName, optionValue) {
   }
   console.log();
   console.log(chalk2.yellow(`${providerName} API key not found.`));
-  console.log(chalk2.dim(`Set ${envVar} in .env, run 'vibe setup', or enter below.`));
+  console.log(chalk2.dim(`Set ${envVar} in .env (current directory), run 'vibe setup', or enter below.`));
   console.log();
   const apiKey = await prompt(chalk2.cyan(`Enter ${providerName} API key: `), true);
   if (!apiKey || apiKey.trim() === "") {
@@ -8249,8 +8281,7 @@ async function getApiKey(envVar, providerName, optionValue) {
   return apiKey.trim();
 }
 async function saveApiKeyToEnv(envVar, apiKey) {
-  const projectRoot = findProjectRoot();
-  const envPath = resolve5(projectRoot, ".env");
+  const envPath = resolve5(process.cwd(), ".env");
   let content = "";
   try {
     await access3(envPath);
@@ -8409,7 +8440,7 @@ async function detectSilencePeriodsWithGemini(videoPath, minDuration, options) {
   const totalDuration = await getVideoDuration(videoPath);
   const geminiApiKey = options.apiKey || await getApiKey("GOOGLE_API_KEY", "Google");
   if (!geminiApiKey) {
-    throw new Error("Google API key required for Gemini Video Understanding. Set GOOGLE_API_KEY or use --api-key");
+    throw new Error("Google API key required for Gemini Video Understanding. Run 'vibe setup' or set GOOGLE_API_KEY in .env");
   }
   const gemini = new GeminiProvider();
   await gemini.initialize({ apiKey: geminiApiKey });
@@ -8666,7 +8697,7 @@ async function executeJumpCut(options) {
   }
   const openaiKey = apiKey || process.env.OPENAI_API_KEY;
   if (!openaiKey) {
-    return { success: false, error: "OpenAI API key required for Whisper transcription." };
+    return { success: false, error: "OpenAI API key required for Whisper transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
   }
   try {
     const tmpDir = `/tmp/vibe_jumpcut_${Date.now()}`;
@@ -8811,7 +8842,7 @@ async function executeCaption(options) {
   }
   const openaiKey = apiKey || process.env.OPENAI_API_KEY;
   if (!openaiKey) {
-    return { success: false, error: "OpenAI API key required for Whisper transcription." };
+    return { success: false, error: "OpenAI API key required for Whisper transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
   }
   try {
     const tmpDir = `/tmp/vibe_caption_${Date.now()}`;
@@ -9080,7 +9111,7 @@ ${textsToTranslate}`;
       if (provider === "openai") {
         const openaiKey = apiKey || process.env.OPENAI_API_KEY;
         if (!openaiKey) {
-          return { success: false, error: "OpenAI API key required for translation." };
+          return { success: false, error: "OpenAI API key required for translation. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
         }
         const response = await fetch("https://api.openai.com/v1/chat/completions", {
           method: "POST",
@@ -9089,7 +9120,7 @@ ${textsToTranslate}`;
             Authorization: `Bearer ${openaiKey}`
           },
           body: JSON.stringify({
-            model: "gpt-4o-mini",
+            model: "gpt-5-mini",
             messages: [{ role: "user", content: translatePrompt }],
             temperature: 0.3
           })
@@ -9102,7 +9133,7 @@ ${textsToTranslate}`;
       } else {
         const claudeKey = apiKey || process.env.ANTHROPIC_API_KEY;
         if (!claudeKey) {
-          return { success: false, error: "Anthropic API key required for translation." };
+          return { success: false, error: "Anthropic API key required for translation. Run 'vibe setup' or set ANTHROPIC_API_KEY in .env" };
         }
         const response = await fetch("https://api.anthropic.com/v1/messages", {
           method: "POST",
@@ -9599,7 +9630,7 @@ async function executeGeminiVideo(options) {
   try {
     const apiKey = await getApiKey("GOOGLE_API_KEY", "Google");
     if (!apiKey) {
-      return { success: false, error: "Google API key required" };
+      return { success: false, error: "Google API key required. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
     }
     const isYouTube = options.source.includes("youtube.com") || options.source.includes("youtu.be");
     const modelMap = {
@@ -9649,7 +9680,7 @@ async function executeAnalyze(options) {
   try {
     const apiKey = await getApiKey("GOOGLE_API_KEY", "Google");
     if (!apiKey) {
-      return { success: false, error: "Google API key required" };
+      return { success: false, error: "Google API key required. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
     }
     const source = options.source;
     const isYouTube = source.includes("youtube.com") || source.includes("youtu.be");
@@ -9789,7 +9820,7 @@ async function executeReview(options) {
   }
   const apiKey = process.env.GOOGLE_API_KEY || await getApiKey("GOOGLE_API_KEY", "Google");
   if (!apiKey) {
-    return { success: false, error: "Google API key required for Gemini video review" };
+    return { success: false, error: "Google API key required for Gemini video review. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
   }
   let storyboardContext = "";
   if (storyboardPath) {
@@ -9896,7 +9927,7 @@ Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFi
 }
 
 // ../cli/src/commands/ai-image.ts
-import { readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir4 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
 import chalk5 from "chalk";
 import ora4 from "ora";
@@ -9917,7 +9948,7 @@ async function executeThumbnailBestFrame(options) {
   }
   const googleKey = apiKey || process.env.GOOGLE_API_KEY;
   if (!googleKey) {
-    return { success: false, error: "Google API key required for Gemini video analysis." };
+    return { success: false, error: "Google API key required for Gemini video analysis. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
   }
   try {
     const gemini = new GeminiProvider();
@@ -9926,7 +9957,9 @@ async function executeThumbnailBestFrame(options) {
     const analysisPrompt = prompt2 || 'Analyze this video and find the single best frame for a thumbnail. Look for frames that are visually striking, well-composed, emotionally engaging, and representative of the video content. Avoid blurry frames, transitions, or dark scenes. Return ONLY a JSON object: {"timestamp": <seconds as number>, "reason": "<brief explanation>"}';
     const modelMap = {
       flash: "gemini-3-flash-preview",
+      latest: "gemini-2.5-flash",
       "flash-2.5": "gemini-2.5-flash",
+      // backward compat
       pro: "gemini-2.5-pro"
     };
     const modelId = modelMap[model] || "gemini-3-flash-preview";
@@ -9968,7 +10001,7 @@ async function executeThumbnailBestFrame(options) {
 // src/tools/ai-analysis.ts
 var aiAnalysisTools = [
   {
-    name: "ai_analyze",
+    name: "analyze_media",
     description: "Analyze media (image, video, or YouTube URL) using Gemini AI. Requires GOOGLE_API_KEY.",
     inputSchema: {
       type: "object",
@@ -9989,7 +10022,7 @@ var aiAnalysisTools = [
     }
   },
   {
-    name: "ai_gemini_video",
+    name: "analyze_video",
     description: "Analyze video content using Gemini AI with temporal understanding. Requires GOOGLE_API_KEY.",
     inputSchema: {
       type: "object",
@@ -10010,7 +10043,7 @@ var aiAnalysisTools = [
     }
   },
   {
-    name: "ai_review",
+    name: "analyze_review",
     description: "AI video review: analyzes quality, suggests fixes, and optionally auto-applies them. Requires GOOGLE_API_KEY.",
     inputSchema: {
       type: "object",
@@ -10030,7 +10063,7 @@ var aiAnalysisTools = [
     }
   },
   {
-    name: "ai_thumbnail",
+    name: "generate_thumbnail",
     description: "Extract the best thumbnail frame from a video using Gemini AI analysis. Requires GOOGLE_API_KEY.",
     inputSchema: {
       type: "object",
@@ -10046,7 +10079,7 @@ var aiAnalysisTools = [
 ];
 async function handleAiAnalysisToolCall(name, args) {
   switch (name) {
-    case "ai_analyze": {
+    case "analyze_media": {
       const result = await executeAnalyze({
         source: args.source,
         prompt: args.prompt,
@@ -10064,7 +10097,7 @@ async function handleAiAnalysisToolCall(name, args) {
         totalTokens: result.totalTokens
       });
     }
-    case "ai_gemini_video": {
+    case "analyze_video": {
       const result = await executeGeminiVideo({
         source: args.source,
         prompt: args.prompt,
@@ -10081,7 +10114,7 @@ async function handleAiAnalysisToolCall(name, args) {
         totalTokens: result.totalTokens
       });
     }
-    case "ai_review": {
+    case "analyze_review": {
       const result = await executeReview({
         videoPath: args.videoPath,
         storyboardPath: args.storyboardPath,
@@ -10098,7 +10131,7 @@ async function handleAiAnalysisToolCall(name, args) {
         outputPath: result.outputPath
       });
     }
-    case "ai_thumbnail": {
+    case "generate_thumbnail": {
       const result = await executeThumbnailBestFrame({
         videoPath: args.videoPath,
         outputPath: args.outputPath,
@@ -10118,15 +10151,30 @@ async function handleAiAnalysisToolCall(name, args) {
 }
 
 // ../cli/src/commands/ai-script-pipeline.ts
-import { readFile as readFile9, writeFile as writeFile7, mkdir as mkdir4, unlink, rename as rename2 } from "node:fs/promises";
+import { readFile as readFile9, writeFile as writeFile7, mkdir as mkdir5, unlink, rename as rename2 } from "node:fs/promises";
 import { resolve as resolve9, basename as basename3, extname as extname3 } from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
 import chalk6 from "chalk";
 init_exec_safe();
+
+// ../cli/src/commands/ai-helpers.ts
+async function downloadVideo(url, apiKey) {
+  const headers = {};
+  if (url.includes("generativelanguage.googleapis.com") && apiKey) {
+    headers["x-goog-api-key"] = apiKey;
+  }
+  const response = await fetch(url, { headers, redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(`Download failed (${response.status}): ${response.statusText}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+// ../cli/src/commands/ai-script-pipeline.ts
 var DEFAULT_VIDEO_RETRIES = 2;
 var RETRY_DELAY_MS = 5e3;
 function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 async function generateVideoWithRetryKling(kling, segment, options, maxRetries, onProgress) {
   const prompt2 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
@@ -10193,6 +10241,37 @@ async function generateVideoWithRetryRunway(runway, segment, referenceImage, opt
   }
   return null;
 }
+async function generateVideoWithRetryVeo(gemini, segment, options, maxRetries, onProgress) {
+  const prompt2 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await gemini.generateVideo(prompt2, {
+        prompt: prompt2,
+        referenceImage: options.referenceImage,
+        duration: options.duration,
+        aspectRatio: options.aspectRatio,
+        model: "veo-3.1-fast-generate-preview"
+      });
+      if (result.status !== "failed" && result.id) {
+        return { operationName: result.id };
+      }
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Retry ${attempt + 1}/${maxRetries}...`);
+        await sleep(RETRY_DELAY_MS);
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+        await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(chalk6.dim(`
+  [Veo error: ${errMsg}]`));
+      }
+    }
+  }
+  return null;
+}
 async function executeScriptToVideo(options) {
   const outputDir = options.outputDir || "script-video-output";
   try {
@@ -10201,17 +10280,17 @@ async function executeScriptToVideo(options) {
     if (storyboardProvider === "openai") {
       storyboardApiKey = await getApiKey("OPENAI_API_KEY", "OpenAI") ?? void 0;
       if (!storyboardApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "OpenAI API key required for storyboard generation (--storyboard-provider openai)" };
+        return { success: false, outputDir, scenes: 0, error: "OpenAI API key required for storyboard generation (--storyboard-provider openai). Run 'vibe setup' or set OPENAI_API_KEY in .env" };
       }
     } else if (storyboardProvider === "gemini") {
       storyboardApiKey = await getApiKey("GOOGLE_API_KEY", "Google") ?? void 0;
       if (!storyboardApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "Google API key required for storyboard generation (--storyboard-provider gemini)" };
+        return { success: false, outputDir, scenes: 0, error: "Google API key required for storyboard generation (--storyboard-provider gemini). Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
       }
     } else {
       storyboardApiKey = await getApiKey("ANTHROPIC_API_KEY", "Anthropic") ?? void 0;
       if (!storyboardApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "Anthropic API key required for storyboard generation" };
+        return { success: false, outputDir, scenes: 0, error: "Anthropic API key required for storyboard generation. Run 'vibe setup' or set ANTHROPIC_API_KEY in .env" };
       }
     }
     let imageApiKey;
@@ -10219,24 +10298,24 @@ async function executeScriptToVideo(options) {
     if (imageProvider === "openai" || imageProvider === "dalle") {
       imageApiKey = await getApiKey("OPENAI_API_KEY", "OpenAI") ?? void 0;
       if (!imageApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "OpenAI API key required for image generation" };
-      }
-    } else if (imageProvider === "stability") {
-      imageApiKey = await getApiKey("STABILITY_API_KEY", "Stability AI") ?? void 0;
-      if (!imageApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "Stability API key required for image generation" };
+        return { success: false, outputDir, scenes: 0, error: "OpenAI API key required for image generation. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
       }
     } else if (imageProvider === "gemini") {
       imageApiKey = await getApiKey("GOOGLE_API_KEY", "Google") ?? void 0;
       if (!imageApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "Google API key required for Gemini image generation" };
+        return { success: false, outputDir, scenes: 0, error: "Google API key required for Gemini image generation. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
+      }
+    } else if (imageProvider === "grok") {
+      imageApiKey = await getApiKey("XAI_API_KEY", "xAI") ?? void 0;
+      if (!imageApiKey) {
+        return { success: false, outputDir, scenes: 0, error: "xAI API key required for Grok image generation. Run 'vibe setup' or set XAI_API_KEY in .env" };
       }
     }
     let elevenlabsApiKey;
     if (!options.noVoiceover) {
       elevenlabsApiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs") ?? void 0;
       if (!elevenlabsApiKey) {
-        return { success: false, outputDir, scenes: 0, error: "ElevenLabs API key required for voiceover (or use noVoiceover option)" };
+        return { success: false, outputDir, scenes: 0, error: "ElevenLabs API key required for voiceover (or use noVoiceover option). Run 'vibe setup' or set ELEVENLABS_API_KEY in .env" };
       }
     }
     let videoApiKey;
@@ -10244,18 +10323,23 @@ async function executeScriptToVideo(options) {
       if (options.generator === "kling") {
         videoApiKey = await getApiKey("KLING_API_KEY", "Kling") ?? void 0;
         if (!videoApiKey) {
-          return { success: false, outputDir, scenes: 0, error: "Kling API key required (or use imagesOnly option)" };
+          return { success: false, outputDir, scenes: 0, error: "Kling API key required (or use imagesOnly option). Run 'vibe setup' or set KLING_API_KEY in .env" };
+        }
+      } else if (options.generator === "veo") {
+        videoApiKey = await getApiKey("GOOGLE_API_KEY", "Google") ?? void 0;
+        if (!videoApiKey) {
+          return { success: false, outputDir, scenes: 0, error: "Google API key required for Veo video generation (or use imagesOnly option). Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
         }
       } else {
         videoApiKey = await getApiKey("RUNWAY_API_SECRET", "Runway") ?? void 0;
         if (!videoApiKey) {
-          return { success: false, outputDir, scenes: 0, error: "Runway API key required (or use imagesOnly option)" };
+          return { success: false, outputDir, scenes: 0, error: "Runway API key required (or use imagesOnly option). Run 'vibe setup' or set RUNWAY_API_SECRET in .env" };
         }
       }
     }
     const absOutputDir = resolve9(process.cwd(), outputDir);
     if (!existsSync6(absOutputDir)) {
-      await mkdir4(absOutputDir, { recursive: true });
+      await mkdir5(absOutputDir, { recursive: true });
     }
     let segments;
     const creativityOpts = { creativity: options.creativity };
@@ -10344,23 +10428,18 @@ async function executeScriptToVideo(options) {
       "9:16": "1024x1536",
       "1:1": "1024x1024"
     };
-    const stabilityAspectRatios = {
-      "16:9": "16:9",
-      "9:16": "9:16",
-      "1:1": "1:1"
-    };
     let openaiImageInstance;
-    let stabilityInstance;
     let geminiInstance;
+    let grokInstance;
     if (imageProvider === "openai" || imageProvider === "dalle") {
       openaiImageInstance = new OpenAIImageProvider();
       await openaiImageInstance.initialize({ apiKey: imageApiKey });
-    } else if (imageProvider === "stability") {
-      stabilityInstance = new StabilityProvider();
-      await stabilityInstance.initialize({ apiKey: imageApiKey });
     } else if (imageProvider === "gemini") {
       geminiInstance = new GeminiProvider();
       await geminiInstance.initialize({ apiKey: imageApiKey });
+    } else if (imageProvider === "grok") {
+      grokInstance = new GrokProvider();
+      await grokInstance.initialize({ apiKey: imageApiKey });
     }
     const imagePaths = [];
     for (let i = 0; i < segments.length; i++) {
@@ -10382,12 +10461,18 @@ async function executeScriptToVideo(options) {
               imageUrl = img.url;
             }
           }
-        } else if (imageProvider === "stability" && stabilityInstance) {
-          const imageResult = await stabilityInstance.generateImage(imagePrompt, {
-            aspectRatio: stabilityAspectRatios[options.aspectRatio || "16:9"] || "16:9",
-            model: "sd3.5-large"
+        } else if (imageProvider === "gemini" && geminiInstance) {
+          const imageResult = await geminiInstance.generateImage(imagePrompt, {
+            aspectRatio: options.aspectRatio || "16:9"
+          });
+          if (imageResult.success && imageResult.images?.[0]?.base64) {
+            imageBuffer = Buffer.from(imageResult.images[0].base64, "base64");
+          }
+        } else if (imageProvider === "grok" && grokInstance) {
+          const imageResult = await grokInstance.generateImage(imagePrompt, {
+            aspectRatio: options.aspectRatio || "16:9"
           });
-          if (imageResult.success && imageResult.images?.[0]) {
+          if (imageResult.success && imageResult.images && imageResult.images.length > 0) {
             const img = imageResult.images[0];
             if (img.base64) {
               imageBuffer = Buffer.from(img.base64, "base64");
@@ -10395,13 +10480,6 @@ async function executeScriptToVideo(options) {
               imageUrl = img.url;
             }
           }
-        } else if (imageProvider === "gemini" && geminiInstance) {
-          const imageResult = await geminiInstance.generateImage(imagePrompt, {
-            aspectRatio: options.aspectRatio || "16:9"
-          });
-          if (imageResult.success && imageResult.images?.[0]?.base64) {
-            imageBuffer = Buffer.from(imageResult.images[0].base64, "base64");
-          }
         }
         const imagePath = resolve9(absOutputDir, `scene-${i + 1}.png`);
         if (imageBuffer) {
@@ -10451,8 +10529,53 @@ async function executeScriptToVideo(options) {
               const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, void 0, 6e5);
               if (waitResult.status === "completed" && waitResult.videoUrl) {
                 const videoPath = resolve9(absOutputDir, `scene-${i + 1}.mp4`);
-                const response = await fetch(waitResult.videoUrl);
-                const buffer = Buffer.from(await response.arrayBuffer());
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                await writeFile7(videoPath, buffer);
+                const targetDuration = segment.duration;
+                const actualVideoDuration = await getVideoDuration(videoPath);
+                if (actualVideoDuration < targetDuration - 0.1) {
+                  const extendedPath = resolve9(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                  await unlink(videoPath);
+                  await rename2(extendedPath, videoPath);
+                }
+                videoPaths.push(videoPath);
+                result.videos.push(videoPath);
+              } else {
+                videoPaths.push("");
+                result.failedScenes.push(i + 1);
+              }
+            } catch {
+              videoPaths.push("");
+              result.failedScenes.push(i + 1);
+            }
+          } else {
+            videoPaths.push("");
+            result.failedScenes.push(i + 1);
+          }
+        }
+      } else if (options.generator === "veo") {
+        const veo = new GeminiProvider();
+        await veo.initialize({ apiKey: videoApiKey });
+        for (let i = 0; i < segments.length; i++) {
+          if (!imagePaths[i]) {
+            videoPaths.push("");
+            continue;
+          }
+          const segment = segments[i];
+          const veoDuration = segment.duration > 6 ? 8 : segment.duration > 4 ? 6 : 4;
+          const taskResult = await generateVideoWithRetryVeo(
+            veo,
+            segment,
+            { duration: veoDuration, aspectRatio: options.aspectRatio || "16:9" },
+            maxRetries
+          );
+          if (taskResult) {
+            try {
+              const waitResult = await veo.waitForVideoCompletion(taskResult.operationName, void 0, 3e5);
+              if (waitResult.status === "completed" && waitResult.videoUrl) {
+                const videoPath = resolve9(absOutputDir, `scene-${i + 1}.mp4`);
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile7(videoPath, buffer);
                 const targetDuration = segment.duration;
                 const actualVideoDuration = await getVideoDuration(videoPath);
@@ -10504,8 +10627,7 @@ async function executeScriptToVideo(options) {
               const waitResult = await runway.waitForCompletion(taskResult.taskId, void 0, 3e5);
               if (waitResult.status === "completed" && waitResult.videoUrl) {
                 const videoPath = resolve9(absOutputDir, `scene-${i + 1}.mp4`);
-                const response = await fetch(waitResult.videoUrl);
-                const buffer = Buffer.from(await response.arrayBuffer());
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile7(videoPath, buffer);
                 const targetDuration = segment.duration;
                 const actualVideoDuration = await getVideoDuration(videoPath);
@@ -10659,7 +10781,7 @@ async function executeScriptToVideo(options) {
 }
 
 // ../cli/src/commands/ai-highlights.ts
-import { readFile as readFile10, writeFile as writeFile8, mkdir as mkdir5 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile8, mkdir as mkdir6 } from "node:fs/promises";
 import { resolve as resolve10, dirname as dirname2, basename as basename4, extname as extname4 } from "node:path";
 import { existsSync as existsSync7 } from "node:fs";
 import chalk7 from "chalk";
@@ -10702,7 +10824,7 @@ async function executeHighlights(options) {
     if (options.useGemini && isVideo) {
       const geminiApiKey = await getApiKey("GOOGLE_API_KEY", "Google");
       if (!geminiApiKey) {
-        return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: "Google API key required for Gemini Video Understanding" };
+        return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: "Google API key required for Gemini Video Understanding. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
       }
       sourceDuration = await ffprobeDuration(absPath);
       const gemini = new GeminiProvider();
@@ -10770,11 +10892,11 @@ Analyze both what is SHOWN (visual cues, actions, expressions) and what is SAID
     } else {
       const openaiApiKey = await getApiKey("OPENAI_API_KEY", "OpenAI");
       if (!openaiApiKey) {
-        return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: "OpenAI API key required for Whisper transcription" };
+        return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: "OpenAI API key required for Whisper transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
       }
       const claudeApiKey = await getApiKey("ANTHROPIC_API_KEY", "Anthropic");
       if (!claudeApiKey) {
-        return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: "Anthropic API key required for highlight analysis" };
+        return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: "Anthropic API key required for highlight analysis. Run 'vibe setup' or set ANTHROPIC_API_KEY in .env" };
       }
       let audioPath = absPath;
       let tempAudioPath = null;
@@ -10900,7 +11022,7 @@ async function executeAutoShorts(options) {
     if (options.useGemini) {
       const geminiApiKey = await getApiKey("GOOGLE_API_KEY", "Google");
       if (!geminiApiKey) {
-        return { success: false, shorts: [], error: "Google API key required for Gemini Video Understanding" };
+        return { success: false, shorts: [], error: "Google API key required for Gemini Video Understanding. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
       }
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey: geminiApiKey });
@@ -10971,11 +11093,11 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
     } else {
       const openaiApiKey = await getApiKey("OPENAI_API_KEY", "OpenAI");
       if (!openaiApiKey) {
-        return { success: false, shorts: [], error: "OpenAI API key required for transcription" };
+        return { success: false, shorts: [], error: "OpenAI API key required for transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
       }
       const claudeApiKey = await getApiKey("ANTHROPIC_API_KEY", "Anthropic");
       if (!claudeApiKey) {
-        return { success: false, shorts: [], error: "Anthropic API key required for highlight detection" };
+        return { success: false, shorts: [], error: "Anthropic API key required for highlight detection. Run 'vibe setup' or set ANTHROPIC_API_KEY in .env" };
       }
       const tempAudio = absPath.replace(/(\.[^.]+)$/, "-temp-audio.mp3");
       await execSafe("ffmpeg", ["-i", absPath, "-vn", "-acodec", "libmp3lame", "-q:a", "2", tempAudio, "-y"]);
@@ -11020,7 +11142,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
     }
     const outputDir = options.outputDir ? resolve10(process.cwd(), options.outputDir) : dirname2(absPath);
     if (options.outputDir && !existsSync7(outputDir)) {
-      await mkdir5(outputDir, { recursive: true });
+      await mkdir6(outputDir, { recursive: true });
     }
     const result = {
       success: true,
@@ -11095,136 +11217,10 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
   }
 }
 
-// ../cli/src/commands/ai-narrate.ts
-import { readFile as readFile11, writeFile as writeFile9, mkdir as mkdir6 } from "node:fs/promises";
-import { resolve as resolve11, dirname as dirname3, basename as basename5 } from "node:path";
-import { existsSync as existsSync8 } from "node:fs";
-import chalk8 from "chalk";
-import ora6 from "ora";
-init_exec_safe();
-async function autoNarrate(options) {
-  const {
-    videoPath,
-    duration,
-    outputDir,
-    voice = "rachel",
-    style = "informative",
-    language = "en",
-    scriptProvider = "claude"
-  } = options;
-  const geminiApiKey = await getApiKey("GOOGLE_API_KEY", "Google");
-  if (!geminiApiKey) {
-    return { success: false, error: "GOOGLE_API_KEY required for video analysis" };
-  }
-  let claudeApiKey = null;
-  let openaiScriptApiKey = null;
-  if (scriptProvider === "openai") {
-    openaiScriptApiKey = await getApiKey("OPENAI_API_KEY", "OpenAI");
-    if (!openaiScriptApiKey) {
-      return { success: false, error: "OPENAI_API_KEY required for script generation" };
-    }
-  } else {
-    claudeApiKey = await getApiKey("ANTHROPIC_API_KEY", "Anthropic");
-    if (!claudeApiKey) {
-      return { success: false, error: "ANTHROPIC_API_KEY required for script generation" };
-    }
-  }
-  const elevenlabsApiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs");
-  if (!elevenlabsApiKey) {
-    return { success: false, error: "ELEVENLABS_API_KEY required for TTS" };
-  }
-  try {
-    const gemini = new GeminiProvider();
-    await gemini.initialize({ apiKey: geminiApiKey });
-    const videoBuffer = await readFile11(videoPath);
-    const analysisPrompt = `Analyze this video in detail for narration purposes. Describe:
-1. What is happening visually (actions, movements, subjects)
-2. The setting and environment
-3. Any text or graphics visible
-4. The mood and tone of the content
-5. Key moments and their approximate timestamps
-
-Provide a detailed description that could be used to write a voiceover narration.
-Focus on what viewers need to know to understand and appreciate the video.`;
-    const analysisResult = await gemini.analyzeVideo(videoBuffer, analysisPrompt, {
-      fps: 0.5,
-      // Lower FPS for cost optimization
-      lowResolution: duration > 60
-      // Use low res for longer videos
-    });
-    if (!analysisResult.success || !analysisResult.response) {
-      return { success: false, error: `Video analysis failed: ${analysisResult.error}` };
-    }
-    let scriptResult;
-    if (scriptProvider === "openai") {
-      const gpt = new OpenAIProvider();
-      await gpt.initialize({ apiKey: openaiScriptApiKey });
-      scriptResult = await gpt.generateNarrationScript(
-        analysisResult.response,
-        duration,
-        style,
-        language
-      );
-    } else {
-      const claude = new ClaudeProvider();
-      await claude.initialize({ apiKey: claudeApiKey });
-      scriptResult = await claude.generateNarrationScript(
-        analysisResult.response,
-        duration,
-        style,
-        language
-      );
-      if (!scriptResult.success && scriptResult.error?.includes("529")) {
-        const fallbackKey = await getApiKey("OPENAI_API_KEY", "OpenAI");
-        if (fallbackKey) {
-          console.error("\u26A0\uFE0F  Claude overloaded, falling back to OpenAI...");
-          const gpt = new OpenAIProvider();
-          await gpt.initialize({ apiKey: fallbackKey });
-          scriptResult = await gpt.generateNarrationScript(
-            analysisResult.response,
-            duration,
-            style,
-            language
-          );
-        }
-      }
-    }
-    if (!scriptResult.success || !scriptResult.script) {
-      return { success: false, error: `Script generation failed: ${scriptResult.error}` };
-    }
-    const elevenlabs = new ElevenLabsProvider();
-    await elevenlabs.initialize({ apiKey: elevenlabsApiKey });
-    const ttsResult = await elevenlabs.textToSpeech(scriptResult.script, {
-      voiceId: voice
-    });
-    if (!ttsResult.success || !ttsResult.audioBuffer) {
-      return { success: false, error: `TTS generation failed: ${ttsResult.error}` };
-    }
-    if (!existsSync8(outputDir)) {
-      await mkdir6(outputDir, { recursive: true });
-    }
-    const audioPath = resolve11(outputDir, "auto-narration.mp3");
-    await writeFile9(audioPath, ttsResult.audioBuffer);
-    const scriptPath = resolve11(outputDir, "narration-script.txt");
-    await writeFile9(scriptPath, scriptResult.script, "utf-8");
-    return {
-      success: true,
-      audioPath,
-      script: scriptResult.script,
-      segments: scriptResult.segments
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error in autoNarrate"
-    };
-  }
-}
-
 // src/tools/ai-pipelines.ts
 var aiPipelineTools = [
   {
-    name: "ai_script_to_video",
+    name: "pipeline_script_to_video",
     description: "Full script-to-video pipeline: script -> storyboard -> images -> voiceover -> video. Requires multiple API keys depending on providers chosen.",
     inputSchema: {
       type: "object",
@@ -11240,7 +11236,7 @@ var aiPipelineTools = [
         },
         imageProvider: {
           type: "string",
-          enum: ["openai", "dalle", "stability", "gemini"],
+          enum: ["openai", "gemini", "grok"],
           description: "Image generation provider (default: gemini)"
         },
         aspectRatio: {
@@ -11273,7 +11269,7 @@ var aiPipelineTools = [
     }
   },
   {
-    name: "ai_highlights",
+    name: "pipeline_highlights",
     description: "Extract highlight clips from a longer video using AI analysis. Requires OPENAI_API_KEY+ANTHROPIC_API_KEY or GOOGLE_API_KEY (with --use-gemini).",
     inputSchema: {
       type: "object",
@@ -11297,8 +11293,8 @@ var aiPipelineTools = [
     }
   },
   {
-    name: "ai_auto_shorts",
-    description: "Automatically generate short-form content (Reels/TikTok/Shorts) from a longer video. Same API key requirements as ai_highlights.",
+    name: "pipeline_auto_shorts",
+    description: "Automatically generate short-form content (Reels/TikTok/Shorts) from a longer video. Same API key requirements as pipeline_highlights.",
     inputSchema: {
       type: "object",
       properties: {
@@ -11324,31 +11320,11 @@ var aiPipelineTools = [
       },
       required: ["video"]
     }
-  },
-  {
-    name: "ai_narrate",
-    description: "Auto-generate narration for a video: analyze content with Gemini, generate script, produce voiceover with ElevenLabs. Requires GOOGLE_API_KEY + ELEVENLABS_API_KEY.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        videoPath: { type: "string", description: "Path to the input video file" },
-        duration: { type: "number", description: "Video duration in seconds (auto-detected if omitted)" },
-        outputDir: { type: "string", description: "Output directory for narration audio" },
-        voice: { type: "string", description: "ElevenLabs voice name (default: Rachel)" },
-        style: {
-          type: "string",
-          enum: ["informative", "energetic", "calm", "dramatic"],
-          description: "Narration style (default: informative)"
-        },
-        language: { type: "string", description: "Language code (default: en)" }
-      },
-      required: ["videoPath", "duration", "outputDir"]
-    }
   }
 ];
 async function handleAiPipelineToolCall(name, args) {
   switch (name) {
-    case "ai_script_to_video": {
+    case "pipeline_script_to_video": {
       const result = await executeScriptToVideo({
         script: args.script,
         outputDir: args.outputDir,
@@ -11378,7 +11354,7 @@ async function handleAiPipelineToolCall(name, args) {
         failedScenes: result.failedScenes
       });
     }
-    case "ai_highlights": {
+    case "pipeline_highlights": {
       const result = await executeHighlights({
         media: args.media,
         output: args.output,
@@ -11400,7 +11376,7 @@ async function handleAiPipelineToolCall(name, args) {
         projectPath: result.projectPath
       });
     }
-    case "ai_auto_shorts": {
+    case "pipeline_auto_shorts": {
       const result = await executeAutoShorts({
         video: args.video,
         outputDir: args.outputDir,
@@ -11426,22 +11402,6 @@ async function handleAiPipelineToolCall(name, args) {
         }))
       });
     }
-    case "ai_narrate": {
-      const result = await autoNarrate({
-        videoPath: args.videoPath,
-        duration: args.duration,
-        outputDir: args.outputDir,
-        voice: args.voice,
-        style: args.style,
-        language: args.language
-      });
-      if (!result.success) return `Narration failed: ${result.error}`;
-      return JSON.stringify({
-        audioPath: result.audioPath,
-        script: result.script,
-        segments: result.segments?.length
-      });
-    }
     default:
       throw new Error(`Unknown AI pipeline tool: ${name}`);
   }
@@ -11482,8 +11442,8 @@ async function handleToolCall(name, args) {
 }
 
 // src/resources/index.ts
-import { readFile as readFile12 } from "node:fs/promises";
-import { resolve as resolve12 } from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { resolve as resolve11 } from "node:path";
 var resources = [
   {
     uri: "vibe://project/current",
@@ -11518,8 +11478,8 @@ var resources = [
 ];
 var currentProjectPath = process.env.VIBE_PROJECT_PATH || null;
 async function loadProject2(projectPath) {
-  const absPath = resolve12(process.cwd(), projectPath);
-  const content = await readFile12(absPath, "utf-8");
+  const absPath = resolve11(process.cwd(), projectPath);
+  const content = await readFile11(absPath, "utf-8");
   const data = JSON.parse(content);
   return Project.fromJSON(data);
 }