Update app.py

app.py

@@ -1,154 +1,815 @@
-import gradio as gr
-import numpy as np
-import random
+"""
+Marketing Image Generator with Agent Review - Complete Gradio App
 
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
+Integrated single-file application that includes:
+1. Image Generator Agent (using Google Imagen)
+2. Image Reviewer Agent (using Google Gemini Vision) 
+3. Gradio UI for Hugging Face deployment
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
+This combines the functionality of the entire marketing image generation system
+into one deployable file for Hugging Face Spaces.
+"""
 
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
+import gradio as gr
+import os
+import base64
+import io
+import time
+import re
+import logging
+import asyncio
+from typing import Dict, Any, List, Optional
+from PIL import Image
+import google.generativeai as genai
+from google import genai as genai_sdk
 
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-MAX_SEED = np.iinfo(np.int32).max
+# Configuration
 MAX_IMAGE_SIZE = 1024
+DEFAULT_QUALITY_THRESHOLD = 0.8
 
+# Initialize Google API with multiple authentication methods
+def setup_google_auth():
+    """Setup Google authentication with multiple fallback options"""
+    
+    # Method 1: Try service account JSON (for Google Cloud APIs)
+    gcp_service_account = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON")
+    if gcp_service_account:
+        try:
+            import json
+            from google.oauth2 import service_account
+            import google.auth
+            
+            # Parse the service account JSON
+            service_account_info = json.loads(gcp_service_account)
+            credentials = service_account.Credentials.from_service_account_info(service_account_info)
+            
+            # Set up for Google Cloud APIs
+            os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = 'temp_service_account.json'
+            with open('temp_service_account.json', 'w') as f:
+                json.dump(service_account_info, f)
+            
+            logger.info("Google Cloud service account configured successfully")
+            return "service_account"
+            
+        except Exception as e:
+            logger.warning(f"Failed to setup service account: {e}")
+    
+    # Method 2: Try API keys (for Google AI Studio)
+    api_keys = [
+        os.getenv("GOOGLE_API_KEY"),
+        os.getenv("GOOGLE_AI_STUDIO_API_KEY"),
+        os.getenv("GCP_KEY_1"),
+        os.getenv("GCP_KEY_2"),
+        os.getenv("GCP_KEY_3")
+    ]
+    
+    google_api_key = next((key for key in api_keys if key), None)
+    if google_api_key:
+        try:
+            genai.configure(api_key=google_api_key)
+            logger.info("Google AI Studio API key configured successfully")
+            return google_api_key
+        except Exception as e:
+            logger.warning(f"Failed to configure API key: {e}")
+    
+    logger.warning("No Google authentication found - using fallback mode")
+    return None
 
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
-"""
+# Setup authentication
+GOOGLE_AUTH = setup_google_auth()
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
+# ====== IMAGE GENERATOR AGENT ======
 
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
+class ImageGeneratorAgent:
+    """Agent responsible for generating marketing images using Google Imagen"""
+    
+    def __init__(self):
+        self.name = "image_generator_agent"
+        
+    async def enhance_prompt(self, prompt: str, style: str) -> str:
+        """Enhance user prompt for better image generation"""
+        if not GOOGLE_AUTH:
+            # Basic enhancement without AI
+            style_enhancers = {
+                "realistic": "photorealistic, high detail, professional photography, marketing quality",
+                "artistic": "artistic masterpiece, creative composition, marketing appeal",
+                "cartoon": "cartoon style, vibrant colors, playful, marketing friendly",
+                "illustration": "professional illustration, clean design, marketing material",
+                "photographic": "professional photograph, high quality, studio lighting, marketing shot"
+            }
+            enhancer = style_enhancers.get(style, "high quality, professional")
+            return f"{prompt}, {enhancer}, 4K resolution, sharp focus"
+        
+        try:
+            enhancement_prompt = f"""
+            You are an expert prompt engineer for AI image generation. Enhance this marketing image prompt for optimal results with Google Imagen.
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
+            Original prompt: "{prompt}"
+            Desired style: "{style}"
 
