Letzai Api

/**
 * LetzAI Image Generation Examples
 * 
 * This file demonstrates how to generate images using the LetzAI API
 * with various models and configurations.
 */

const API_BASE_URL = 'https://api.letz.ai';

// Replace with your actual API key
const API_KEY = process.env.LETZAI_API_KEY || 'YOUR_API_KEY';

const headers = {
  'Content-Type': 'application/json',
  'Authorization': `Bearer ${API_KEY}`
};

/**
 * Sleep utility for polling
 */
const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

/**
 * Poll for image completion
 * @param {string} imageId - The image generation job ID
 * @param {number} intervalMs - Polling interval in milliseconds (default: 3000)
 * @param {number} maxAttempts - Maximum polling attempts (default: 60)
 * @returns {Promise<Object>} - The completed image object
 */
async function pollImageStatus(imageId, intervalMs = 3000, maxAttempts = 60) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const response = await fetch(`${API_BASE_URL}/images/${imageId}`, { headers });
    const data = await response.json();
    
    console.log(`Attempt ${attempt + 1}: Status = ${data.status}`);
    
    if (data.status === 'ready') {
      return data;
    }
    
    if (data.status === 'failed') {
      throw new Error(`Image generation failed: ${data.error || 'Unknown error'}`);
    }
    
    await sleep(intervalMs);
  }
  
  throw new Error('Image generation timed out');
}

/**
 * Example 1: Basic Image Generation with Nano Banana Pro
 * 
 * Uses the recommended model for high-quality images
 */
async function generateBasicImage() {
  console.log('=== Basic Image Generation ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: 'A beautiful sunset over a calm ocean with vibrant orange and purple colors',
      baseModel: 'gemini-3-pro-image-preview',
      mode: '2k'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Image generation started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  console.log(`Credits used: ${result.creditsUsed}`);
  
  return result;
}

/**
 * Example 2: High-Resolution Image with Custom Dimensions
 * 
 * Generates a 4K image with specific dimensions
 */
async function generateHighResImage() {
  console.log('=== High-Resolution Image Generation ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: 'A majestic eagle soaring through snow-capped mountains, dramatic lighting, photorealistic',
      baseModel: 'gemini-3-pro-image-preview',
      mode: '4k',
      width: 2160,
      height: 1440,
      negativePrompt: 'blurry, low quality, distorted'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`High-res generation started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  console.log(`Dimensions: ${result.width}x${result.height}`);
  
  return result;
}

/**
 * Example 3: Image Generation with Flux2 Max
 * 
 * Uses the Flux2 Max model for creative styles
 */
async function generateFlux2Image() {
  console.log('=== Flux2 Max Image Generation ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: 'Cyberpunk city street at night, neon lights reflecting on wet pavement, futuristic',
      baseModel: 'flux2-max',
      mode: 'hd',
      aspectRatio: '16:9'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Flux2 generation started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  
  return result;
}

/**
 * Example 4: Image Generation with SeeDream
 * 
 * Uses the SeeDream 4.5 model
 */
async function generateSeeDreamImage() {
  console.log('=== SeeDream Image Generation ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: 'A serene Japanese garden with cherry blossoms, koi pond, and wooden bridge',
      baseModel: 'seedream-4-5-251128',
      mode: '2k'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`SeeDream generation started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  
  return result;
}

/**
 * Example 5: Reproducible Generation with Seed
 * 
 * Uses a seed for reproducible results
 */
async function generateWithSeed() {
  console.log('=== Reproducible Generation with Seed ===\n');
  
  const seed = 12345;
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: 'A fantasy castle on a floating island surrounded by clouds',
      baseModel: 'gemini-3-pro-image-preview',
      mode: '2k',
      seed: seed
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Generation with seed ${seed} started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  console.log(`Use the same seed (${seed}) to reproduce this exact image`);
  
  return result;
}

/**
 * Example 6: Batch Generation with Different Models
 * 
 * Generates multiple images with different models in parallel
 */
async function generateBatch() {
  console.log('=== Batch Generation ===\n');
  
  const prompts = [
    {
      prompt: 'Abstract art with flowing colors',
      baseModel: 'gemini-3-pro-image-preview',
      mode: 'default'
    },
    {
      prompt: 'Abstract art with flowing colors',
      baseModel: 'flux2-max',
      mode: '1k'
    },
    {
      prompt: 'Abstract art with flowing colors',
      baseModel: 'seedream-4-5-251128',
      mode: '2k'
    }
  ];
  
  // Start all generations
  const startPromises = prompts.map(async (config) => {
    const response = await fetch(`${API_BASE_URL}/images`, {
      method: 'POST',
      headers,
      body: JSON.stringify(config)
    });
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(`API Error: ${error.error}`);
    }
    
    const data = await response.json();
    console.log(`Started ${config.baseModel}: ${data.id}`);
    return { ...data, model: config.baseModel };
  });
  
  const jobs = await Promise.all(startPromises);
  
  // Poll all in parallel
  const results = await Promise.all(
    jobs.map(job => pollImageStatus(job.id))
  );
  
  console.log('\n=== All Images Ready ===');
  results.forEach((result, i) => {
    console.log(`\n${jobs[i].model}:`);
    console.log(`  URL: ${result.imageVersions.original}`);
    console.log(`  Credits: ${result.creditsUsed}`);
  });
  
  return results;
}

/**
 * Example 7: Error Handling
 * 
 * Demonstrates proper error handling
 */
async function generateWithErrorHandling() {
  console.log('=== Image Generation with Error Handling ===\n');
  
  try {
    const response = await fetch(`${API_BASE_URL}/images`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        prompt: 'A beautiful landscape',
        baseModel: 'gemini-3-pro-image-preview',
        mode: '2k'
      })
    });
    
    // Handle HTTP errors
    if (!response.ok) {
      const error = await response.json();
      
      switch (response.status) {
        case 401:
          throw new Error('Invalid API key. Please check your credentials.');
        case 402:
          throw new Error('Insufficient credits. Please top up at letz.ai/subscription');
        case 400:
          throw new Error(`Invalid parameters: ${error.error}`);
        case 429:
          throw new Error('Rate limited. Please wait before making more requests.');
        default:
          throw new Error(`API Error (${response.status}): ${error.error}`);
      }
    }
    
    const { id } = await response.json();
    console.log(`Generation started. ID: ${id}`);
    
    const result = await pollImageStatus(id);
    console.log(`\nImage ready!`);
    console.log(`URL: ${result.imageVersions.original}`);
    
    return result;
    
  } catch (error) {
    console.error(`Error: ${error.message}`);
    
    // Implement retry logic for transient errors
    if (error.message.includes('Rate limited')) {
      console.log('Retrying after delay...');
      await sleep(5000);
      // Could retry here
    }
    
    throw error;
  }
}

