myaidev-method 0.2.18 → 0.2.22

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

@@ -2,10 +2,17 @@
  * 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)
+ *
+ * RECOMMENDED SOTA MODELS:
+ * - Google Gemini 3.0 Pro Image ("Nano Banana") - fast, cost-effective
+ * - OpenAI GPT Image 1.5 - state-of-the-art quality, best text rendering
+ *
+ * ADDITIONAL MODELS:
+ * - Google Imagen 3 - premium quality via Gemini API
+ * - Black Forest Labs FLUX 2 (pro, flex, dev) - excellent quality
+ * - Google Veo 3 - latest video generation
+ *
+ * Authentication: Uses simple API keys (GEMINI_API_KEY, OPENAI_API_KEY, FAL_KEY)
  *
  * Platform support: Claude Code, Gemini CLI, Codex CLI
  *
@@ -16,92 +23,91 @@ 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 GEMINI_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();
+// Gemini Models for image generation
+const GEMINI_IMAGE_MODEL = 'gemini-3-pro-image-preview'; // Gemini 3.0 "Nano Banana" preview
+const GEMINI_IMAGEN_MODEL = 'imagen-3.0-generate-002'; // Imagen via Gemini API
 
-    if (!tokenResponse.token) {
-      throw new Error('Failed to obtain access token');
-    }
+// OpenAI GPT Image Models (SOTA)
+const OPENAI_IMAGE_MODELS = {
+  'gpt-image-1.5': 'gpt-image-1.5',      // State-of-the-art (recommended)
+  'gpt-image-1': 'gpt-image-1',           // Main model
+  'gpt-image-1-mini': 'gpt-image-1-mini'  // Cost-effective option
+};
 
-    return tokenResponse.token;
-  } catch (error) {
-    throw new Error(`Vertex AI authentication failed: ${error.message}`);
-  }
-}
+// FLUX 2 Models (via Fal.ai or BFL API)
+const FLUX2_MODELS = {
+  'flux2-pro': 'fal-ai/flux-2/pro',      // State-of-the-art quality, fastest, lowest cost
+  'flux2-flex': 'fal-ai/flux-2/flex',    // Developer-controlled parameters
+  'flux2-dev': 'fal-ai/flux-2/dev',      // 32B open-weight model
+  // Legacy FLUX 1.x models (still available)
+  'flux-pro': 'fal-ai/flux-pro/v1.1-ultra',
+  'flux-dev': 'fal-ai/flux/dev'
+};
 
-// Pricing (USD per image/video) - GPT-Image-1 pricing
+// Pricing (USD per image/video)
 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)
