Video Generation

import { Connector, VideoGeneration, Vendor } from 'oneringai';
import * as fs from 'fs/promises';

// Setup connector
Connector.create({
  name: 'google-video',
  vendor: Vendor.Google,
  auth: { type: 'api_key', apiKey: process.env.GOOGLE_API_KEY! },
});

// Create video generator
const videoGen = VideoGeneration.create({ connector: 'google-video' });

// Start video generation (returns immediately with job ID)
const job = await videoGen.generate({
  prompt: 'A cinematic shot of a sunrise over mountains with clouds rolling',
  model: 'veo-3.1-lite-generate-preview',
  duration: 8,           // 8 seconds
});

console.log('Job started:', job.jobId);
console.log('Status:', job.status);  // 'pending'

// Wait for completion (polls every 10 seconds, default 10-minute timeout)
const result = await videoGen.waitForCompletion(job.jobId);

// Download the completed video
const videoBuffer = await videoGen.download(job.jobId);
await fs.writeFile('./output.mp4', videoBuffer);

// 1. Start generation - returns immediately
const job = await videoGen.generate({ prompt: '...', duration: 8 });
// job.status = 'pending'

// 2. Poll for status (optional - if you want progress updates)
const status = await videoGen.getStatus(job.jobId);
// status.status = 'processing', status.progress = 45

// 3. Wait for completion (blocks until done or timeout)
const result = await videoGen.waitForCompletion(job.jobId);
// result.status = 'completed'

// 4. Download the video
const buffer = await videoGen.download(job.jobId);

// Generate and wait in one call
const result = await videoGen.generateAndWait({
  prompt: 'A butterfly flying through a garden',
  duration: 4,
});

const buffer = await videoGen.download(result.jobId);

interface VideoResponse {
  jobId: string;              // Unique job identifier
  status: 'pending' | 'processing' | 'completed' | 'failed';
  created: number;            // Unix timestamp
  progress?: number;          // 0-100 percentage (when processing)
  video?: {
    url?: string;             // Download URL (if available)
    b64_json?: string;        // Base64-encoded video data (if provider returns inline)
    duration?: number;        // Actual duration in seconds
    resolution?: string;      // Actual resolution
    format?: string;          // 'mp4' typically
  };
  audio?: {                   // Separate audio track (if provider returns one)
    url?: string;
    b64_json?: string;
  };
  error?: string;             // Error message if failed
}

// Save to file
await fs.writeFile('./output.mp4', videoBuffer);

// Open with default player (Node.js)
import { exec } from 'child_process';
exec('open ./output.mp4');  // macOS
exec('xdg-open ./output.mp4');  // Linux
exec('start ./output.mp4');  // Windows

// Serve via web server
import express from 'express';
const app = express();
app.get('/video', (req, res) => {
  res.setHeader('Content-Type', 'video/mp4');
  res.send(videoBuffer);
});

// Convert to base64 for embedding
const base64 = videoBuffer.toString('base64');
const dataUrl = `data:video/mp4;base64,${base64}`;

// Setup Google connector
Connector.create({
  name: 'google',
  vendor: Vendor.Google,
  auth: { type: 'api_key', apiKey: process.env.GOOGLE_API_KEY! },
});

const googleVideo = VideoGeneration.create({ connector: 'google' });

// Veo 3.1 Lite is the current high-level Google default.
const lite = await googleVideo.generate({
  prompt: 'A colorful butterfly landing on a flower',
  model: 'veo-3.1-lite-generate-preview',
  duration: 6,
  resolution: '1080p',
  vendorOptions: {
    negativePrompt: 'blurry, low quality',  // What to avoid
  },
});

// Veo 3.1 Fast (with audio support)
const veo3 = await googleVideo.generate({
  prompt: 'A thunderstorm over a city with lightning',
  model: 'veo-3.1-fast-generate-preview',
  duration: 8,
  vendorOptions: {
    personGeneration: 'dont_allow',  // Safety setting
  },
});