// =============================================================================
// Context Editing Examples
// =============================================================================

/**
 * Poll for image edit completion
 * @param {string} editId - The image edit job ID
 * @param {number} intervalMs - Polling interval in milliseconds (default: 3000)
 * @param {number} maxAttempts - Maximum polling attempts (default: 60)
 * @returns {Promise<Object>} - The completed edit object
 */
async function pollEditStatus(editId, intervalMs = 3000, maxAttempts = 60) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const response = await fetch(`${API_BASE_URL}/image-edits/${editId}`, { headers });
    const data = await response.json();
    
    console.log(`Attempt ${attempt + 1}: Status = ${data.status}`);
    
    if (data.status === 'ready') {
      return data;
    }
    
    if (data.status === 'failed') {
      throw new Error(`Image edit failed: ${data.error || 'Unknown error'}`);
    }
    
    await sleep(intervalMs);
  }
  
  throw new Error('Image edit timed out');
}

/**
 * Example: Context Editing - Single Image
 * 
 * Edits an existing image using AI-powered context editing
 */
async function contextEditSingleImage(imageUrl, editPrompt) {
  console.log('=== Context Edit - Single Image ===\n');
  
  const response = await fetch(`${API_BASE_URL}/image-edits`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      mode: 'context',
      prompt: editPrompt,
      imageUrl: imageUrl,
      settings: {
        resolution: '2k',
        aspect_ratio: '16:9',
        model: 'gemini-3-pro-image-preview'
      }
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Edit started. ID: ${id}`);
  
  const result = await pollEditStatus(id);
  console.log(`\nEdit complete!`);
  console.log(`Edited image: ${result.generatedImageCompletion.imageVersions.original}`);
  
  return result;
}

/**
 * Example: Context Editing - Multi-Reference
 * 
 * Uses multiple reference images for editing
 */
async function contextEditMultiReference(imageUrls, editPrompt) {
  console.log('=== Context Edit - Multi-Reference ===\n');
  
  if (imageUrls.length > 9) {
    throw new Error('Maximum 9 reference images allowed');
  }
  
  const response = await fetch(`${API_BASE_URL}/image-edits`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      mode: 'context',
      prompt: editPrompt,
      inputImageUrls: imageUrls,
      settings: {
        resolution: '4k',
        model: 'gemini-3-pro-image-preview'
      }
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Multi-reference edit started. ID: ${id}`);
  
  const result = await pollEditStatus(id);
  console.log(`\nEdit complete!`);
  console.log(`Edited image: ${result.generatedImageCompletion.imageVersions.original}`);
  
  return result;
}