+  // SOTA Models (Recommended)
+  gemini: 0.02,              // Gemini 3.0 Pro Image "Nano Banana" - fast, cheap
+  'gpt-image-1.5': 0.19,     // OpenAI GPT Image 1.5 - SOTA quality (high quality)
+  'gpt-image-1.5-medium': 0.07,  // GPT Image 1.5 medium quality
+  'gpt-image-1.5-low': 0.02,     // GPT Image 1.5 low quality
+  'gpt-image-1': 0.19,       // OpenAI GPT Image 1 (high quality)
+  'gpt-image-1-mini': 0.02,  // OpenAI GPT Image 1 Mini - budget option
+  // Additional Models
+  imagen: 0.03,              // Imagen 3 (Gemini API)
+  // FLUX 2 pricing
+  flux2_pro: 0.05,           // FLUX 2 Pro
+  flux2_flex: 0.04,          // FLUX 2 Flex
+  flux2_dev: 0.025,          // FLUX 2 Dev
+  // Legacy FLUX 1.x
+  flux_pro: 0.06,            // FLUX Pro v1.1 Ultra
+  flux_dev: 0.025,           // FLUX Dev (per megapixel)
+  // Video
+  veo3: 0.40                 // Veo 3 (per second)
 };
 
 /**
  * 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;
+  // Support both GEMINI_API_KEY (preferred) and GOOGLE_API_KEY (legacy)
+  const geminiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
   const openaiKey = process.env.OPENAI_API_KEY;
   const falKey = process.env.FAL_KEY;
+  const bflKey = process.env.BFL_API_KEY; // Black Forest Labs direct API
 
-  const hasGoogle = !!(googleKey && googleKey.length > 20);
+  const hasGemini = !!(geminiKey && geminiKey.length > 20);
   const hasOpenAI = !!(openaiKey && openaiKey.length > 20);
   const hasFal = !!(falKey && falKey.length > 20);
+  const hasBFL = !!(bflKey && bflKey.length > 20);
 
   const availableServices = [];
-  if (hasGoogle) {
-    availableServices.push('gemini', 'imagen', 'veo');
+  if (hasGemini) {
+    availableServices.push('gemini', 'imagen');
   }
   if (hasOpenAI) {
-    availableServices.push('dalle');
+    availableServices.push('gpt-image-1.5', 'gpt-image-1', 'gpt-image-1-mini');
   }
-  if (hasFal) {
-    availableServices.push('flux', 'flux-pro', 'flux-dev', 'veo3');
+  if (hasFal || hasBFL) {
+    availableServices.push('flux2-pro', 'flux2-flex', 'flux2-dev', 'flux-pro', 'flux-dev', 'veo3');
   }
 
   return {
-    hasGoogle,
+    hasGemini,
+    hasGoogle: hasGemini, // Legacy compatibility
     hasOpenAI,
     hasFal,
-    hasAny: hasGoogle || hasOpenAI || hasFal,
+    hasBFL,
+    hasAny: hasGemini || hasOpenAI || hasFal || hasBFL,
     availableServices
   };
 }
@@ -109,14 +115,12 @@ export function validateAPIKeys() {
 /**
  * Estimate cost for image/video generation
  *
- * @param {string} service - Service name (gemini, imagen, dalle, veo)
+ * @param {string} service - Service name
  * @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;
+  const { quality = 'high' } = options;
 
   switch (service) {
     case 'gemini':
@@ -125,19 +129,26 @@ export function estimateCost(service, options = {}) {
     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
+    // OpenAI GPT Image models - cost varies by quality
+    case 'gpt-image-1.5':
+      if (quality === 'low') return PRICING['gpt-image-1.5-low'];
+      if (quality === 'medium') return PRICING['gpt-image-1.5-medium'];
+      return PRICING['gpt-image-1.5']; // high quality default
 
-    case 'veo':
-      return PRICING.veo;
+    case 'gpt-image-1':
+      return PRICING['gpt-image-1'];
+
+    case 'gpt-image-1-mini':
+      return PRICING['gpt-image-1-mini'];
+
+    case 'flux2-pro':
+      return PRICING.flux2_pro;
+
+    case 'flux2-flex':
+      return PRICING.flux2_flex;
+
+    case 'flux2-dev':
+      return PRICING.flux2_dev;
 
     case 'flux':
     case 'flux-pro':
@@ -166,7 +177,7 @@ 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.');
+    throw new Error('No API keys configured. Set GEMINI_API_KEY, OPENAI_API_KEY, or FAL_KEY in your environment.');
   }
 
   // Return preferred service if available
@@ -179,38 +190,44 @@ export function selectBestService(preferred = 'gemini') {
 }
 
 /**
- * Generate image using Google Gemini 2.5 Flash Image ("Nano Banana")
- * Fast and cost-effective image generation
+ * Generate image using Google Gemini API
+ * Uses gemini-3-pro-image-preview model ("Nano Banana") with simple API key auth
  *
  * @param {string} prompt - Image description
  * @param {Object} options - Generation options
- * @param {number} options.aspectRatio - Aspect ratio (1 for square, 16/9 for wide)
+ * @param {string} options.imageSize - Image size (1K, 2K)
  * @param {number} options.maxRetries - Maximum retry attempts
  * @returns {Promise<Object>} Generated image data
  */
 export async function generateImageGemini(prompt, options = {}) {
   const {
-    aspectRatio = 1,
+    imageSize = '1K',
     maxRetries = 3
   } = options;
 
-  const apiKey = process.env.GOOGLE_API_KEY;
+  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
   if (!apiKey) {
-    throw new Error('GOOGLE_API_KEY not configured');
+    throw new Error('GEMINI_API_KEY not configured. Set GEMINI_API_KEY in your environment.');
   }
 
-  const endpoint = `${GOOGLE_API_BASE}/models/gemini-2.0-flash-exp:generateContent`;
+  const endpoint = `${GEMINI_API_BASE}/models/${GEMINI_IMAGE_MODEL}: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`
-      }]
-    }],
+    contents: [
+      {
+        role: 'user',
+        parts: [
+          {
+            text: prompt
+          }
+        ]
+      }
+    ],
     generationConfig: {
-      temperature: 0.4,
-      topP: 0.95,
-      topK: 40
+      responseModalities: ['IMAGE', 'TEXT'],
+      imageConfig: {
+        image_size: imageSize
+      }
     }
   };
 
