myaidev-method 0.2.12 → 0.2.16

package/src/lib/visual-generation-utils.js

@@ -0,0 +1,880 @@
+/**
+ * Visual Content Generation Utilities
+ *
+ * Provides image and video generation capabilities using:
+ * - Google Gemini 2.5 Flash Image ("Nano Banana")
+ * - Google Imagen 3
+ * - OpenAI GPT-Image-1 (GPT-4o Image Generation)
+ * - Google Veo 2 (video)
+ *
+ * Platform support: Claude Code, Gemini CLI, Codex CLI
+ *
+ * @module visual-generation-utils
+ */
+
+import fetch from 'node-fetch';
+import fs from 'fs-extra';
+import path from 'path';
+import dotenv from 'dotenv';
+import { GoogleAuth } from 'google-auth-library';
+
+dotenv.config();
+
+// API Configuration
+const GOOGLE_API_BASE = 'https://generativelanguage.googleapis.com/v1beta';
+const OPENAI_API_BASE = 'https://api.openai.com/v1';
+
+/**
+ * Get OAuth2 access token for Vertex AI
+ * Uses Google Application Default Credentials (ADC)
+ *
+ * @returns {Promise<string>} OAuth2 access token
+ * @throws {Error} If authentication fails
+ */
+async function getVertexAIToken() {
+  try {
+    const auth = new GoogleAuth({
+      scopes: ['https://www.googleapis.com/auth/cloud-platform']
+    });
+
+    const client = await auth.getClient();
+    const tokenResponse = await client.getAccessToken();
+
+    if (!tokenResponse.token) {
+      throw new Error('Failed to obtain access token');
+    }
+
+    return tokenResponse.token;
+  } catch (error) {
+    throw new Error(`Vertex AI authentication failed: ${error.message}`);
+  }
+}
+
+// Pricing (USD per image/video) - GPT-Image-1 pricing
+const PRICING = {
+  gemini: 0.02,        // Gemini 2.5 Flash Image (direct Google API)
+  imagen: 0.03,        // Imagen 3 (direct Google API)
+  dalle_low: 0.02,     // GPT-Image-1 low quality
+  dalle_medium: 0.07,  // GPT-Image-1 medium quality
+  dalle_standard: 0.07, // GPT-Image-1 medium quality (alias for standard)
+  dalle_high: 0.19,    // GPT-Image-1 high quality
+  dalle_hd: 0.19,      // GPT-Image-1 high quality (alias for hd)
+  veo: 0.10,           // Veo 2 (estimated per video)
+  // Fal.ai pricing
+  flux_pro: 0.06,      // FLUX Pro v1.1 Ultra
+  flux_dev: 0.025,     // FLUX Dev (per megapixel)
+  veo3: 0.40,          // Veo 3 (per second)
+  gemini_fal: 0.0398,  // Gemini via fal.ai (fallback)
+  imagen_fal: 0.05     // Imagen via fal.ai (fallback)
+};
+
+/**
+ * Validate that required API keys are configured
+ *
+ * @returns {Object} Validation results
+ * @returns {boolean} hasGoogle - Google API key is configured
+ * @returns {boolean} hasOpenAI - OpenAI API key is configured
+ * @returns {boolean} hasAny - At least one API key is configured
+ * @returns {Array<string>} availableServices - List of available services
+ */
+export function validateAPIKeys() {
+  const googleKey = process.env.GOOGLE_API_KEY;
+  const openaiKey = process.env.OPENAI_API_KEY;
+
+  const hasGoogle = !!(googleKey && googleKey.length > 20);
+  const hasOpenAI = !!(openaiKey && openaiKey.length > 20);
+
+  const availableServices = [];
+  if (hasGoogle) {
+    availableServices.push('gemini', 'imagen', 'veo');
+  }
+  if (hasOpenAI) {
+    availableServices.push('dalle');
+  }
+
+  return {
+    hasGoogle,
+    hasOpenAI,
+    hasAny: hasGoogle || hasOpenAI,
+    availableServices
+  };
+}
+
+/**
+ * Estimate cost for image/video generation
+ *
+ * @param {string} service - Service name (gemini, imagen, dalle, veo)
+ * @param {Object} options - Generation options
+ * @param {string} options.quality - Quality level (standard, hd)
+ * @param {string} options.size - Image size
+ * @returns {number} Estimated cost in USD
+ */
+export function estimateCost(service, options = {}) {
+  const { quality = 'high', size = '1024x1024' } = options;
+
+  switch (service) {
+    case 'gemini':
+      return PRICING.gemini;
+
+    case 'imagen':
+      return PRICING.imagen;
+
+    case 'dalle':
+      // GPT-Image-1 quality-based pricing
+      if (quality === 'low') {
+        return PRICING.dalle_low;
+      } else if (quality === 'medium' || quality === 'standard') {
+        return PRICING.dalle_medium;
+      } else if (quality === 'high' || quality === 'hd') {
+        return PRICING.dalle_high;
+      }
+      return PRICING.dalle_high; // default to high quality
+
+    case 'veo':
+      return PRICING.veo;
+
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Select best available service based on preferences
+ *
+ * @param {string} preferred - Preferred service name
+ * @returns {string} Selected service name
+ * @throws {Error} If no API keys are configured
+ */
+export function selectBestService(preferred = 'gemini') {
+  const { availableServices, hasAny } = validateAPIKeys();
+
+  if (!hasAny) {
+    throw new Error('No API keys configured. Run /myai-configure visual to set up image generation.');
+  }
+
+  // Return preferred service if available
+  if (availableServices.includes(preferred)) {
+    return preferred;
+  }
+
+  // Fallback to first available service
+  return availableServices[0];
+}
+
+/**
+ * Generate image using Google Gemini 2.5 Flash Image ("Nano Banana")
+ * Fast and cost-effective image generation
+ *
+ * @param {string} prompt - Image description
+ * @param {Object} options - Generation options
+ * @param {number} options.aspectRatio - Aspect ratio (1 for square, 16/9 for wide)
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated image data
+ */
+export async function generateImageGemini(prompt, options = {}) {
+  const {
+    aspectRatio = 1,
+    maxRetries = 3
+  } = options;
+
+  const apiKey = process.env.GOOGLE_API_KEY;
+  if (!apiKey) {
+    throw new Error('GOOGLE_API_KEY not configured');
+  }
+
+  const endpoint = `${GOOGLE_API_BASE}/models/gemini-2.0-flash-exp:generateContent`;
+
+  const requestBody = {
+    contents: [{
+      parts: [{
+        text: `Generate an image: ${prompt}\n\nAspect ratio: ${aspectRatio === 16/9 ? '16:9' : '1:1'}\nStyle: Professional, high quality, suitable for article content`
+      }]
+    }],
+    generationConfig: {
+      temperature: 0.4,
+      topP: 0.95,
+      topK: 40
+    }
+  };
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(`${endpoint}?key=${apiKey}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Gemini API error: ${response.status} - ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      // Extract image data from response
+      if (data.candidates && data.candidates[0]) {
+        const candidate = data.candidates[0];
+
+        // Gemini returns inline data or content references
+        if (candidate.content && candidate.content.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.inlineData && part.inlineData.data) {
+              return {
+                data: part.inlineData.data,
+                mimeType: part.inlineData.mimeType || 'image/png',
+                service: 'gemini',
+                cost: PRICING.gemini
+              };
+            }
+          }
+        }
+      }
+
+      throw new Error('No image data in Gemini response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ Gemini attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Generate image using Google Imagen 4 (via Vertex AI)
+ * Premium quality image generation
+ *
+ * Requires Vertex AI setup:
+ * - GOOGLE_CLOUD_PROJECT_ID environment variable
+ * - GOOGLE_CLOUD_LOCATION environment variable (default: us-central1)
+ * - GOOGLE_APPLICATION_CREDENTIALS pointing to service account key JSON
+ *
+ * @param {string} prompt - Image description
+ * @param {Object} options - Generation options
+ * @param {string} options.size - Image size (256x256, 1024x1024)
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated image data
+ */
+export async function generateImageImagen(prompt, options = {}) {
+  const {
+    size = '1024x1024',
+    maxRetries = 3
+  } = options;
+
+  // Vertex AI configuration
+  const projectId = process.env.GOOGLE_CLOUD_PROJECT_ID;
+  const location = process.env.GOOGLE_CLOUD_LOCATION || 'us-central1';
+
+  if (!projectId) {
+    throw new Error('GOOGLE_CLOUD_PROJECT_ID not configured. Set up Vertex AI credentials.');
+  }
+
+  // Build Vertex AI endpoint
+  const endpoint = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/imagen-4.0-generate-001:predict`;
+
+  const requestBody = {
+    instances: [{
+      prompt: prompt
+    }],
+    parameters: {
+      sampleCount: 1,
+      aspectRatio: size === '1024x1024' ? '1:1' : (size.includes('1792') ? '16:9' : '1:1'),
+      safetyFilterLevel: 'block_some',
+      personGeneration: 'allow_adult'
+    }
+  };
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      // Get OAuth2 access token
+      const token = await getVertexAIToken();
+
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Imagen API error: ${response.status} - ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      if (data.predictions && data.predictions[0]) {
+        const prediction = data.predictions[0];
+
+        // Imagen 4 returns base64-encoded image in bytesBase64Encoded
+        if (prediction.bytesBase64Encoded) {
+          return {
+            data: prediction.bytesBase64Encoded,
+            mimeType: prediction.mimeType || 'image/png',
+            service: 'imagen',
+            cost: PRICING.imagen
+          };
+        }
+      }
+
+      throw new Error('No image data in Imagen response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ Imagen attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Generate image using OpenAI DALL-E 3
+ * Creative, high-quality image generation
+ *
+ * @param {string} prompt - Image description
+ * @param {Object} options - Generation options
+ * @param {string} options.size - Image size (1024x1024, 1024x1792, 1792x1024)
+ * @param {string} options.quality - Quality level (standard, hd)
+ * @param {string} options.style - Style (vivid, natural)
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated image data with URL
+ */
+export async function generateImageDALLE(prompt, options = {}) {
+  const {
+    size = '1024x1024',
+    quality = 'high', // low, medium, or high
+    maxRetries = 3
+  } = options;
+
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error('OPENAI_API_KEY not configured');
+  }
+
+  const endpoint = `${OPENAI_API_BASE}/images/generations`;
+
+  // Try GPT-Image-1 first, fall back to DALL-E 3 if not available
+  const model = 'dall-e-3'; // Will use gpt-image-1 once org is verified
+
+  const requestBody = {
+    model: model,
+    prompt: prompt,
+    n: 1,
+    size: size,
+    ...(model === 'gpt-image-1' ? { quality } : { quality: quality === 'low' ? 'standard' : 'hd' })
+  };
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(`DALL-E API error: ${response.status} - ${errorData.error?.message || 'Unknown error'}`);
+      }
+
+      const data = await response.json();
+
+      if (data.data && data.data[0]) {
+        const image = data.data[0];
+
+        return {
+          url: image.url,
+          revisedPrompt: image.revised_prompt, // DALL-E often revises prompts
+          mimeType: 'image/png',
+          service: 'dalle',
+          cost: estimateCost('dalle', { quality, size })
+        };
+      }
+
+      throw new Error('No image data in DALL-E response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (error.message.includes('rate_limit')) {
+        if (attempt < maxRetries) {
+          const backoff = Math.pow(2, attempt) * 1000;
+          console.log(`⚠️ DALL-E rate limited. Retrying in ${backoff/1000}s...`);
+          await sleep(backoff);
+        }
+      } else {
+        throw error; // Don't retry on other errors
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Generate video using Google Veo 2
+ * AI video generation from text prompts
+ *
+ * @param {string} prompt - Video description
+ * @param {Object} options - Generation options
+ * @param {number} options.duration - Video duration in seconds (max 8)
+ * @param {string} options.aspectRatio - Aspect ratio (16:9, 9:16, 1:1)
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated video data
+ */
+export async function generateVideoVeo(prompt, options = {}) {
+  const {
+    duration = 5,
+    aspectRatio = '16:9',
+    maxRetries = 3
+  } = options;
+
+  const apiKey = process.env.GOOGLE_API_KEY;
+  if (!apiKey) {
+    throw new Error('GOOGLE_API_KEY not configured');
+  }
+
+  const endpoint = `${GOOGLE_API_BASE}/models/veo-2.0-generate-001:predict`;
+
+  const requestBody = {
+    instances: [{
+      prompt: prompt
+    }],
+    parameters: {
+      duration: Math.min(duration, 8), // Max 8 seconds
+      aspectRatio: aspectRatio,
+      quality: '720p'
+    }
+  };
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(`${endpoint}?key=${apiKey}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Veo API error: ${response.status} - ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      if (data.predictions && data.predictions[0]) {
+        const prediction = data.predictions[0];
+
+        // Veo returns video data or URL
+        if (prediction.videoData || prediction.url) {
+          return {
+            data: prediction.videoData,
+            url: prediction.url,
+            mimeType: 'video/mp4',
+            service: 'veo',
+            cost: PRICING.veo,
+            duration: duration
+          };
+        }
+      }
+
+      throw new Error('No video data in Veo response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 2000; // Longer backoff for video
+        console.log(`⚠️ Veo attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Generate image using Fal.ai
+ * Access to FLUX and other premium models
+ *
+ * @param {string} prompt - Image description
+ * @param {Object} options - Generation options
+ * @param {string} options.model - Fal.ai model (flux-pro, flux-dev, nano-banana, imagen-3-fast)
+ * @param {string} options.size - Image size
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated image data
+ */
+export async function generateImageFal(prompt, options = {}) {
+  const {
+    model = 'flux-pro',
+    size = '1024x1024',
+    maxRetries = 3
+  } = options;
+
+  const apiKey = process.env.FAL_KEY;
+  if (!apiKey) {
+    throw new Error('FAL_KEY not configured. Get your key from https://fal.ai/dashboard/keys');
+  }
+
+  // Import fal.ai client
+  const { fal } = await import('@fal-ai/client');
+
+  // Configure credentials
+  fal.config({ credentials: apiKey });
+
+  // Map model names to fal.ai endpoints
+  const modelMap = {
+    'flux-pro': 'fal-ai/flux-pro/v1.1-ultra',
+    'flux-dev': 'fal-ai/flux/dev',
+    'nano-banana': 'fal-ai/nano-banana',
+    'imagen-3-fast': 'fal-ai/fast-imagen'
+  };
+
+  const endpoint = modelMap[model] || modelMap['flux-pro'];
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fal.subscribe(endpoint, {
+        input: {
+          prompt: prompt,
+          image_size: size === '1024x1024' ? 'square' : 'landscape',
+          num_images: 1
+        },
+        logs: false
+      });
+
+      if (result.images && result.images[0]) {
+        const image = result.images[0];
+
+        // Fal.ai returns URL, need to fetch and convert to base64
+        const imageResponse = await fetch(image.url);
+        const imageBuffer = await imageResponse.arrayBuffer();
+        const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+        return {
+          data: base64Data,
+          mimeType: image.content_type || 'image/png',
+          service: 'fal',
+          model: model,
+          cost: PRICING[`${model.replace('-', '_')}`] || PRICING.flux_pro
+        };
+      }
+
+      throw new Error('No image data in Fal.ai response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ Fal.ai attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Generate video using Fal.ai (Veo 3)
+ * Latest video generation models
+ *
+ * @param {string} prompt - Video description
+ * @param {Object} options - Generation options
+ * @param {string} options.model - Model (veo3, veo3-fast)
+ * @param {number} options.duration - Video duration in seconds
+ * @param {string} options.aspectRatio - Aspect ratio
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated video data
+ */
+export async function generateVideoFal(prompt, options = {}) {
+  const {
+    model = 'veo3',
+    duration = 5,
+    aspectRatio = '16:9',
+    maxRetries = 3
+  } = options;
+
+  const apiKey = process.env.FAL_KEY;
+  if (!apiKey) {
+    throw new Error('FAL_KEY not configured. Get your key from https://fal.ai/dashboard/keys');
+  }
+
+  // Import fal.ai client
+  const { fal } = await import('@fal-ai/client');
+
+  // Configure credentials
+  fal.config({ credentials: apiKey });
+
+  const endpoint = model === 'veo3-fast' ? 'fal-ai/veo3-fast' : 'fal-ai/veo3';
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fal.subscribe(endpoint, {
+        input: {
+          prompt: prompt,
+          duration: Math.min(duration, 10),
+          aspect_ratio: aspectRatio
+        },
+        logs: false
+      });
+
+      if (result.video && result.video.url) {
+        // Fal.ai returns video URL
+        const videoResponse = await fetch(result.video.url);
+        const videoBuffer = await videoResponse.arrayBuffer();
+        const base64Data = Buffer.from(videoBuffer).toString('base64');
+
+        return {
+          data: base64Data,
+          mimeType: 'video/mp4',
+          service: 'fal',
+          model: model,
+          cost: PRICING.veo3 * duration
+        };
+      }
+
+      throw new Error('No video data in Fal.ai response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ Fal.ai video attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Download image from URL and return buffer
+ *
+ * @param {string} url - Image URL
+ * @returns {Promise<Buffer>} Image buffer
+ */
+export async function downloadImage(url) {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to download image: ${response.status}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+
+/**
+ * Generate image using auto-selected service
+ * Automatically selects best available service based on preferences
+ *
+ * @param {string} prompt - Image description
+ * @param {Object} options - Generation options
+ * @param {string} options.preferredService - Preferred service (gemini, imagen, dalle)
+ * @param {string} options.type - Image type for optimization (hero, illustration, diagram)
+ * @returns {Promise<Object>} Generated image data with buffer
+ */
+export async function generateImage(prompt, options = {}) {
+  const { preferredService, type = 'general', ...serviceOptions } = options;
+
+  // Select service
+  const defaultService = process.env.VISUAL_DEFAULT_SERVICE || 'gemini';
+  const service = selectBestService(preferredService || defaultService);
+
+  console.log(`🎨 Generating ${type} image using ${service}...`);
+
+  // Enhance prompt based on image type
+  const enhancedPrompt = enhancePrompt(prompt, type);
+
+  // Generate based on service
+  let result;
+  switch (service) {
+    case 'gemini':
+      result = await generateImageGemini(enhancedPrompt, serviceOptions);
+      break;
+
+    case 'imagen':
+      result = await generateImageImagen(enhancedPrompt, serviceOptions);
+      break;
+
+    case 'dalle':
+      result = await generateImageDALLE(enhancedPrompt, serviceOptions);
+      break;
+
+    case 'flux':
+    case 'flux-pro':
+    case 'flux-dev':
+      result = await generateImageFal(enhancedPrompt, { ...serviceOptions, model: service });
+      break;
+
+    default:
+      throw new Error(`Unknown service: ${service}`);
+  }
+
+  // Convert to buffer
+  let buffer;
+  if (result.data) {
+    // Base64 encoded data
+    buffer = Buffer.from(result.data, 'base64');
+  } else if (result.url) {
+    // Download from URL
+    buffer = await downloadImage(result.url);
+  } else {
+    throw new Error('No image data or URL in response');
+  }
+
+  return {
+    ...result,
+    buffer,
+    prompt: enhancedPrompt,
+    originalPrompt: prompt
+  };
+}
+
+/**
+ * Enhance prompt based on image type
+ *
+ * @param {string} prompt - Original prompt
+ * @param {string} type - Image type (hero, illustration, diagram, screenshot)
+ * @returns {string} Enhanced prompt
+ */
+function enhancePrompt(prompt, type) {
+  const enhancements = {
+    hero: 'Professional hero image, high quality, visually striking, suitable for article header:',
+    illustration: 'Clean illustration, professional style, clear and informative:',
+    diagram: 'Technical diagram, clear labels, professional design, easy to understand:',
+    screenshot: 'Professional screenshot, clean interface, high resolution:',
+    general: 'High quality image, professional style:'
+  };
+
+  const prefix = enhancements[type] || enhancements.general;
+  return `${prefix} ${prompt}`;
+}
+
+/**
+ * Sleep utility for retry backoff
+ *
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Get service information
+ *
+ * @param {string} service - Service name
+ * @returns {Object} Service information
+ */
+export function getServiceInfo(service) {
+  const info = {
+    gemini: {
+      name: 'Gemini 2.5 Flash Image',
+      nickname: 'Nano Banana',
+      speed: 'Fast',
+      cost: '$0.02/image',
+      quality: 'Good',
+      bestFor: 'Quick hero images, high volume',
+      provider: 'Google AI (Direct)'
+    },
+    imagen: {
+      name: 'Imagen 3',
+      nickname: 'Premium Quality',
+      speed: 'Medium',
+      cost: '$0.03/image',
+      quality: 'Excellent',
+      bestFor: 'Premium hero images, photorealistic',
+      provider: 'Google Vertex AI (Direct)'
+    },
+    dalle: {
+      name: 'DALL-E 3',
+      nickname: 'Creative',
+      speed: 'Medium',
+      cost: '$0.04-0.12/image',
+      quality: 'Excellent',
+      bestFor: 'Creative illustrations, concept art',
+      provider: 'OpenAI (Direct)'
+    },
+    veo: {
+      name: 'Veo 2',
+      nickname: 'Video Generation',
+      speed: 'Slow',
+      cost: '$0.10/video (estimated)',
+      quality: 'Good',
+      bestFor: 'Product demos, animated diagrams',
+      provider: 'Google AI (Direct)'
+    },
+    flux: {
+      name: 'FLUX Pro v1.1 Ultra',
+      nickname: 'Premium Artistic',
+      speed: 'Medium',
+      cost: '$0.06/image',
+      quality: 'Outstanding',
+      bestFor: 'Premium artistic images, highest quality',
+      provider: 'Fal.ai'
+    },
+    'flux-pro': {
+      name: 'FLUX Pro v1.1 Ultra',
+      nickname: 'Premium Artistic',
+      speed: 'Medium',
+      cost: '$0.06/image',
+      quality: 'Outstanding',
+      bestFor: 'Premium artistic images, highest quality',
+      provider: 'Fal.ai'
+    },
+    'flux-dev': {
+      name: 'FLUX Dev',
+      nickname: 'Developer Friendly',
+      speed: 'Fast',
+      cost: '$0.025/MP',
+      quality: 'Excellent',
+      bestFor: 'Developer workflows, rapid iteration',
+      provider: 'Fal.ai'
+    },
+    veo3: {
+      name: 'Veo 3',
+      nickname: 'Cutting Edge Video',
+      speed: 'Slow',
+      cost: '$0.40/second',
+      quality: 'Outstanding',
+      bestFor: 'Premium video content, latest features',
+      provider: 'Fal.ai'
+    }
+  };
+
+  return info[service] || null;
+}