/**
 * Example: Edit Previously Generated LetzAI Image
 * 
 * Uses originalImageCompletionId to edit an existing LetzAI image
 */
async function editLetzAIImage(imageCompletionId, editPrompt) {
  console.log('=== Edit LetzAI Image ===\n');
  
  const response = await fetch(`${API_BASE_URL}/image-edits`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      mode: 'context',
      prompt: editPrompt,
      originalImageCompletionId: imageCompletionId,
      settings: {
        resolution: '2k',
        model: 'gemini-3-pro-image-preview'
      }
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Edit of ${imageCompletionId} started. ID: ${id}`);
  
  const result = await pollEditStatus(id);
  console.log(`\nEdit complete!`);
  console.log(`Original: ${result.originalImageCompletion?.imageVersions?.original || 'N/A'}`);
  console.log(`Edited: ${result.generatedImageCompletion.imageVersions.original}`);
  
  return result;
}

// =============================================================================
// Custom Trained Models Examples
// =============================================================================

/**
 * Example 8: List Available Trained Models
 * 
 * Retrieves user's custom trained models (persons, objects, styles)
 */
async function listTrainedModels(modelClass = null) {
  console.log('=== List Trained Models ===\n');
  
  let url = `${API_BASE_URL}/models?limit=10&sortBy=usages&sortOrder=DESC`;
  if (modelClass) {
    url += `&class=${modelClass}`;
  }
  
  const response = await fetch(url, { headers });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const data = await response.json();
  
  console.log(`Found ${data.data?.length || 0} models:`);
  (data.data || []).forEach(model => {
    console.log(`  - @${model.name} (${model.class}) - ${model.usages} uses`);
  });
  
  return data;
}

/**
 * Example 9: Generate Image with Custom Person Model
 * 
 * Uses a trained person model via @modelname syntax
 */
async function generateWithPersonModel(modelName) {
  console.log('=== Generate with Person Model ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: `@${modelName} standing on a beach at sunset, professional photography`,
      baseModel: 'gemini-3-pro-image-preview',
      mode: '2k'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Generation with @${modelName} started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  
  return result;
}

/**
 * Example 10: Generate Image with Custom Style Model
 * 
 * Uses a trained style model for artistic effects
 */
async function generateWithStyleModel(styleName) {
  console.log('=== Generate with Style Model ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: `A portrait of a woman in @${styleName} aesthetic, dramatic lighting`,
      baseModel: 'gemini-3-pro-image-preview',
      mode: '2k'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Generation with @${styleName} style started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  
  return result;
}

/**
 * Example 11: Generate Product Photo with Object Model
 * 
 * Uses a trained object/product model
 */
async function generateWithObjectModel(objectName) {
  console.log('=== Generate with Object Model ===\n');
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: `Professional product photo featuring @${objectName} on a white background, studio lighting`,
      baseModel: 'gemini-3-pro-image-preview',
      mode: '2k'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Generation with @${objectName} started. ID: ${id}`);
  
  const result = await pollImageStatus(id);
  console.log(`\nImage ready!`);
  console.log(`URL: ${result.imageVersions.original}`);
  
  return result;
}

/**
 * Example 12: Complete Workflow with Custom Model
 * 
 * Lists models, selects one, and generates an image
 */