@@ -232,21 +249,38 @@ export async function generateImageGemini(prompt, options = {}) {
 
       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
-              };
-            }
+      // Handle streaming response format (array of candidates)
+      const candidates = Array.isArray(data) ? data : (data.candidates || [data]);
+
+      for (const candidate of candidates) {
+        const content = candidate.content || candidate;
+        const parts = content.parts || [];
+
+        for (const part of parts) {
+          // Check for inline image data
+          if (part.inlineData && part.inlineData.data) {
+            return {
+              data: part.inlineData.data,
+              mimeType: part.inlineData.mimeType || 'image/png',
+              service: 'gemini',
+              model: GEMINI_IMAGE_MODEL,
+              cost: PRICING.gemini
+            };
+          }
+
+          // Check for file data reference
+          if (part.fileData && part.fileData.fileUri) {
+            const imageResponse = await fetch(part.fileData.fileUri);
+            const imageBuffer = await imageResponse.arrayBuffer();
+            const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+            return {
+              data: base64Data,
+              mimeType: part.fileData.mimeType || 'image/png',
+              service: 'gemini',
+              model: GEMINI_IMAGE_MODEL,
+              cost: PRICING.gemini
+            };
           }
         }
       }
@@ -258,7 +292,7 @@ export async function generateImageGemini(prompt, options = {}) {
 
       if (attempt < maxRetries) {
         const backoff = Math.pow(2, attempt) * 1000;
-        console.log(`⚠️ Gemini attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        console.log(`⚠️ Gemini attempt ${attempt} failed: ${error.message}. Retrying in ${backoff / 1000}s...`);
         await sleep(backoff);
       }
     }
@@ -268,59 +302,45 @@ export async function generateImageGemini(prompt, options = {}) {
 }
 
 /**
- * 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
+ * Generate image using Google Imagen 3 (via Gemini API)
+ * Premium quality image generation with simple API key authentication
  *
  * @param {string} prompt - Image description
  * @param {Object} options - Generation options
- * @param {string} options.size - Image size (256x256, 1024x1024)
+ * @param {string} options.aspectRatio - Aspect ratio (1:1, 16:9, 9:16, 4:3, 3:4)
+ * @param {number} options.numberOfImages - Number of images to generate (1-4)
  * @param {number} options.maxRetries - Maximum retry attempts
  * @returns {Promise<Object>} Generated image data
  */
 export async function generateImageImagen(prompt, options = {}) {
   const {
-    size = '1024x1024',
+    aspectRatio = '1:1',
+    numberOfImages = 1,
     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.');
+  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+  if (!apiKey) {
+    throw new Error('GEMINI_API_KEY not configured. Set GEMINI_API_KEY in your environment.');
   }
 
-  // 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 endpoint = `${GEMINI_API_BASE}/models/${GEMINI_IMAGEN_MODEL}:generateImages`;
 
   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'
+    prompt: prompt,
+    config: {
+      numberOfImages: Math.min(numberOfImages, 4),
+      aspectRatio: aspectRatio,
+      safetyFilterLevel: 'BLOCK_MEDIUM_AND_ABOVE'
     }
   };
 
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
-      // Get OAuth2 access token
-      const token = await getVertexAIToken();
-
-      const response = await fetch(endpoint, {
+      const response = await fetch(`${endpoint}?key=${apiKey}`, {
         method: 'POST',
         headers: {
-          'Authorization': `Bearer ${token}`,
           'Content-Type': 'application/json'
         },
         body: JSON.stringify(requestBody)
@@ -333,15 +353,31 @@ export async function generateImageImagen(prompt, options = {}) {
 
       const data = await response.json();
 
-      if (data.predictions && data.predictions[0]) {
-        const prediction = data.predictions[0];
+      // Imagen returns images array with base64 encoded data
+      if (data.generatedImages && data.generatedImages[0]) {
+        const image = data.generatedImages[0];
 
-        // Imagen 4 returns base64-encoded image in bytesBase64Encoded
-        if (prediction.bytesBase64Encoded) {
+        if (image.image && image.image.imageBytes) {
           return {
-            data: prediction.bytesBase64Encoded,
-            mimeType: prediction.mimeType || 'image/png',
+            data: image.image.imageBytes,
+            mimeType: 'image/png',
             service: 'imagen',
+            model: GEMINI_IMAGEN_MODEL,
+            cost: PRICING.imagen
+          };
+        }
+      }
+
+      // Alternative response format
+      if (data.images && data.images[0]) {
+        const image = data.images[0];
+
+        if (image.bytesBase64Encoded || image.imageBytes) {
+          return {
+            data: image.bytesBase64Encoded || image.imageBytes,
+            mimeType: 'image/png',
+            service: 'imagen',
+            model: GEMINI_IMAGEN_MODEL,
             cost: PRICING.imagen
           };
         }
@@ -354,7 +390,7 @@ export async function generateImageImagen(prompt, options = {}) {
 
       if (attempt < maxRetries) {
         const backoff = Math.pow(2, attempt) * 1000;
-        console.log(`⚠️ Imagen attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        console.log(`⚠️ Imagen attempt ${attempt} failed: ${error.message}. Retrying in ${backoff / 1000}s...`);
         await sleep(backoff);
       }
     }
@@ -364,42 +400,56 @@ export async function generateImageImagen(prompt, options = {}) {
 }
 
 /**
- * Generate image using OpenAI DALL-E 3
- * Creative, high-quality image generation
+ * Generate image using OpenAI GPT Image API
+ * State-of-the-art image generation with best text rendering
+ *
+ * Features:
+ * - Best-in-class text rendering in images
+ * - Multiple quality tiers (low, medium, high)
+ * - Transparency support (PNG with transparent background)
+ * - Multiple output formats (PNG, JPEG, WebP)
  *
  * @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 {string} options.model - Model (gpt-image-1.5, gpt-image-1, gpt-image-1-mini)
+ * @param {string} options.size - Image size (1024x1024, 1536x1024, 1024x1536, auto)
+ * @param {string} options.quality - Quality level (low, medium, high, auto)
+ * @param {string} options.outputFormat - Output format (png, jpeg, webp)
+ * @param {string} options.background - Background type (transparent, opaque, auto)
  * @param {number} options.maxRetries - Maximum retry attempts
- * @returns {Promise<Object>} Generated image data with URL
+ * @returns {Promise<Object>} Generated image data
  */
-export async function generateImageDALLE(prompt, options = {}) {
+export async function generateImageOpenAI(prompt, options = {}) {
   const {
+    model = 'gpt-image-1.5',
     size = '1024x1024',
-    quality = 'high', // low, medium, or high
+    quality = 'high',
+    outputFormat = 'png',
+    background = 'auto',
     maxRetries = 3
   } = options;
 
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) {
-    throw new Error('OPENAI_API_KEY not configured');
+    throw new Error('OPENAI_API_KEY not configured. Get your key from https://platform.openai.com/api-keys');
   }
 
   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,
+    model: OPENAI_IMAGE_MODELS[model] || model,
     prompt: prompt,
     n: 1,
     size: size,
-    ...(model === 'gpt-image-1' ? { quality } : { quality: quality === 'low' ? 'standard' : 'hd' })
+    quality: quality,
+    output_format: outputFormat
   };
 
+  // Add background for PNG format (transparency support)
+  if (outputFormat === 'png' && background !== 'auto') {
+    requestBody.background = background;
+  }
+
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
@@ -413,37 +463,61 @@ export async function generateImageDALLE(prompt, options = {}) {
       });
 
       if (!response.ok) {
-        const errorData = await response.json();
-        throw new Error(`DALL-E API error: ${response.status} - ${errorData.error?.message || 'Unknown error'}`);
+        const errorText = await response.text();
+        let errorMessage = `OpenAI API error: ${response.status}`;
+        try {
+          const errorData = JSON.parse(errorText);
+          errorMessage = errorData.error?.message || errorMessage;
+        } catch {
+          errorMessage = `${errorMessage} - ${errorText}`;
+        }
+        throw new Error(errorMessage);
       }
 
       const data = await response.json();
 