-        result = gr.Image(label="Result", show_label=False)
+            Create an enhanced version that:
+            1. Maintains the core marketing intent
+            2. Adds specific technical details for image quality
+            3. Includes appropriate style descriptors for "{style}" style
+            4. Adds professional marketing composition guidance
+            5. Keeps the enhanced prompt under 150 words
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
+            Return only the enhanced prompt without explanation.
+            """
+            
+            model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            response = model.generate_content(enhancement_prompt)
+            enhanced = response.text.strip()
+            
+            logger.info(f"Enhanced prompt: {enhanced[:100]}...")
+            return enhanced
+            
+        except Exception as e:
+            logger.warning(f"Failed to enhance prompt with AI: {e}")
+            style_enhancers = {
+                "realistic": "photorealistic, high detail, professional photography, marketing quality",
+                "artistic": "artistic masterpiece, creative composition, marketing appeal", 
+                "cartoon": "cartoon style, vibrant colors, playful, marketing friendly",
+                "illustration": "professional illustration, clean design, marketing material",
+                "photographic": "professional photograph, high quality, studio lighting"
+            }
+            enhancer = style_enhancers.get(style, "high quality, professional")
+            return f"{prompt}, {enhancer}, 4K resolution, sharp focus"
+    
+    async def generate_image(self, prompt: str, style: str = "realistic") -> Dict[str, Any]:
+        """Generate image using Google Imagen"""
+        try:
+            # Enhance the prompt first
+            enhanced_prompt = await self.enhance_prompt(prompt, style)
+            
+            # Try Google Imagen API
+            if GOOGLE_AUTH:
+                image_data = await self._generate_with_imagen(enhanced_prompt)
+                if image_data:
+                    return {
+                        "success": True,
+                        "image_data": image_data,
+                        "enhanced_prompt": enhanced_prompt,
+                        "method": "Google Imagen"
+                    }
+            
+            # Fallback to placeholder for demo
+            return await self._generate_fallback(enhanced_prompt, style)
+            
+        except Exception as e:
+            logger.error(f"Image generation failed: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "enhanced_prompt": prompt
+            }
+    
+    async def _generate_with_imagen(self, enhanced_prompt: str) -> Optional[str]:
+        """Generate image using Google Imagen API"""
+        try:
+            # Handle different authentication methods
+            if GOOGLE_AUTH == "service_account":
+                # Use service account authentication
+                client = genai_sdk.Client()  # Will use GOOGLE_APPLICATION_CREDENTIALS
+            else:
+                # Use API key authentication
+                client = genai_sdk.Client(api_key=GOOGLE_AUTH)
+            
+            result = client.models.generate_images(
+                model="imagen-3.0-generate-002",
+                prompt=enhanced_prompt,
+                config={
+                    "number_of_images": 1,
+                    "output_mime_type": "image/png"
+                }
             )
+            
+            if result and hasattr(result, 'generated_images') and len(result.generated_images) > 0:
+                generated_image = result.generated_images[0]
+                
+                if hasattr(generated_image, 'image') and hasattr(generated_image.image, 'image_bytes'):
+                    image_bytes = generated_image.image.image_bytes
+                    base64_image = base64.b64encode(image_bytes).decode('utf-8')
+                    return f"data:image/png;base64,{base64_image}"
+            
+            return None
+            
+        except Exception as e:
+            logger.warning(f"Imagen API failed: {e}")
+            return None
+    
+    async def _generate_fallback(self, enhanced_prompt: str, style: str) -> Dict[str, Any]:
+        """Generate fallback placeholder image"""
+        try:
+            # Create a simple colored image based on prompt
+            import hashlib
+            prompt_hash = int(hashlib.md5(enhanced_prompt.encode()).hexdigest()[:8], 16)
+            
+            # Generate deterministic but varied colors
+            colors = [
+                (70, 130, 180),   # Steel Blue
+                (60, 179, 113),   # Medium Sea Green  
+                (255, 140, 0),    # Dark Orange
+                (106, 90, 205),   # Slate Blue
+                (220, 20, 60),    # Crimson
+                (255, 215, 0),    # Gold
+                (147, 112, 219),  # Medium Purple
+                (32, 178, 170)    # Light Sea Green
+            ]
+            
+            color = colors[prompt_hash % len(colors)]
+            img = Image.new('RGB', (1024, 1024), color)
+            
+            # Add some simple text overlay
+            try:
+                from PIL import ImageDraw, ImageFont
+                draw = ImageDraw.Draw(img)
+                
+                # Try to use a font, fallback to default
+                try:
+                    font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 48)
+                except:
+                    font = ImageFont.load_default()
+                
+                # Add text
+                text = f"Marketing Image\n{style.title()} Style"
+                draw.multiline_text((50, 450), text, fill=(255, 255, 255), font=font, align="center")
+                
+            except Exception as e:
+                logger.warning(f"Could not add text overlay: {e}")
+            
+            # Convert to base64
+            img_buffer = io.BytesIO()
+            img.save(img_buffer, format='PNG')
+            img_buffer.seek(0)
+            base64_image = base64.b64encode(img_buffer.read()).decode('utf-8')
+            
+            return {
+                "success": True,
+                "image_data": f"data:image/png;base64,{base64_image}",
+                "enhanced_prompt": enhanced_prompt,
+                "method": "Fallback Demo"
+            }
+            
+        except Exception as e:
+            logger.error(f"Fallback generation failed: {e}")
+            return {"success": False, "error": str(e)}
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-            )
+# ====== IMAGE REVIEWER AGENT ======
 
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+class ImageReviewerAgent:
+    """Agent responsible for reviewing generated images for quality and relevance"""
+    
+    def __init__(self):
+        self.name = "image_reviewer_agent"
+    
+    def parse_prompt_elements(self, prompt: str) -> Dict[str, List[str]]:
+        """Parse prompt to extract key elements for validation"""
+        prompt_lower = prompt.lower()
+        
+        # Define patterns for different element types
+        patterns = {
+            "subjects": [
+                r'\b(person|man|woman|child|people|human|figure|team|group)\b',
+                r'\b(product|device|phone|laptop|car|building|office|space)\b',
+                r'\b(logo|brand|company|business|service)\b'
+            ],
+            "style": [
+                r'\b(realistic|photorealistic|photograph|photo)\b',
+                r'\b(artistic|painting|drawing|illustration)\b',
+                r'\b(modern|contemporary|minimalist|professional)\b',
+                r'\b(cartoon|animated|3d|rendered)\b'
+            ],
+            "colors": [
+                r'\b(blue|red|green|yellow|orange|purple|pink|black|white|gray|grey)\b',
+                r'\b(bright|dark|light|vibrant|muted|pastel|neon)\b',
+                r'\b(colorful|monochrome|gradient)\b'
+            ],
+            "settings": [
+                r'\b(office|studio|outdoor|indoor|background|scene)\b',
+                r'\b(professional|corporate|casual|formal)\b',
+                r'\b(lighting|natural light|studio lighting)\b'
+            ],
+            "marketing": [
+                r'\b(marketing|advertisement|promotional|campaign|brand)\b',
+                r'\b(professional|business|corporate|commercial)\b',
+                r'\b(hero|banner|social media|web|digital)\b'
+            ]
+        }
+        
+        def extract_matches(patterns_list: List[str], text: str) -> List[str]:
+            matches = set()
+            for pattern in patterns_list:
+                found = re.findall(pattern, text)
+                matches.update(found)
+            return list(matches)
+        
+        return {
+            key: extract_matches(pattern_list, prompt_lower)
+            for key, pattern_list in patterns.items()
+        }
+    
+    async def review_image(self, image_data: str, original_prompt: str, enhanced_prompt: str) -> Dict[str, Any]:
+        """Review generated image for quality and relevance"""
+        try:
+            logger.info("Starting image review analysis")
+            
+            # Parse prompt elements
+            prompt_elements = self.parse_prompt_elements(original_prompt)
+            
+            # Try AI-powered review if API available
+            if GOOGLE_AUTH and image_data.startswith("data:image"):
+                ai_review = await self._ai_powered_review(image_data, original_prompt, enhanced_prompt, prompt_elements)
+                if ai_review:
+                    return ai_review
+            
+            # Fallback to prompt-based analysis
+            return await self._prompt_based_review(original_prompt, enhanced_prompt, prompt_elements)
+            
+        except Exception as e:
+            logger.error(f"Image review failed: {e}")
+            return self._fallback_review(original_prompt)
+    
+    async def _ai_powered_review(self, image_data: str, original_prompt: str, enhanced_prompt: str, prompt_elements: Dict) -> Optional[Dict[str, Any]]:
+        """Review image using Google Gemini Vision"""
+        try:
+            # Extract image from data URL
+            if not image_data.startswith("data:image"):
+                return None
+                
+            image_b64 = image_data.split(',')[1]
+            image_bytes = base64.b64decode(image_b64)
+            image = Image.open(io.BytesIO(image_bytes))
+            
+            # Create detailed analysis prompt
+            analysis_prompt = f"""
+            Analyze this marketing image that was generated from: "{original_prompt}"
+            Enhanced prompt used: "{enhanced_prompt}"
+            
+            Key elements to verify:
+            - Subjects: {', '.join(prompt_elements.get('subjects', []))}
+            - Style: {', '.join(prompt_elements.get('style', []))}
+            - Colors: {', '.join(prompt_elements.get('colors', []))}
+            - Setting: {', '.join(prompt_elements.get('settings', []))}
+            - Marketing elements: {', '.join(prompt_elements.get('marketing', []))}
+            
+            Rate the image on:
+            1. Technical Quality (0.0-1.0): clarity, composition, lighting, resolution
+            2. Prompt Relevance (0.0-1.0): how well it matches the original request
+            3. Marketing Effectiveness (0.0-1.0): professional appeal, brand suitability
+            
+            Provide response in this format:
+            QUALITY_SCORE: [0.0-1.0]
+            RELEVANCE_SCORE: [0.0-1.0] 
+            MARKETING_SCORE: [0.0-1.0]
+            
+            STRENGTHS: [List 2-3 strong points]
+            ISSUES: [List 2-3 improvement areas]
+            RECOMMENDATIONS: [List 2-3 specific suggestions]
+            
+            OVERALL_ASSESSMENT: [Brief summary of the image's marketing potential]
+            """
+            
+            model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            response = model.generate_content([analysis_prompt, image])
+            analysis_text = response.text
+            
+            return self._parse_ai_review(analysis_text, original_prompt)
+            
+        except Exception as e:
+            logger.warning(f"AI-powered review failed: {e}")
+            return None
+    
+    def _parse_ai_review(self, analysis_text: str, original_prompt: str) -> Dict[str, Any]:
+        """Parse AI review response into structured feedback"""
+        
+        def extract_score(text: str, score_type: str) -> float:
+            pattern = rf"{score_type}_SCORE:\s*([\d.]+)"
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                try:
+                    return min(1.0, max(0.0, float(match.group(1))))
+                except ValueError:
+                    pass
+            return 0.7
+        
+        def extract_list_section(text: str, section: str) -> List[str]:
+            pattern = rf"{section}:\s*(.+?)(?=\n[A-Z_]+:|$)"
+            match = re.search(pattern, text, re.IGNORECASE | re.DOTALL)
+            if match:
+                items_text = match.group(1).strip()
+                items = [item.strip().strip('-•*').strip() 
+                        for item in re.split(r'\n|,', items_text)
+                        if item.strip() and len(item.strip()) > 3]
+                return items[:3]  # Limit to 3 items
+            return []
+        
+        try:
+            # Extract scores
+            quality_score = extract_score(analysis_text, "QUALITY")
+            relevance_score = extract_score(analysis_text, "RELEVANCE")  
+            marketing_score = extract_score(analysis_text, "MARKETING")
+            
+            # Extract feedback sections
+            strengths = extract_list_section(analysis_text, "STRENGTHS")
+            issues = extract_list_section(analysis_text, "ISSUES")
+            recommendations = extract_list_section(analysis_text, "RECOMMENDATIONS")
+            
+            # Extract overall assessment
+            assessment_match = re.search(r"OVERALL_ASSESSMENT:\s*(.+?)(?=\n[A-Z_]+:|$)", 
+                                       analysis_text, re.IGNORECASE | re.DOTALL)
+            overall_assessment = assessment_match.group(1).strip() if assessment_match else "Good marketing image potential"
+            
+            # Calculate weighted overall score (emphasize marketing effectiveness)
+            overall_score = (quality_score * 0.3 + relevance_score * 0.4 + marketing_score * 0.3)
+            
+            # Determine pass/fail
+            passed = overall_score >= 0.7 and relevance_score >= 0.6
+            
+            return {
+                "success": True,
+                "overall_score": round(overall_score, 2),
+                "quality_score": round(quality_score, 2),
+                "relevance_score": round(relevance_score, 2),
+                "marketing_score": round(marketing_score, 2),
+                "passed": passed,
+                "strengths": strengths,
+                "issues": issues,
+                "recommendations": recommendations,
+                "overall_assessment": overall_assessment,
+                "review_method": "AI-Powered (Gemini Vision)"
+            }
+            
+        except Exception as e:
+            logger.error(f"Error parsing AI review: {e}")
+            return self._fallback_review(original_prompt)
+    
+    async def _prompt_based_review(self, original_prompt: str, enhanced_prompt: str, prompt_elements: Dict) -> Dict[str, Any]:
+        """Review based on prompt analysis when AI review isn't available"""
+        
+        issues = []
+        recommendations = []
+        strengths = []
+        
+        # Analyze prompt completeness
+        total_elements = sum(len(elements) for elements in prompt_elements.values())
+        
+        # Base scoring
+        if total_elements >= 8:
+            base_score = 0.8
+            strengths.append("Comprehensive prompt with detailed specifications")
+        elif total_elements >= 5:
+            base_score = 0.7
+            strengths.append("Good prompt detail level")
+        elif total_elements >= 3:
+            base_score = 0.6
+            issues.append("Prompt could use more specific details")
+        else:
+            base_score = 0.5
+            issues.append("Prompt lacks sufficient detail for optimal results")
+            recommendations.append("Add more specific details about subjects, style, and setting")
+        
+        # Check for marketing-specific elements
+        marketing_elements = prompt_elements.get('marketing', [])
+        if marketing_elements:
+            base_score += 0.1
+            strengths.append("Contains marketing-focused language")
+        else:
+            recommendations.append("Consider adding marketing-specific context")
+        
+        # Check for style specification
+        style_elements = prompt_elements.get('style', [])
+        if style_elements:
+            strengths.append(f"Clear style direction: {', '.join(style_elements[:2])}")
+        else:
+            issues.append("No clear artistic style specified")
+            recommendations.append("Specify desired artistic style (realistic, artistic, etc.)")
+        
+        # Check for subject clarity
+        subject_elements = prompt_elements.get('subjects', [])
+        if subject_elements:
+            strengths.append(f"Clear subjects identified: {', '.join(subject_elements[:2])}")
+        else:
+            issues.append("Main subjects not clearly specified")
+            recommendations.append("Clearly define what should be the main focus")
+        
+        # Calculate scores
+        quality_score = min(1.0, base_score + 0.1)  # Slight boost for quality
+        relevance_score = base_score  # Based on prompt completeness
+        marketing_score = base_score + (0.1 if marketing_elements else -0.1)
+        
+        overall_score = (quality_score * 0.3 + relevance_score * 0.4 + marketing_score * 0.3)
+        passed = overall_score >= 0.6
+        
+        return {
+            "success": True,
+            "overall_score": round(overall_score, 2),
+            "quality_score": round(quality_score, 2),
+            "relevance_score": round(relevance_score, 2),
+            "marketing_score": round(marketing_score, 2),
+            "passed": passed,
+            "strengths": strengths[:3],
+            "issues": issues[:3],
+            "recommendations": recommendations[:3],
+            "overall_assessment": f"Prompt-based analysis shows {'good' if passed else 'moderate'} marketing image potential",
+            "review_method": "Prompt Analysis"
+        }
+    
+    def _fallback_review(self, original_prompt: str) -> Dict[str, Any]:
+        """Fallback review when all else fails"""
+        word_count = len(original_prompt.split())
+        base_score = min(0.8, max(0.4, 0.4 + (word_count * 0.02)))
+        
+        return {
+            "success": True,
+            "overall_score": base_score,
+            "quality_score": base_score,
+            "relevance_score": base_score,
+            "marketing_score": base_score,
+            "passed": base_score >= 0.6,
+            "strengths": ["Prompt provided for image generation"],
+            "issues": ["Unable to perform detailed analysis"],
+            "recommendations": ["Consider regenerating with more detailed prompt"],
+            "overall_assessment": "Basic review completed",
+            "review_method": "Fallback"
+        }
 
-            with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
+# ====== MAIN APPLICATION WORKFLOW ======
 
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
+# Initialize agents
+generator_agent = ImageGeneratorAgent()
+reviewer_agent = ImageReviewerAgent()
 
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
-                )
+def generate_marketing_image_with_review(
+    prompt: str,
+    style: str = "realistic",
+    quality_threshold: float = 0.8,
+    max_iterations: int = 2,
+    progress=gr.Progress(track_tqdm=True)
+):
+    """
+    Main workflow: Generate image and review it
+    """
+    
+    if not prompt.strip():
+        return None, "Please enter a prompt to generate an image.", "❌ No Prompt", ""
+    
+    try:
+        progress(0.1, desc="Initializing generation workflow...")
+        
+        # Step 1: Generate image
+        progress(0.3, desc="Generating marketing image...")
+        generation_result = asyncio.run(generator_agent.generate_image(prompt, style))
+        
+        if not generation_result.get("success"):
+            error_msg = f"Image generation failed: {generation_result.get('error', 'Unknown error')}"
+            return None, error_msg, "❌ Generation Failed", ""
+        
+        image_data = generation_result["image_data"]
+        enhanced_prompt = generation_result["enhanced_prompt"]
+        
+        # Convert base64 to PIL Image for display
+        if image_data.startswith("data:image"):
+            image_b64 = image_data.split(',')[1]
+            image_bytes = base64.b64decode(image_b64)
+            display_image = Image.open(io.BytesIO(image_bytes))
+        else:
+            display_image = None
+        
+        progress(0.6, desc="Reviewing image quality...")
+        
+        # Step 2: Review the generated image
+        review_result = asyncio.run(reviewer_agent.review_image(image_data, prompt, enhanced_prompt))
+        
+        progress(0.9, desc="Finalizing results...")
+        
+        # Step 3: Format results
+        if review_result.get("success"):
+            # Build quality information display
+            quality_info = f"""
+## 🎯 Review Results
+
+**Overall Score:** {review_result['overall_score']:.2f}/1.0
+**Status:** {'✅ Approved' if review_result['passed'] else '⚠️ Needs Improvement'}
 
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
+### Detailed Scores
+- **Quality:** {review_result['quality_score']:.2f}/1.0
+- **Relevance:** {review_result['relevance_score']:.2f}/1.0  
+- **Marketing Appeal:** {review_result['marketing_score']:.2f}/1.0
+
+### 💪 Strengths
+{chr(10).join(f"• {strength}" for strength in review_result.get('strengths', []))}
+
+### ⚠️ Areas for Improvement
+{chr(10).join(f"• {issue}" for issue in review_result.get('issues', []))}
+
+### 💡 Recommendations
+{chr(10).join(f"• {rec}" for rec in review_result.get('recommendations', []))}
+
+### 📝 Assessment
+{review_result.get('overall_assessment', 'Review completed')}
+
+---
+*Review Method: {review_result.get('review_method', 'Standard')}*
+*Enhanced Prompt: {enhanced_prompt[:100]}...*
+            """
+            
+            review_status = "✅ Approved" if review_result['passed'] else "⚠️ Needs Review"
+            
+            # Add generation method info
+            debug_info = f"""
+**Generation Details:**
+- Method: {generation_result.get('method', 'Unknown')}
+- Original Prompt: {prompt}
+- Enhanced Prompt: {enhanced_prompt}
+- Style: {style}
+- API Status: {'✅ Connected' if GOOGLE_AUTH else '⚠️ Demo Mode'}
+            """
+            
+        else:
+            quality_info = f"Review failed: {review_result.get('error', 'Unknown error')}"
+            review_status = "❌ Review Failed" 
+            debug_info = f"Generation Method: {generation_result.get('method', 'Unknown')}"
+        
+        progress(1.0, desc="Complete!")
+        
+        return display_image, quality_info, review_status, debug_info
+        
+    except Exception as e:
+        logger.error(f"Workflow error: {str(e)}")
+        error_msg = f"Workflow failed: {str(e)}"
+        return None, error_msg, "❌ Error", f"Error details: {str(e)}"
+
+# ====== GRADIO INTERFACE ======
+
+def create_gradio_interface():
+    """Create the complete Gradio interface"""
+    
+    custom_css = """
+    .gradio-container {
+        max-width: 1400px !important;
+        margin: auto !important;
+    }
+    .header-text {
+        text-align: center;
+        color: #1f77b4;
+        margin-bottom: 2rem;
+    }
+    .quality-info {
+        background-color: #f8f9fa;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 4px solid #1f77b4;
+        font-family: monospace;
+    }
+    .status-approved { color: #28a745; font-weight: bold; }
+    .status-warning { color: #ffc107; font-weight: bold; }
+    .status-error { color: #dc3545; font-weight: bold; }
+    """
+    
+    with gr.Blocks(css=custom_css, title="Marketing Image Generator with AI Review") as interface:
+        
+        # Header
+        gr.Markdown("""
+        # 🎨 Marketing Image Generator with AI Review
+        ### Professional marketing images with automated quality assurance
+        
+        This system combines **Google Imagen** for image generation with **Google Gemini Vision** for intelligent quality review.
+        Perfect for creating professional marketing materials with AI-powered feedback.
+        """, elem_classes=["header-text"])
+        
+        # API Status indicator
+        api_status = "🟢 Google AI Connected" if GOOGLE_AUTH else "🟡 Demo Mode (No API Key)"
+        gr.Markdown(f"**Status:** {api_status}")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Input Section
+                gr.Markdown("## 📝 Describe Your Marketing Image")
+                
+                prompt = gr.Textbox(
+                    label="Marketing Image Description",
+                    placeholder="e.g., A professional team of diverse colleagues collaborating in a modern office space with natural lighting, for a corporate website hero image",
+                    lines=4,
+                    info="Be specific about subjects, setting, style, and intended marketing use"
+                )
+                
+                with gr.Row():
+                    style = gr.Dropdown(
+                        choices=["realistic", "artistic", "cartoon", "illustration", "photographic"],
+                        value="realistic",
+                        label="Art Style",
+                        info="Choose the visual style that fits your brand"
+                    )
+                    
+                    quality_threshold = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.7,
+                        step=0.1,
+                        label="Quality Threshold",
+                        info="Minimum score for approval (0.0 = lenient, 1.0 = strict)"
+                    )
+                
+                with gr.Accordion("🔧 Advanced Options", open=False):
+                    max_iterations = gr.Slider(
+                        minimum=1,
+                        maximum=3,
+                        value=2,
+                        step=1,
+                        label="Max Review Iterations",
+                        info="Maximum attempts to improve the image"
+                    )
+                
+                generate_btn = gr.Button(
+                    "🚀 Generate & Review Marketing Image",
+                    variant="primary",
+                    size="lg"
                 )