async function completeCustomModelWorkflow() {
  console.log('=== Complete Custom Model Workflow ===\n');
  
  // Step 1: List available person models
  console.log('Step 1: Fetching available person models...');
  const modelsResponse = await fetch(
    `${API_BASE_URL}/models?class=person&limit=5&sortBy=usages&sortOrder=DESC`,
    { headers }
  );
  
  if (!modelsResponse.ok) {
    throw new Error('Failed to fetch models');
  }
  
  const modelsData = await modelsResponse.json();
  const models = modelsData.data || [];
  
  if (models.length === 0) {
    console.log('No person models found. Train models at letz.ai first.');
    return null;
  }
  
  console.log(`Found ${models.length} person models:`);
  models.forEach(m => console.log(`  - @${m.name}`));
  
  // Step 2: Use the most-used model
  const selectedModel = models[0];
  console.log(`\nStep 2: Using @${selectedModel.name} for generation...`);
  
  const response = await fetch(`${API_BASE_URL}/images`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      prompt: `@${selectedModel.name} in a modern office, professional headshot`,
      baseModel: 'gemini-3-pro-image-preview',
      mode: '2k'
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }
  
  const { id } = await response.json();
  console.log(`Generation started. ID: ${id}`);
  
  // Step 3: Poll for result
  console.log('\nStep 3: Waiting for generation...');
  const result = await pollImageStatus(id);
  
  console.log('\n=== Workflow Complete ===');
  console.log(`Model used: @${selectedModel.name}`);
  console.log(`Image URL: ${result.imageVersions.original}`);
  
  return result;
}

// Main execution
async function main() {
  try {
    // Run examples
    await generateBasicImage();
    console.log('\n---\n');
    
    // Uncomment to run other examples:
    // await generateHighResImage();
    // await generateFlux2Image();
    // await generateSeeDreamImage();
    // await generateWithSeed();
    // await generateBatch();
    // await generateWithErrorHandling();
    
    // Custom model examples (requires trained models):
    // await listTrainedModels('person');
    // await generateWithPersonModel('john_doe');
    // await generateWithStyleModel('vintage_style');
    // await generateWithObjectModel('my_product');
    // await completeCustomModelWorkflow();
    
  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

// Run if executed directly
main();

// Export functions for use as module
module.exports = {
  // Base model examples
  generateBasicImage,
  generateHighResImage,
  generateFlux2Image,
  generateSeeDreamImage,
  generateWithSeed,
  generateBatch,
  generateWithErrorHandling,
  // Context editing examples
  contextEditSingleImage,
  contextEditMultiReference,
  editLetzAIImage,
  // Custom model examples
  listTrainedModels,
  generateWithPersonModel,
  generateWithStyleModel,
  generateWithObjectModel,
  completeCustomModelWorkflow,
  // Utilities
  pollImageStatus,
  pollEditStatus
};

"""
LetzAI Video Generation Examples

This module demonstrates how to generate videos using the LetzAI API
with various models and configurations.
"""

import os
import time
import requests
from typing import Optional, Dict, Any

API_BASE_URL = "https://api.letz.ai"
API_KEY = os.environ.get("LETZAI_API_KEY", "YOUR_API_KEY")

HEADERS = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}


def poll_status(
    endpoint: str,
    job_id: str,
    interval_seconds: float = 3.0,
    max_attempts: int = 120
) -> Dict[str, Any]:
    """
    Poll for job completion.
    
    Args:
        endpoint: API endpoint (e.g., 'images', 'videos')
        job_id: The job ID to poll
        interval_seconds: Time between polls (default: 3s for images, 2-3s for videos)
        max_attempts: Maximum number of polling attempts
        
    Returns:
        The completed job data
        
    Raises:
        TimeoutError: If job doesn't complete within max_attempts
        RuntimeError: If job fails
    """
    url = f"{API_BASE_URL}/{endpoint}/{job_id}"
    
    for attempt in range(max_attempts):
        response = requests.get(url, headers=HEADERS)
        response.raise_for_status()
        data = response.json()
        
        status = data.get("status", "")
        print(f"Attempt {attempt + 1}: Status = {status}")
        
        if status == "ready":
            return data
        
        if status == "failed":
            error_msg = data.get("error", "Unknown error")
            raise RuntimeError(f"Job failed: {error_msg}")
        
        time.sleep(interval_seconds)
    
    raise TimeoutError(f"Job {job_id} did not complete within {max_attempts} attempts")


def poll_image_status(image_id: str) -> Dict[str, Any]:
    """Poll for image completion (3s interval)."""
    return poll_status("images", image_id, interval_seconds=3.0)


def poll_video_status(video_id: str) -> Dict[str, Any]:
    """Poll for video completion (2.5s interval)."""
    return poll_status("videos", video_id, interval_seconds=2.5)


# =============================================================================
# Image Generation (needed for video source)
# =============================================================================

def generate_source_image(prompt: str) -> Dict[str, Any]:
    """
    Generate a source image for video creation.
    
    Args:
        prompt: Text description of the image
        
    Returns:
        The completed image data including ID and URLs
    """
    print("=== Generating Source Image ===\n")
    
    response = requests.post(
        f"{API_BASE_URL}/images",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "baseModel": "gemini-3-pro-image-preview",
            "mode": "2k"
        }
    )
    response.raise_for_status()
    
    data = response.json()
    image_id = data["id"]
    print(f"Image generation started. ID: {image_id}")
    
    result = poll_image_status(image_id)
    print(f"\nImage ready!")
    print(f"URL: {result['imageVersions']['original']}")
    
    return result