+      // OpenAI returns base64-encoded image data
       if (data.data && data.data[0]) {
-        const image = data.data[0];
+        const imageData = 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 })
-        };
+        // Handle base64 response (primary)
+        if (imageData.b64_json) {
+          return {
+            data: imageData.b64_json,
+            mimeType: outputFormat === 'jpeg' ? 'image/jpeg' : outputFormat === 'webp' ? 'image/webp' : 'image/png',
+            service: 'openai',
+            model: model,
+            cost: estimateCost(model, { quality }),
+            revisedPrompt: imageData.revised_prompt
+          };
+        }
+
+        // Handle URL response (fallback)
+        if (imageData.url) {
+          const imageResponse = await fetch(imageData.url);
+          const imageBuffer = await imageResponse.arrayBuffer();
+          const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+          return {
+            data: base64Data,
+            mimeType: outputFormat === 'jpeg' ? 'image/jpeg' : outputFormat === 'webp' ? 'image/webp' : 'image/png',
+            service: 'openai',
+            model: model,
+            cost: estimateCost(model, { quality }),
+            revisedPrompt: imageData.revised_prompt
+          };
+        }
       }
 
-      throw new Error('No image data in DALL-E response');
+      throw new Error('No image data in OpenAI 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
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ OpenAI attempt ${attempt} failed: ${error.message}. Retrying in ${backoff / 1000}s...`);
+        await sleep(backoff);
       }
     }
   }
@@ -452,83 +526,110 @@ export async function generateImageDALLE(prompt, options = {}) {
 }
 
 /**
- * Generate video using Google Veo 2
- * AI video generation from text prompts
+ * Generate image using FLUX 2 (via Fal.ai)
+ * State-of-the-art image generation from Black Forest Labs
  *
- * @param {string} prompt - Video description
+ * Features:
+ * - Multi-reference support (up to 10 images)
+ * - Enhanced photorealism
+ * - Complex typography and UI mockups
+ * - Image editing up to 4 megapixels
+ *
+ * @param {string} prompt - Image 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 {string} options.model - FLUX 2 model (flux2-pro, flux2-flex, flux2-dev)
+ * @param {string} options.size - Image size (square, landscape, portrait)
+ * @param {number} options.steps - Number of inference steps (flux2-flex only)
+ * @param {number} options.guidance - Guidance scale (flux2-flex only)
+ * @param {Array<string>} options.referenceImages - Reference image URLs (up to 10)
  * @param {number} options.maxRetries - Maximum retry attempts
- * @returns {Promise<Object>} Generated video data
+ * @returns {Promise<Object>} Generated image data
  */
-export async function generateVideoVeo(prompt, options = {}) {
+export async function generateImageFlux2(prompt, options = {}) {
   const {
-    duration = 5,
-    aspectRatio = '16:9',
+    model = 'flux2-pro',
+    size = 'square',
+    steps = 28,
+    guidance = 3.5,
+    referenceImages = [],
     maxRetries = 3
   } = options;
 
-  const apiKey = process.env.GOOGLE_API_KEY;
+  const apiKey = process.env.FAL_KEY || process.env.BFL_API_KEY;
   if (!apiKey) {
-    throw new Error('GOOGLE_API_KEY not configured');
+    throw new Error('FAL_KEY not configured. Get your key from https://fal.ai/dashboard/keys');
   }
 
-  const endpoint = `${GOOGLE_API_BASE}/models/veo-2.0-generate-001:predict`;
+  // Import fal.ai client
+  const { fal } = await import('@fal-ai/client');
+  fal.config({ credentials: apiKey });
 
-  const requestBody = {
-    instances: [{
-      prompt: prompt
-    }],
-    parameters: {
-      duration: Math.min(duration, 8), // Max 8 seconds
-      aspectRatio: aspectRatio,
-      quality: '720p'
-    }
+  // Get endpoint for model
+  const endpoint = FLUX2_MODELS[model] || FLUX2_MODELS['flux2-pro'];
+
+  // Build input based on model capabilities
+  const input = {
+    prompt: prompt,
+    image_size: size === '1024x1024' ? 'square' : size,
+    num_images: 1
   };
 
+  // FLUX 2 Flex supports custom parameters
+  if (model === 'flux2-flex') {
+    input.num_inference_steps = steps;
+    input.guidance_scale = guidance;
+  }
+
+  // Add reference images if provided (FLUX 2 multi-reference feature)
+  if (referenceImages.length > 0) {
+    input.reference_images = referenceImages.slice(0, 10); // Max 10
+  }
+
   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)
+      const result = await fal.subscribe(endpoint, {
+        input,
+        logs: false
       });
 
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Veo API error: ${response.status} - ${errorText}`);
-      }
+      // Extract image from result
+      let imageUrl;
+      let contentType = 'image/png';
 
