Optimizing Latency for Real-time Video

# Fast option (~30s)
result = client.run("fal-ai/ltx-video", {
    "input": {"prompt": "...", "duration": 3}
})

# Balanced option (~45s)
result = client.run("fal-ai/hunyuan-video", {
    "input": {"prompt": "...", "duration": 5}
})

# Quality option (~90s)
result = client.run("fal-ai/kling-video/v1/standard/text-to-video", {
    "input": {"prompt": "..."}
})

async function generateWithPreview(prompt) {
  // 1. Generate a quick preview image first
  const preview = await client.run('fal-ai/flux/schnell', {
    input: { prompt: prompt + ', first frame of video' }
  });
  
  showPreview(preview.images[0].url);
  
  // 2. Start video generation
  const video = await client.run('fal-ai/minimax/video-01', {
    input: { prompt }
  });
  
  return video;
}

const ws = new WebSocket('wss://api.abstrakt.one/v1/stream');

ws.onopen = () => {
  ws.send(JSON.stringify({
    action: 'generate',
    model: 'fal-ai/minimax/video-01',
    input: { prompt: '...' },
    api_key: 'YOUR_KEY'
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  
  switch (data.type) {
    case 'progress':
      updateProgressBar(data.progress);
      break;
    case 'preview':
      showPreviewFrame(data.frame_url);
      break;
    case 'complete':
      playVideo(data.video_url);
      break;
  }
};

class VideoCache:
    def __init__(self):
        self.cache = {}
        self.client = AbstraktClient()
    
    async def warm_cache(self, common_prompts):
        """Pre-generate common videos"""
        for prompt in common_prompts:
            if prompt not in self.cache:
                result = await self.client.run_async(
                    "fal-ai/ltx-video",
                    {"input": {"prompt": prompt}}
                )
                self.cache[prompt] = result.video.url
    
    async def get_video(self, prompt):
        if prompt in self.cache:
            return self.cache[prompt]
        # Generate on-demand if not cached
        result = await self.client.run_async(...)
        return result.video.url

# Fast: 480p
{"resolution": {"width": 854, "height": 480}}

# Balanced: 720p
{"resolution": {"width": 1280, "height": 720}}

# Quality: 1080p
{"resolution": {"width": 1920, "height": 1080}}

# 3 seconds = ~30s generation
# 5 seconds = ~45s generation
# 10 seconds = ~90s generation

import time

start = time.time()
result = client.run("fal-ai/minimax/video-01", {...})
latency = time.time() - start

# Log to your metrics system
metrics.record('video_generation_latency', latency, {
    'model': 'minimax',
    'duration': 5
})