# =============================================================================
# Video Generation Examples
# =============================================================================

def generate_video_from_url(
    prompt: str,
    image_url: str,
    mode: str = "default",
    duration: int = 5
) -> Dict[str, Any]:
    """
    Example 1: Generate video from an image URL.
    
    Args:
        prompt: Text description of the video motion
        image_url: URL of the source image
        mode: Video model ('default', 'veo31', 'kling26', 'wan25')
        duration: Video duration in seconds
        
    Returns:
        The completed video data
    """
    print(f"=== Video Generation from URL ({mode}) ===\n")
    
    response = requests.post(
        f"{API_BASE_URL}/videos",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "imageUrl": image_url,
            "settings": {
                "mode": mode,
                "duration": duration
            }
        }
    )
    response.raise_for_status()
    
    data = response.json()
    video_id = data["id"]
    print(f"Video generation started. ID: {video_id}")
    
    result = poll_video_status(video_id)
    print(f"\nVideo ready!")
    print(f"MP4 URL: {result['videoPaths'].get('mp4', 'N/A')}")
    print(f"Credits used: {result.get('creditsUsed', 'N/A')}")
    
    return result


def generate_video_from_image_id(
    prompt: str,
    image_completion_id: str,
    mode: str = "kling26",
    duration: int = 5
) -> Dict[str, Any]:
    """
    Example 2: Generate video from a previously generated image ID.
    
    This is more efficient if you've already generated an image with LetzAI.
    
    Args:
        prompt: Text description of the video motion
        image_completion_id: ID from previous image generation
        mode: Video model
        duration: Video duration in seconds
        
    Returns:
        The completed video data
    """
    print(f"=== Video Generation from Image ID ({mode}) ===\n")
    
    response = requests.post(
        f"{API_BASE_URL}/videos",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "originalImageCompletionId": image_completion_id,
            "settings": {
                "mode": mode,
                "duration": duration
            }
        }
    )
    response.raise_for_status()
    
    data = response.json()
    video_id = data["id"]
    print(f"Video generation started. ID: {video_id}")
    
    result = poll_video_status(video_id)
    print(f"\nVideo ready!")
    print(f"MP4 URL: {result['videoPaths'].get('mp4', 'N/A')}")
    
    return result


def generate_video_veo31(
    prompt: str,
    image_url: str
) -> Dict[str, Any]:
    """
    Example 3: Generate high-quality video with VEO 3.1.
    
    VEO 3.1 produces the highest quality videos at 8 seconds duration.
    
    Args:
        prompt: Text description of the video motion
        image_url: URL of the source image
        
    Returns:
        The completed video data
    """
    print("=== VEO 3.1 Video Generation ===\n")
    
    response = requests.post(
        f"{API_BASE_URL}/videos",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "imageUrl": image_url,
            "settings": {
                "mode": "veo31"
                # VEO 3.1 has fixed 8-second duration
            }
        }
    )
    response.raise_for_status()
    
    data = response.json()
    video_id = data["id"]
    print(f"VEO 3.1 generation started. ID: {video_id}")
    print("Note: VEO 3.1 may take longer to generate...")
    
    # VEO can take longer, increase polling time
    result = poll_status("videos", video_id, interval_seconds=5.0, max_attempts=120)
    print(f"\nVideo ready!")
    print(f"MP4 URL: {result['videoPaths'].get('mp4', 'N/A')}")
    print(f"Credits used: {result.get('creditsUsed', 'N/A')} (VEO 3.1 uses 1500-6000 credits)")
    
    return result