// Veo 3.1 (full feature set and 4K support)
const veo31 = await googleVideo.generate({
  prompt: 'A drone shot flying over mountains',
  model: 'veo-3.1-generate-preview',
  duration: 8,
  resolution: '4k',
});

// Gemini Omni uses the Interactions API for conversational video editing.
const omni = await googleVideo.generate({
  prompt: 'Animate this storyboard with a gentle dolly movement',
  model: 'gemini-omni-1.1-flash',
  image: './storyboard.png',
  duration: 6,
});

Connector.create({
  name: 'xai',
  vendor: Vendor.Grok,
  auth: { type: 'api_key', apiKey: process.env.XAI_API_KEY! },
});

const grokVideo = VideoGeneration.create({ connector: 'xai' });

// Current text-to-video default.
const textJob = await grokVideo.generate({
  prompt: 'A paper sculpture unfolding into a city skyline',
  model: 'grok-imagine-video',
  duration: 8,
  resolution: '720p',
});

// Grok Imagine Video 1.5 is preferred for higher-fidelity image-to-video.
const imageJob = await grokVideo.generate({
  prompt: 'Slow cinematic push-in with moving clouds',
  model: 'grok-imagine-video-1.5',
  image: './keyframe.png',
  duration: 8,
  resolution: '1080p',
});

// List available models
const models = await videoGen.listModels();
console.log('Available models:', models);

// Historical metadata is still available for retired models.
const info = videoGen.getModelInfo('sora-2');
console.log('Durations:', info.capabilities.durations);       // [4, 8, 12, 16, 20]
console.log('Resolutions:', info.capabilities.resolutions);   // ['720x1280', ...]
console.log('Has audio:', info.capabilities.audio);           // true
console.log('Image-to-video:', info.capabilities.imageToVideo); // true
console.log('Style control:', info.capabilities.features.styleControl); // false
console.log('Lifecycle:', info.lifecycle);                      // retired
console.log('Callable:', info.isActive);                         // false

import { calculateVideoCost } from 'oneringai';

// Historical Sora 2 pricing: $0.10/second (generation is retired)
const soraCost = calculateVideoCost('sora-2', 8);  // 8 seconds
console.log(`Sora 2 (8s): $${soraCost}`);  // $0.80

// Historical Sora 2 Pro pricing: $0.30/second (generation is retired)
const proCost = calculateVideoCost('sora-2-pro', 12);  // 12 seconds
console.log(`Sora 2 Pro (12s): $${proCost}`);  // $3.60

// Veo 3.1 Lite at 1080p: $0.08/second
const veoCost = calculateVideoCost('veo-3.1-lite-generate-preview', 8, {
  resolution: '1080p',
});
console.log(`Veo 3.1 Lite (8s, 1080p): $${veoCost}`); // $0.64

// Grok 1.5 at 1080p plus one image input.
const grokCost = calculateVideoCost('grok-imagine-video-1.5', 8, {
  resolution: '1080p',
  inputImages: 1,
});
console.log(`Grok Imagine 1.5 (8s, 1080p): $${grokCost}`); // $2.01

try {
  const job = await videoGen.generate({
    prompt: 'A video',
    duration: 8,
  });

  const result = await videoGen.waitForCompletion(job.jobId, 300000); // 5 min timeout

  if (result.status === 'completed') {
    const buffer = await videoGen.download(result.jobId);
    await fs.writeFile('./output.mp4', buffer);
  }
} catch (error) {
  if (error.message.includes('timed out')) {
    console.error('Video generation took too long');
  } else if (error.message.includes('failed')) {
    console.error('Video generation failed:', error.message);
  } else if (error.message.includes('policy')) {
    console.error('Content policy violation');
  } else {
    console.error('Error:', error.message);
  }
}

// Cancel a pending job
const job = await videoGen.generate({ prompt: '...', duration: 8 });

// Changed your mind? Cancel it
const cancelled = await videoGen.cancel(job.jobId);
console.log('Cancelled:', cancelled);  // true