+            
+            with gr.Column(scale=3):
+                # Output Section
+                gr.Markdown("## 🖼️ Generated Image & Analysis")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        generated_image = gr.Image(
+                            label="Your Marketing Image",
+                            type="pil",
+                            interactive=False,
+                            height=400
+                        )
+                    
+                    with gr.Column(scale=1):
+                        review_status = gr.Textbox(
+                            label="Review Status",
+                            value="⏳ Ready to Generate",
+                            interactive=False,
+                            max_lines=1
+                        )
+                
+                quality_info = gr.Markdown(
+                    label="AI Quality Analysis",
+                    value="*Generate an image to see detailed AI quality analysis and recommendations*",
+                    elem_classes=["quality-info"]
+                )
+        
+        # Debug/Technical Info (Collapsible)
+        with gr.Accordion("🔧 Technical Details", open=False):
+            debug_info = gr.Markdown(
+                value="*Technical information will appear here after generation*"
+            )
+        
+        # Examples Section
+        gr.Markdown("## 💡 Example Marketing Prompts")
+        
+        examples = gr.Examples(
+            examples=[
+                ["A diverse team of professionals collaborating around a modern conference table in a bright office space, corporate website hero image", "realistic"],
+                ["A sleek product showcase featuring a smartphone on a clean white background with dramatic lighting, for e-commerce", "photographic"],
+                ["A friendly customer service representative wearing a headset, smiling while helping clients in a contemporary office", "realistic"],
+                ["A minimalist workspace setup with laptop, coffee, and plants, perfect for productivity app marketing", "artistic"],
+                ["An abstract representation of data flow and connectivity, modern tech company branding", "illustration"],
+                ["A celebration scene with confetti and happy people, perfect for achievement or success marketing", "realistic"]
+            ],
+            inputs=[prompt, style],
+            label="Click any example to try it out!"
+        )
+        
+        # Connect the workflow
+        generate_btn.click(
+            fn=generate_marketing_image_with_review,
+            inputs=[prompt, style, quality_threshold, max_iterations],
+            outputs=[generated_image, quality_info, review_status, debug_info],
+            show_progress=True
+        )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style='text-align: center; color: #666; font-size: 0.9rem;'>
+            <p>🎨 <strong>Marketing Image Generator with AI Review</strong></p>
+            <p>Powered by Google Imagen & Gemini Vision | Built for Professional Marketing Teams</p>
+            <p><em>Generate → Review → Perfect: Your AI-powered creative workflow</em></p>
+        </div>
+        """)
+    
+    return interface
 
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
-    )
+# ====== APPLICATION ENTRY POINT ======
+
+# Create the interface
+demo = create_gradio_interface()
 
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("Starting Marketing Image Generator with AI Review")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+    )