def generate_video_kling(
    prompt: str,
    image_url: str,
    duration: int = 10
) -> Dict[str, Any]:
    """
    Example 4: Generate video with Kling 2.6.
    
    Kling 2.6 offers a good balance of quality and duration (5-10 seconds).
    
    Args:
        prompt: Text description of the video motion
        image_url: URL of the source image
        duration: Video duration (5-10 seconds)
        
    Returns:
        The completed video data
    """
    print("=== Kling 2.6 Video Generation ===\n")
    
    response = requests.post(
        f"{API_BASE_URL}/videos",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "imageUrl": image_url,
            "settings": {
                "mode": "kling26",
                "duration": min(max(duration, 5), 10)  # Clamp to 5-10
            }
        }
    )
    response.raise_for_status()
    
    data = response.json()
    video_id = data["id"]
    print(f"Kling 2.6 generation started. ID: {video_id}")
    
    result = poll_video_status(video_id)
    print(f"\nVideo ready!")
    print(f"MP4 URL: {result['videoPaths'].get('mp4', 'N/A')}")
    
    return result


def generate_video_wan(
    prompt: str,
    image_url: str,
    duration: int = 5
) -> Dict[str, Any]:
    """
    Example 5: Generate video with Wan 2.5.
    
    Wan 2.5 is good for smooth motion effects.
    
    Args:
        prompt: Text description of the video motion
        image_url: URL of the source image
        duration: Video duration (5-10 seconds)
        
    Returns:
        The completed video data
    """
    print("=== Wan 2.5 Video Generation ===\n")
    
    response = requests.post(
        f"{API_BASE_URL}/videos",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "imageUrl": image_url,
            "settings": {
                "mode": "wan25",
                "duration": duration
            }
        }
    )
    response.raise_for_status()
    
    data = response.json()
    video_id = data["id"]
    print(f"Wan 2.5 generation started. ID: {video_id}")
    
    result = poll_video_status(video_id)
    print(f"\nVideo ready!")
    print(f"MP4 URL: {result['videoPaths'].get('mp4', 'N/A')}")
    
    return result


# =============================================================================
# Complete Workflow Examples
# =============================================================================

def complete_image_to_video_workflow():
    """
    Example 6: Complete workflow - generate image then video.
    
    This demonstrates the full workflow of:
    1. Generating a source image
    2. Creating a video from that image
    """
    print("=" * 60)
    print("COMPLETE IMAGE-TO-VIDEO WORKFLOW")
    print("=" * 60 + "\n")
    
    # Step 1: Generate source image
    image_result = generate_source_image(
        "A majestic lion standing on a rock at sunset, golden savanna in background"
    )
    image_id = image_result["id"]
    
    print("\n" + "-" * 40 + "\n")
    
    # Step 2: Generate video from the image
    video_result = generate_video_from_image_id(
        prompt="The lion slowly turns its head and looks at the camera, wind blowing through its mane",
        image_completion_id=image_id,
        mode="kling26",
        duration=5
    )
    
    print("\n" + "=" * 60)
    print("WORKFLOW COMPLETE")
    print("=" * 60)
    print(f"Source Image: {image_result['imageVersions']['original']}")
    print(f"Video: {video_result['videoPaths'].get('mp4', 'N/A')}")
    
    return {
        "image": image_result,
        "video": video_result
    }