-      const data = await response.json();
+      if (result.data?.images?.[0]) {
+        imageUrl = result.data.images[0].url;
+        contentType = result.data.images[0].content_type || 'image/png';
+      } else if (result.images?.[0]) {
+        imageUrl = result.images[0].url;
+        contentType = result.images[0].content_type || 'image/png';
+      } else if (result.image?.url) {
+        imageUrl = result.image.url;
+      }
 
-      if (data.predictions && data.predictions[0]) {
-        const prediction = data.predictions[0];
+      if (imageUrl) {
+        // Fetch and convert to base64
+        const imageResponse = await fetch(imageUrl);
+        const imageBuffer = await imageResponse.arrayBuffer();
+        const base64Data = Buffer.from(imageBuffer).toString('base64');
 
-        // 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
-          };
-        }
+        return {
+          data: base64Data,
+          mimeType: contentType,
+          service: 'flux2',
+          model: model,
+          cost: PRICING[model.replace('-', '_')] || PRICING.flux2_pro
+        };
       }
 
-      throw new Error('No video data in Veo response');
+      throw new Error('No image data in FLUX 2 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...`);
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ FLUX 2 attempt ${attempt} failed: ${error.message}. Retrying in ${backoff / 1000}s...`);
         await sleep(backoff);
       }
     }
@@ -538,12 +639,12 @@ export async function generateVideoVeo(prompt, options = {}) {
 }
 
 /**
- * Generate image using Fal.ai
- * Access to FLUX and other premium models
+ * Generate image using legacy FLUX 1.x (via Fal.ai)
+ * Still available for backwards compatibility
  *
  * @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.model - FLUX model (flux-pro, flux-dev)
  * @param {string} options.size - Image size
  * @param {number} options.maxRetries - Maximum retry attempts
  * @returns {Promise<Object>} Generated image data
@@ -560,21 +661,10 @@ export async function generateImageFal(prompt, options = {}) {
     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'];
+  const endpoint = FLUX2_MODELS[model] || FLUX2_MODELS['flux-pro'];
 
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -588,26 +678,20 @@ export async function generateImageFal(prompt, options = {}) {
         logs: false
       });
 
-      // Fal.ai can return images in different formats
       let imageUrl;
       let contentType = 'image/png';
 
-      if (result.data && result.data.images && result.data.images[0]) {
+      if (result.data?.images?.[0]) {
         imageUrl = result.data.images[0].url;
         contentType = result.data.images[0].content_type || 'image/png';
-      } else if (result.images && result.images[0]) {
+      } else if (result.images?.[0]) {
         imageUrl = result.images[0].url;
         contentType = result.images[0].content_type || 'image/png';
-      } else if (result.image && result.image.url) {
+      } else if (result.image?.url) {
         imageUrl = result.image.url;
-      } else if (result.data && result.data[0] && result.data[0].url) {
-        imageUrl = result.data[0].url;
-      } else if (typeof result === 'string') {
-        imageUrl = result;
       }
 
       if (imageUrl) {
-        // Fal.ai returns URL, need to fetch and convert to base64
         const imageResponse = await fetch(imageUrl);
         const imageBuffer = await imageResponse.arrayBuffer();
         const base64Data = Buffer.from(imageBuffer).toString('base64');
@@ -617,7 +701,7 @@ export async function generateImageFal(prompt, options = {}) {
           mimeType: contentType,
           service: 'fal',
           model: model,
-          cost: PRICING[`${model.replace('-', '_')}`] || PRICING.flux_pro
+          cost: PRICING[model.replace('-', '_')] || PRICING.flux_pro
         };
       }
 
@@ -628,7 +712,7 @@ export async function generateImageFal(prompt, options = {}) {
 
       if (attempt < maxRetries) {
         const backoff = Math.pow(2, attempt) * 1000;
-        console.log(`⚠️ Fal.ai attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        console.log(`⚠️ Fal.ai attempt ${attempt} failed: ${error.message}. Retrying in ${backoff / 1000}s...`);
         await sleep(backoff);
       }
     }
