API Integrations for AI Video

// NEVER hardcode API keys in your source code.
// Use environment variables loaded from a .env file.

// .env file (add to .gitignore!):
// OPENAI_API_KEY=sk-proj-abc123...
// RUNWAY_API_KEY=rw_key_xyz789...
// ELEVENLABS_API_KEY=el_key_def456...
// STABILITY_API_KEY=sk-stab-ghi012...

// Load in Node.js:
import 'dotenv/config';

const openaiKey = process.env.OPENAI_API_KEY;
const runwayKey = process.env.RUNWAY_API_KEY;

// Use in requests:
const headers = {
  'Authorization': `Bearer ${openaiKey}`,
  'Content-Type': 'application/json'
};

import OpenAI from 'openai';
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const generateScript = async (topic, duration = 60) => {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      {
        role: 'system',
        content: `You are a professional video scriptwriter. Write a ${duration}-second video script. Return a JSON object with: title, total_duration, and scenes array. Each scene has: scene_number, narration, visual_prompt (for AI image generation), duration (seconds), transition (fade/cut/dissolve).`
      },
      {
        role: 'user',
        content: `Write a script about: ${topic}`
      }
    ],
    response_format: { type: 'json_object' },
    temperature: 0.8,
    max_tokens: 2000
  });
  return JSON.parse(response.choices[0].message.content);
};

const script = await generateScript('How Runway Gen-3 is changing video production');

const generateSceneImage = async (visualPrompt) => {
  const response = await openai.images.generate({
    model: 'dall-e-3',
    prompt: `${visualPrompt}. Cinematic, 4K, photorealistic, 16:9 aspect ratio, no text or watermarks.`,
    size: '1792x1024',    // Closest to 16:9
    quality: 'hd',         // Higher detail ($0.080 vs $0.040)
    style: 'natural',      // 'vivid' for more dramatic, 'natural' for realistic
    n: 1
  });
  return {
    url: response.data[0].url,
    revised_prompt: response.data[0].revised_prompt
  };
};

const generateRunwayVideo = async (imageUrl, motionPrompt) => {
  // Step 1: Create generation task
  const createResponse = await fetch('https://api.runwayml.com/v1/image_to_video', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.RUNWAY_API_KEY}`,
      'X-Runway-Version': '2024-11-06',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'gen3a_turbo',
      promptImage: imageUrl,
      promptText: motionPrompt,
      duration: 5,          // 5 or 10 seconds
      ratio: '16:9',
      watermark: false
    })
  });
  const { id: taskId } = await createResponse.json();

  // Step 2: Poll for completion
  let task;
  do {
    await sleep(10000); // Check every 10s
    const statusResponse = await fetch(
      `https://api.runwayml.com/v1/tasks/${taskId}`,
      { headers: { 'Authorization': `Bearer ${process.env.RUNWAY_API_KEY}` } }
    );
    task = await statusResponse.json();
  } while (task.status === 'RUNNING');

  if (task.status === 'SUCCEEDED') {
    return task.output[0]; // Video URL
  }
  throw new Error(`Runway generation failed: ${task.failure}`);
};

const generateVoiceover = async (text, voiceId = 'pNInz6obpgDQGcFmaJgB') => {
  // voiceId 'pNInz6obpgDQGcFmaJgB' = "Adam" (deep, narrator voice)
  const response = await fetch(
    `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
    {
      method: 'POST',
      headers: {
        'xi-api-key': process.env.ELEVENLABS_API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: text,
        model_id: 'eleven_multilingual_v2', // Best quality
        voice_settings: {
          stability: 0.5,        // 0-1: lower = more expressive
          similarity_boost: 0.75, // 0-1: higher = closer to original voice
          style: 0.3,            // 0-1: style exaggeration
          use_speaker_boost: true
        },
        output_format: 'mp3_44100_128' // High quality MP3
      })
    }
  );

  // Response is raw audio bytes
  const audioBuffer = await response.arrayBuffer();
  fs.writeFileSync('voiceover.mp3', Buffer.from(audioBuffer));
  return 'voiceover.mp3';
};

const generateSoundEffect = async (description, duration = 5) => {
  const response = await fetch(
    'https://api.elevenlabs.io/v1/sound-generation',
    {
      method: 'POST',
      headers: {
        'xi-api-key': process.env.ELEVENLABS_API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: description,         // e.g., "dramatic cinematic whoosh transition"
        duration_seconds: duration,
        prompt_influence: 0.5      // 0-1: how closely to follow the description
      })
    }
  );
  const audioBuffer = await response.arrayBuffer();
  fs.writeFileSync('sfx.mp3', Buffer.from(audioBuffer));
  return 'sfx.mp3';
};

// Generate transition sound effects
await generateSoundEffect('cinematic whoosh transition sound', 2);
await generateSoundEffect('gentle ambient background music, technology theme', 60);

const generateStabilityImage = async (prompt) => {
  const response = await fetch(
    'https://api.stability.ai/v2beta/stable-image/generate/sd3',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.STABILITY_API_KEY}`,
        'Accept': 'image/*'
      },
      body: (() => {
        const formData = new FormData();
        formData.append('prompt', prompt);
        formData.append('output_format', 'png');
        formData.append('aspect_ratio', '16:9');
        formData.append('model', 'sd3.5-large');  // Best quality
        formData.append('negative_prompt', 'text, watermark, blurry, low quality');
        return formData;
      })()
    }
  );
  const imageBuffer = await response.arrayBuffer();
  return Buffer.from(imageBuffer);
};

const callAPIWithRetry = async (apiCall, options = {}) => {
  const { maxRetries = 3, baseDelay = 1000, maxDelay = 30000 } = options;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const result = await apiCall();
      return result;
    } catch (error) {
      const isRateLimit = error.status === 429;
      const isServerError = error.status >= 500;
      const isRetryable = isRateLimit || isServerError;

      if (!isRetryable || attempt === maxRetries) {
        throw error;
      }

      // Use Retry-After header if available, otherwise exponential backoff
      let delay;
      if (isRateLimit && error.headers?.['retry-after']) {
        delay = parseInt(error.headers['retry-after']) * 1000;
      } else {
        delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
      }

      console.warn(
        `API call failed (${error.status}). ` +
        `Retry ${attempt + 1}/${maxRetries} in ${delay}ms...`
      );
      await sleep(delay);
    }
  }
};

// Usage:
const script = await callAPIWithRetry(
  () => openai.chat.completions.create({ model: 'gpt-4o', messages: [...] }),
  { maxRetries: 3, baseDelay: 2000 }
);

import express from 'express';
const app = express();

// Webhook endpoint that Runway calls when video generation completes
app.post('/webhooks/runway', express.json(), async (req, res) => {
  const { task_id, status, output } = req.body;

  if (status === 'SUCCEEDED') {
    console.log(`Video ready: ${output[0]}`);
    // Continue pipeline: download video, assemble, publish
    await downloadVideo(output[0], `clips/${task_id}.mp4`);
    await triggerAssemblyStage(task_id);
  } else if (status === 'FAILED') {
    console.error(`Task ${task_id} failed: ${req.body.failure}`);
    await retryOrNotify(task_id);
  }

  res.status(200).json({ received: true });
});

app.listen(3000, () => console.log('Webhook server listening on port 3000'));

// When creating a Runway task, specify the webhook URL:
// { ...params, webhook: 'https://your-server.com/webhooks/runway' }