def compare_video_models(image_url: str):
    """
    Example 7: Compare different video models.
    
    Generates videos with different models from the same source image.
    
    Args:
        image_url: URL of the source image
    """
    print("=" * 60)
    print("COMPARING VIDEO MODELS")
    print("=" * 60 + "\n")
    
    prompt = "Gentle camera pan with subtle motion, cinematic"
    
    models = [
        {"mode": "default", "duration": 4},
        {"mode": "kling26", "duration": 5},
        # Uncomment for VEO (expensive):
        # {"mode": "veo31"},
    ]
    
    results = {}
    
    for config in models:
        mode = config["mode"]
        print(f"\n--- Testing {mode} ---\n")
        
        try:
            response = requests.post(
                f"{API_BASE_URL}/videos",
                headers=HEADERS,
                json={
                    "prompt": prompt,
                    "imageUrl": image_url,
                    "settings": config
                }
            )
            response.raise_for_status()
            
            data = response.json()
            video_id = data["id"]
            
            result = poll_video_status(video_id)
            results[mode] = {
                "url": result["videoPaths"].get("mp4", "N/A"),
                "credits": result.get("creditsUsed", "N/A")
            }
            
        except Exception as e:
            print(f"Error with {mode}: {e}")
            results[mode] = {"error": str(e)}
    
    print("\n" + "=" * 60)
    print("COMPARISON RESULTS")
    print("=" * 60)
    
    for mode, data in results.items():
        print(f"\n{mode}:")
        if "error" in data:
            print(f"  Error: {data['error']}")
        else:
            print(f"  URL: {data['url']}")
            print(f"  Credits: {data['credits']}")
    
    return results


# =============================================================================
# Error Handling Example
# =============================================================================

def generate_video_with_error_handling(
    prompt: str,
    image_url: str,
    mode: str = "default"
) -> Optional[Dict[str, Any]]:
    """
    Example 8: Video generation with comprehensive error handling.
    
    Args:
        prompt: Text description of the video motion
        image_url: URL of the source image
        mode: Video model
        
    Returns:
        The completed video data, or None if failed
    """
    print("=== Video Generation with Error Handling ===\n")
    
    try:
        response = requests.post(
            f"{API_BASE_URL}/videos",
            headers=HEADERS,
            json={
                "prompt": prompt,
                "imageUrl": image_url,
                "settings": {"mode": mode}
            }
        )
        
        # Handle HTTP errors
        if response.status_code == 401:
            raise ValueError("Invalid API key. Check your credentials at letz.ai/subscription")
        elif response.status_code == 402:
            raise ValueError("Insufficient credits. Top up at letz.ai/subscription")
        elif response.status_code == 400:
            error_data = response.json()
            raise ValueError(f"Invalid parameters: {error_data.get('error', 'Unknown')}")
        elif response.status_code == 429:
            raise ValueError("Rate limited. Please wait before making more requests.")
        
        response.raise_for_status()
        
        data = response.json()
        video_id = data["id"]
        print(f"Video generation started. ID: {video_id}")
        
        result = poll_video_status(video_id)
        print(f"\nVideo ready!")
        print(f"MP4 URL: {result['videoPaths'].get('mp4', 'N/A')}")
        
        return result
        
    except requests.exceptions.ConnectionError:
        print("Error: Could not connect to LetzAI API. Check your internet connection.")
        return None
        
    except requests.exceptions.Timeout:
        print("Error: Request timed out. Try again later.")
        return None
        
    except ValueError as e:
        print(f"Error: {e}")
        return None
        
    except RuntimeError as e:
        print(f"Generation failed: {e}")
        return None
        
    except TimeoutError as e:
        print(f"Timeout: {e}")
        return None
        
    except Exception as e:
        print(f"Unexpected error: {e}")
        return None


# =============================================================================
# Main Entry Point
# =============================================================================

def main():
    """Run example demonstrations."""
    
    # First, generate a source image
    print("First, we need a source image for video generation...\n")
    
    try:
        image_result = generate_source_image(
            "A serene mountain lake at dawn with mist rising from the water"
        )
        image_url = image_result["imageVersions"]["original"]
        
        print("\n" + "=" * 60 + "\n")
        
        # Generate a video from the image
        generate_video_from_url(
            prompt="Gentle ripples spread across the lake as morning light intensifies",
            image_url=image_url,
            mode="default",
            duration=4
        )
        
        # Uncomment to run other examples:
        # generate_video_kling(prompt="...", image_url=image_url)
        # generate_video_veo31(prompt="...", image_url=image_url)
        # complete_image_to_video_workflow()
        
    except Exception as e:
        print(f"Error: {e}")
        return 1
    
    return 0


if __name__ == "__main__":
    exit(main())

MIT License

Copyright (c) 2025 LetzAI

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.