@@ -638,8 +722,8 @@ export async function generateImageFal(prompt, options = {}) {
 }
 
 /**
- * Generate video using Fal.ai (Veo 3)
- * Latest video generation models
+ * Generate video using Veo 3 (via Fal.ai)
+ * Latest video generation with outstanding quality
  *
  * @param {string} prompt - Video description
  * @param {Object} options - Generation options
@@ -649,7 +733,7 @@ export async function generateImageFal(prompt, options = {}) {
  * @param {number} options.maxRetries - Maximum retry attempts
  * @returns {Promise<Object>} Generated video data
  */
-export async function generateVideoFal(prompt, options = {}) {
+export async function generateVideoVeo3(prompt, options = {}) {
   const {
     model = 'veo3',
     duration = 5,
@@ -662,10 +746,7 @@ export async function generateVideoFal(prompt, options = {}) {
     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';
@@ -682,29 +763,30 @@ export async function generateVideoFal(prompt, options = {}) {
         logs: false
       });
 
-      if (result.video && result.video.url) {
-        // Fal.ai returns video URL
+      if (result.video?.url) {
         const videoResponse = await fetch(result.video.url);
         const videoBuffer = await videoResponse.arrayBuffer();
         const base64Data = Buffer.from(videoBuffer).toString('base64');
 
         return {
           data: base64Data,
+          url: result.video.url,
           mimeType: 'video/mp4',
-          service: 'fal',
+          service: 'veo3',
           model: model,
-          cost: PRICING.veo3 * duration
+          cost: PRICING.veo3 * duration,
+          duration: duration
         };
       }
 
-      throw new Error('No video data in Fal.ai response');
+      throw new Error('No video data in Veo 3 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...`);
+        console.log(`⚠️ Veo 3 attempt ${attempt} failed: ${error.message}. Retrying in ${backoff / 1000}s...`);
         await sleep(backoff);
       }
     }
@@ -736,7 +818,7 @@ export async function downloadImage(url) {
  *
  * @param {string} prompt - Image description
  * @param {Object} options - Generation options
- * @param {string} options.preferredService - Preferred service (gemini, imagen, dalle)
+ * @param {string} options.preferredService - Preferred service
  * @param {string} options.type - Image type for optimization (hero, illustration, diagram)
  * @returns {Promise<Object>} Generated image data with buffer
  */
@@ -763,8 +845,17 @@ export async function generateImage(prompt, options = {}) {
       result = await generateImageImagen(enhancedPrompt, serviceOptions);
       break;
 
-    case 'dalle':
-      result = await generateImageDALLE(enhancedPrompt, serviceOptions);
+    // OpenAI GPT Image models (SOTA)
+    case 'gpt-image-1.5':
+    case 'gpt-image-1':
+    case 'gpt-image-1-mini':
+      result = await generateImageOpenAI(enhancedPrompt, { ...serviceOptions, model: service });
+      break;
+
+    case 'flux2-pro':
+    case 'flux2-flex':
+    case 'flux2-dev':
+      result = await generateImageFlux2(enhancedPrompt, { ...serviceOptions, model: service });
       break;
 
     case 'flux':
@@ -780,10 +871,8 @@ export async function generateImage(prompt, options = {}) {
   // 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');
@@ -797,6 +886,21 @@ export async function generateImage(prompt, options = {}) {
   };
 }
 
+/**
+ * Generate video using auto-selected service
+ *
+ * @param {string} prompt - Video description
+ * @param {Object} options - Generation options
+ * @returns {Promise<Object>} Generated video data
+ */
+export async function generateVideo(prompt, options = {}) {
+  const { preferredService = 'veo3', ...serviceOptions } = options;
+
+  console.log(`🎬 Generating video using ${preferredService}...`);
+
+  return await generateVideoVeo3(prompt, serviceOptions);
+}
+
 /**
  * Enhance prompt based on image type
  *
@@ -836,13 +940,14 @@ function sleep(ms) {
 export function getServiceInfo(service) {
   const info = {
     gemini: {
-      name: 'Gemini 2.5 Flash Image',
+      name: 'Gemini 3.0 Pro Image',
       nickname: 'Nano Banana',
       speed: 'Fast',
       cost: '$0.02/image',
       quality: 'Good',
       bestFor: 'Quick hero images, high volume',
-      provider: 'Google AI (Direct)'
+      provider: 'Google Gemini API (API Key)',
+      model: GEMINI_IMAGE_MODEL
     },
     imagen: {
       name: 'Imagen 3',
@@ -851,51 +956,97 @@ export function getServiceInfo(service) {
       cost: '$0.03/image',
       quality: 'Excellent',
       bestFor: 'Premium hero images, photorealistic',
-      provider: 'Google Vertex AI (Direct)'
+      provider: 'Google Gemini API (API Key)',
+      model: GEMINI_IMAGEN_MODEL
     },
-    dalle: {
-      name: 'DALL-E 3',
-      nickname: 'Creative',
+    // OpenAI GPT Image Models (SOTA)
+    'gpt-image-1.5': {
+      name: 'GPT Image 1.5',
+      nickname: 'State-of-the-Art',
       speed: 'Medium',
-      cost: '$0.04-0.12/image',
-      quality: 'Excellent',
-      bestFor: 'Creative illustrations, concept art',
-      provider: 'OpenAI (Direct)'
+      cost: '$0.02-$0.19/image',
+      quality: 'Outstanding',
+      bestFor: 'Best text rendering, highest quality, transparent backgrounds',
+      provider: 'OpenAI',
+      model: 'gpt-image-1.5',
+      features: ['Best-in-class text rendering', 'Transparency support', 'Multiple quality tiers', 'WebP/JPEG/PNG output'],
+      qualityTiers: {
+        low: '$0.02/image (~272 tokens)',
+        medium: '$0.07/image (~1056 tokens)',
+        high: '$0.19/image (~4160 tokens)'
+      }
     },
-    veo: {
-      name: 'Veo 2',
-      nickname: 'Video Generation',
-      speed: 'Slow',
-      cost: '$0.10/video (estimated)',
+    'gpt-image-1': {
+      name: 'GPT Image 1',
+      nickname: 'Premium Quality',
+      speed: 'Medium',
+      cost: '$0.19/image',
+      quality: 'Outstanding',
+      bestFor: 'High quality images, text rendering',
+      provider: 'OpenAI',
+      model: 'gpt-image-1',
+      features: ['Excellent text rendering', 'Multiple sizes', 'Transparency support']
+    },
+    'gpt-image-1-mini': {
+      name: 'GPT Image 1 Mini',
+      nickname: 'Cost-Effective',
+      speed: 'Fast',
+      cost: '$0.02/image',
       quality: 'Good',
-      bestFor: 'Product demos, animated diagrams',
-      provider: 'Google AI (Direct)'
+      bestFor: 'Quick images, budget-conscious, high volume',
+      provider: 'OpenAI',
+      model: 'gpt-image-1-mini',
+      features: ['Fast generation', 'Low cost', 'Good quality']
     },
-    flux: {
-      name: 'FLUX Pro v1.1 Ultra',
-      nickname: 'Premium Artistic',
+    'flux2-pro': {
+      name: 'FLUX 2 Pro',
+      nickname: 'State-of-the-Art',
+      speed: 'Fast',
+      cost: '$0.05/image',
+      quality: 'Outstanding',
+      bestFor: 'Best quality, fastest generation, lowest cost',
+      provider: 'Black Forest Labs (Fal.ai)',
+      model: 'flux-2/pro',
+      features: ['Multi-reference (up to 10 images)', 'Enhanced photorealism', 'Complex typography', 'UI mockups']
+    },
+    'flux2-flex': {
+      name: 'FLUX 2 Flex',
+      nickname: 'Developer Control',
       speed: 'Medium',
-      cost: '$0.06/image',
+      cost: '$0.04/image',
       quality: 'Outstanding',
-      bestFor: 'Premium artistic images, highest quality',
-      provider: 'Fal.ai'
+      bestFor: 'Custom parameters, fine-tuned control',
+      provider: 'Black Forest Labs (Fal.ai)',
+      model: 'flux-2/flex',
+      features: ['Custom inference steps', 'Guidance scale control', 'Developer-friendly']
+    },
+    'flux2-dev': {
+      name: 'FLUX 2 Dev',
+      nickname: 'Open-Weight',
+      speed: 'Fast',
+      cost: '$0.025/image',
+      quality: 'Excellent',
+      bestFor: 'Developer workflows, local deployment option',
+      provider: 'Black Forest Labs (Fal.ai)',
+      model: 'flux-2/dev',
+      features: ['32B parameters', 'Open-weight model', 'Local deployment available']
     },
     'flux-pro': {
       name: 'FLUX Pro v1.1 Ultra',
-      nickname: 'Premium Artistic',
+      nickname: 'Legacy Premium',
       speed: 'Medium',
       cost: '$0.06/image',
       quality: 'Outstanding',
-      bestFor: 'Premium artistic images, highest quality',
+      bestFor: 'Premium artistic images (legacy)',
       provider: 'Fal.ai'
     },
     'flux-dev': {
       name: 'FLUX Dev',
-      nickname: 'Developer Friendly',
+      nickname: 'Legacy Developer',
       speed: 'Fast',
       cost: '$0.025/MP',
       quality: 'Excellent',
-      bestFor: 'Developer workflows, rapid iteration',
+      bestFor: 'Developer workflows (legacy)',
       provider: 'Fal.ai'
     },
     veo3: {
@@ -905,7 +1056,7 @@ export function getServiceInfo(service) {
       cost: '$0.40/second',
       quality: 'Outstanding',
       bestFor: 'Premium video content, latest features',
-      provider: 'Fal.ai'
+      provider: 'Google (Fal.ai)'
     }
   };